'use strict';

import Router from 'koa-router';
import moment from 'moment';
import Rp from 'request-promise';
import Build from '../../ci/build';
import Deploy from '../../ci/deploy';
import DeployPhp from '../../ci/deploy_php';
import Restart from '../../ci/restart';
import DeleteRestart from '../../ci/delete_restart';
import Operation from '../../logger/operation';
import ws from '../../../lib/ws';

const monit = require('../../ci/monit');

const DeployPool = require('../../ci/deploy_pool');

import {
    Building,
    Project,
    Server,
    DeployInfo,
    RestartInfo,
    DeleteRestartInfo
} from '../../models';

let r = new Router();

const colors = ['primary', 'success', 'info', 'warning', 'danger', 'success-alt', 'info-alt', 'warning-alt', 'danger-alt', 'primary-head', 'success-head', 'danger-head'];
const envs = {
    production: '线上环境',
    preview: '灰度环境',
    test: '测试环境'
};

const p = {
    /**
     * 所有项目首页
     */
    index_page: async(ctx, next) => {
        let projects = await Project.findAll();
        let awsProjects = [];
        let qcloudProject = [];

        projects.forEach((p, i) => {
            p.color = colors[i % colors.length];
            if (p.cloud === 'aws') {
                awsProjects.push(p);
            } else {
                qcloudProject.push(p);
            }

            awsProjects.sort((a, b) => {
                return a.name > b.name ? 1 : -1;
            });
            qcloudProject.sort((a, b) => {
                return a.name > b.name ? 1 : -1;
            });

            if (p.deploy) {
                Object.keys(p.deploy).forEach(k => {
                    if (typeof p.deploy[k].target === 'string') {
                        p.deploy[k].target = [p.deploy[k].target];
                    }
                });
            }
        });
        await ctx.render('action/projects', {
            awsProjects: awsProjects,
            qcloudProject: qcloudProject
        });
    },
    /**
     * 单个项目首页
     */
    project_index: async(ctx, next) => {
        let id = ctx.params.id;
        let env = ctx.request.query.env;
        let project = await Project.findById(id);
        let deploy = project.deploy[env] || {};
        deploy.env = env;
        deploy.name = envs[env];

        if (typeof deploy.target === 'string') {
            deploy.target = [deploy.target];
        }

        let promises = deploy.target.map((host) => {
            return DeployInfo.findOne({
                projectId: project._id,
                host: host,
                env: env
            }).then((info) => {
                return {
                    host: host,
                    hostFm: host.replace(/\./g, '-'),
                    info: info
                };
            });
        });
        let targets = await Promise.all(promises);

        targets.sort((a, b) => {
            return a.host > b.host ? 1 : -1;
        });

        await ctx.render('action/project_index', {
            project: project,
            deploy: deploy,
            targets: targets
        });
    },

    new_page: async(ctx, next) => {
        let serversAll = await Server.findAll();
        let servers = {};
        serversAll.forEach(s => {
            if (servers[s.env]) {
                servers[s.env].push(s);
            } else {
                servers[s.env] = [s];
            }
        });
        await ctx.render('action/project_form', {
            servers: servers,
            project: {
                deploy: {
                    production: {},
                    test: {}
                }
            }
        });

    },
    edit_page: async(ctx, next) => {
        let id = ctx.query.id;
        let project = await Project.findById(id);

        let serversAll = await Server.findAll();
        let servers = {};
        serversAll.forEach(s => {
            if (servers[s.env]) {
                servers[s.env].push(s);
            } else {
                servers[s.env] = [s];
            }
            if (project.deploy[s.env] && project.deploy[s.env].target && project.deploy[s.env].target.indexOf(s.host) >= 0) {
                s.checked = true;
            }
        });

        Object.keys(servers).forEach(key => {
            servers[key].sort((a, b) => {
                return a.host > b.host ? 1 : -1;
            });
        });

        await ctx.render('action/project_form', {
            project: project,
            servers: servers
        });
    },
    save: async(ctx, next) => {
        let project = ctx.request.body;
        let id = project._id;
        delete project._id;
        if (id) {
            await Project.update({
                _id: id
            }, {
                $set: project
            });
            await Operation.action(ctx.session.user, 'EDIT_PROJECT_INFO', '修改项目信息', {
                _id: id,
                name: project.name
            });
        } else {
            await Project.insert(project);
            await Operation.action(ctx.session.user, 'NEW_PROJECT_INFO', '新增项目信息', {
                _id: id,
                name: project.name
            });
        }
        ctx.redirect('/projects');
        ctx.status = 301;
    },
    buildings_table: async(ctx, next) => {
        let env = ctx.request.query.env;
        let pid = ctx.params.id;
        let buildings = await Building.cfind({
            env: env,
            projectId: pid
        }).sort({
            buildTime: -1
        }).limit(30).exec();
        buildings.forEach(b => {
            b.updatedAt = moment(b.updatedAt).format('YYYY-MM-DD HH:mm:ss');
        });
        ctx.body = {
            data: buildings
        };
    },
    project_build: async(ctx, next) => {
        let pid = ctx.params.pid;
        let env = ctx.request.body.env;
        let branch = ctx.request.body.branch;
        let p = await Project.findById(pid);
        let build = new Build(p);

        let {
            buildTime,
            distFile
        } = build.build(branch);
        let buildingDoc = await Building.insert({
            buildTime: buildTime,
            project: p.name,
            projectId: pid,
            branch: branch,
            env: env,
            distFile: distFile,
            state: 'waiting',
            createdAt: new Date(),
            updatedAt: new Date()
        });

        let id = buildingDoc[0]._id;

        build.run(id);

        await Operation.action(ctx.session.user, 'NEW_PROJECT_BUILDING', '新增项目构建', {
            _id: id,
            project: p.name,
            branch: branch,
            env: env
        });

        ctx.body = {
            code: 200,
            id: id
        };
        await next();
    },
    project_deploy: async(ctx) => {
        let buildingId = ctx.params.building;
        let building = await Building.findById(buildingId);
        if (!building) {
            ctx.body = {
                code: 201,
                msg: '该版本不存在'
            };
        } else if (building.state == 'success') {
            let project = await Project.findById(building.projectId);
            let targets = project.deploy[building.env].target;

            if (typeof targets === 'string') {
                targets = [targets];
            }

            targets.forEach(async(host) => {

                let doc = await DeployInfo.findOne({
                    projectId: project._id,
                    host: host,
                    env: building.env
                });

                if (!doc || doc.state !== 'running' || doc.building !== building.buildTime) {
                    let deploy = new Deploy(project, building, host);

                    // if (project.type === 'php') {
                    //     deploy = new DeployPhp(project, building, host);
                    // } else {
                    //     deploy = new Deploy(project, building, host);
                    // }
                    DeployPool.deploy(deploy);
                }
            });

            await Operation.action(ctx.session.user, 'PROJECT_DEPLOY', '项目分发部署', {
                _id: buildingId,
                project: project.name,
                branch: building.branch,
                env: building.env
            });

            ctx.body = {
                code: 200,
                building: building
            };
        } else {
            ctx.body = {
                code: 201,
                msg: '该版本未构建成功，暂不能分发'
            };
        }
    },
    project_restart: async(ctx) => {
        const projectId = ctx.request.body.id;
        const host = ctx.request.body.host;
        const env = ctx.request.body.env;
        const project = await Project.findById(projectId);

        if (!project) {
            ctx.body = {
                code: 201,
                msg: '该项目不存在'
            };
            return;
        }

        let hosts = [];
        if (host === 'all') {
            // 全部重启
            hosts = project.deploy[env].target;
        } else {
            // 单台重启
            hosts.push(host);
        }

        hosts.forEach(async(host) => {
            let doc = await DeployInfo.findOne({
                projectId: projectId,
                host: host,
                env: env
            });

            if (!doc) {
                return;
            }

            let info = {
                projectId: projectId,
                host: host,
                env: env,
                createdAt: new Date(),
                updatedAt: new Date(),
                state: 'waiting'
            };

            let restartDoc = await RestartInfo.insert(info);
            let restart = new Restart(project);

            info._id = restartDoc[0]._id;
            restart.restart(info);

            await Operation.action(ctx.session.user, 'PROJECT_RESTART', '项目重启', {
                _id: info._id,
                project: project.name,
                branch: project.deploy[env].branchName,
                env: env
            });
        });

        ctx.body = {
            code: 200
        };
    },
    project_deleterestart: async(ctx) => {
        const projectId = ctx.request.body.id;
        const host = ctx.request.body.host;
        const env = ctx.request.body.env;
        const project = await Project.findById(projectId);

        if (!project) {
            ctx.body = {
                code: 201,
                msg: '该项目不存在'
            };
            return;
        }

        let hosts = [];
        if (host === 'all') {
            // 全部重启
            hosts = project.deploy[env].target;
        } else {
            // 单台重启
            hosts.push(host);
        }

        hosts.forEach(async(host) => {
            let doc = await DeployInfo.findOne({
                projectId: projectId,
                host: host,
                env: env
            });

            if (!doc) {
                return;
            }

            let info = {
                projectId: projectId,
                host: host,
                env: env,
                createdAt: new Date(),
                updatedAt: new Date(),
                state: 'waiting'
            };

            let delrestartDoc = await DeleteRestartInfo.insert(info);
            let deleteRestart = new DeleteRestart(project);

            info._id = delrestartDoc[0]._id;
            deleteRestart.deleteRestart(info);

            await Operation.action(ctx.session.user, 'PROJECT_DELETERESTART', '项目删除重启', {
                _id: info._id,
                project: project.name,
                branch: project.deploy[env].branchName,
                env: env
            });
        });

        ctx.body = {
            code: 200
        };
    },
    project_monit: async(ctx) => {
        const projectId = ctx.request.body.id;
        const env = ctx.request.body.env;
        const project = await Project.findById(projectId);
        if (!project) {
            ctx.body = {
                code: 201,
                msg: '该项目不存在'
            };
            return;
        }

        let hosts = [];
        let target = project.deploy[env].target;
        if (typeof target === 'string') {
            hosts.push(target);
        } else {
            hosts = target;
        }
        
        if (project.type === 'php') {
            monit.php(project, hosts);
        } else {
            monit.node(project, hosts);
        }
        ctx.body = {
            code: 200
        };
    }
};

r.get('/', p.index_page);
r.get('/new', p.new_page);
r.get('/edit', p.edit_page);
r.get('/:id', p.project_index);
r.get('/:id/buildings', p.buildings_table);
r.post('/save', p.save);
r.post('/build/:pid', p.project_build);
r.post('/deploy/:building', p.project_deploy);
r.post('/restart', p.project_restart);
r.post('/deleterestart', p.project_deleterestart);
r.post('/monit', p.project_monit);
export default r;