'use strict';

import Router from 'koa-router';
import moment from 'moment';
import _ from 'lodash';

import {Degrade, DegradeServer} from '../../models';

import getter from '../../zookeeper/getter';
import setter from '../../zookeeper/setter';

const router = new Router();

const ctl = {
    async getServer() {
        let server = await DegradeServer.findAll({});

        server = _.last(server);

        if (server) {
            return `${server.ip}:${server.port}`;
        } else {
            return 'localhost:2181';
        }
    },
    async index (ctx) {
        let count = await DegradeServer.count({});
        let render;

        if (count) {
            let serverPath = await ctl.getServer();
            let degrades = await Degrade.findAll();

            for (let i of degrades) {
                i.checked = await getter(serverPath, i.path);
            }

            let pc = _.filter(degrades, o => _.startsWith(o.path, '/pc'));
            let wap = _.filter(degrades, o => _.startsWith(o.path, '/wap'));

            let serverSplit = serverPath.split(':');
            render = {
                ip: serverSplit[0],
                port: serverSplit[1],
                render: {
                    pc: pc,
                    wap: wap
                }
            }
        }

        await ctx.render('action/degrade', render);
    },
    async server(ctx) {
        let ip = ctx.request.body.ip;
        let port = ctx.request.body.port;

        let serverCount = await DegradeServer.count({});

        // keep one server 
        if (serverCount) {
            let serverConfig = await DegradeServer.findAll({});
            let id = _.last(serverConfig)._id; // get the latest item

            await DegradeServer.update({
                _id: id
            }, {
                $set: {
                    ip: ip,
                    port: port
                }
            });
        } else {
            await DegradeServer.insert({
                ip: ip,
                port: port
            });
        }

        ctx.body = {
            code: 200,
            message: `${serverCount ? 'update' : 'new'} server success`
        };
    },
    async setter(ctx) {
        let {checked, id} = ctx.query;

        let theDegrade = await Degrade.findById(id);

        let path = theDegrade.path;

        let serverPath = await ctl.getServer();

        await setter(serverPath, path, checked.toString());

        ctx.body = {
            code: 200,
            message: 'update success'
        };
    }
};

router.get('/', ctl.index);
router.post('/server', ctl.server);
router.get('/setter', ctl.setter);

export default router;