import * as path from 'path';
import * as fs from 'fs';
import Application from '../application';
import { some_config } from './define';
import * as master from '../components/master';
import * as monitor from '../components/monitor';
import * as rpcServer from '../components/rpcServer';
import * as rpcService from '../components/rpcService';
import { FrontendServer } from '../components/frontendServer';
import { BackendServer } from '../components/backendServer';
import { ServerInfo } from './interfaceDefine';
import { msgCoderSetApp } from '../components/msgCoder';

/**
 * Load configuration
 * @param app
 */
export function defaultConfiguration(app: Application) {
    const args = parseArgs(process.argv);
    app.env = args.env || 'development';
    loadBaseConfig(app);
    processArgs(app, args);
}

/**
 * Start the server
 * @param app
 */
export function startServer(app: Application) {
    startPng(app);
    msgCoderSetApp(app);
    if (app.serverType === 'master') {
        master.start(app);
    } else if (app.frontend) {
        rpcService.init(app);
        app.frontendServer = new FrontendServer(app);

        rpcServer.start(app, function () {
            app.frontendServer.start(function () {
                monitor.start(app);
            });
        });
    } else {
        rpcService.init(app);
        app.backendServer = new BackendServer(app);

        rpcServer.start(app, function () {
            monitor.start(app);
        });
    }
};

export function getNoRpcKey(t1: string, t2: string) {
    if (t1 <= t2) {
        return t1 + '_' + t2;
    } else {
        return t2 + '_' + t1;
    }
}

const parseArgs = function (args: any[]) {
    const argsMap = {} as any;
    let mainPos = 1;

    while (args[mainPos].indexOf('--') > 0) {
        mainPos++;
    }
    argsMap.main = args[mainPos];

    for (let i = (mainPos + 1); i < args.length; i++) {
        const arg = args[i];
        const sep = arg.indexOf('=');
        const key = arg.slice(0, sep);
        // eslint-disable-next-line @typescript-eslint/restrict-plus-operands
        let value = arg.slice(sep + 1);
        if (!isNaN(Number(value)) && (value.indexOf('.') < 0)) {
            value = Number(value);
        } else if (value === 'true') {
            value = true;
        } else if (value === 'false') {
            value = false;
        }
        argsMap[key] = value;
    }

    return argsMap;
};

const loadBaseConfig = function (app: Application) {
    loadConfigBaseApp(app, 'masterConfig', path.join(some_config.File_Dir.Config, 'master.js'));
    loadConfigBaseApp(app, 'serversConfig', path.join(some_config.File_Dir.Config, 'servers.js'));
    loadConfigBaseApp(app, 'routeConfig', path.join(some_config.File_Dir.Config, 'route.js'));

    function loadConfigBaseApp(app: Application, key: 'masterConfig' | 'serversConfig' | 'routeConfig', val: string) {
        const env = app.env;
        const originPath = path.join(app.base, val);
        if (fs.existsSync(originPath)) {
            let file = require(originPath).default;
            if (key === 'masterConfig' || key === 'serversConfig') {
                if (!file[env]) {
                    console.error('ERROR-- no such environment: ' + key + '/' + env);
                    process.exit();
                }
                file = file[env];
            }
            if (key === 'serversConfig') {
                parseServersConfig(file);
            } else if (key === 'routeConfig') {
                const arr: string[][] = [];
                for (const one of file) {
                    arr.push((one as string).split('.'));
                }
                app.routeConfig2 = arr;
            }

            app[key] = file;
        } else {
            console.error('ERROR-- no such file: ' + originPath);
            process.exit();
        }
    }
};

/** Parse the servers configuration */
function parseServersConfig(info: Record<string, ServerInfo[]>) {
    for (const svrT in info) {
        const arr = info[svrT];
        for (let i = 0; i < arr.length;) {
            if ((arr[i].port as any) instanceof Array) {
                const one = arr[i];
                const newArr: ServerInfo[] = [];
                const idStart: number = one.idStart || 0;
                const port = (one.port as any)[0];
                const len = (one.port as any)[1] - (one.port as any)[0] + 1;
                for (let j = 0; j < len; j++) {
                    const tmpOne: any = JSON.parse(JSON.stringify(one));
                    tmpOne.id = one.id + (idStart + j).toString();
                    // eslint-disable-next-line @typescript-eslint/restrict-plus-operands
                    tmpOne.port = port + j;
                    if (one.clientPort) {
                        tmpOne.clientPort = one.clientPort + j;
                    }
                    newArr.push(tmpOne);
                }
                arr.splice(i, 1, ...newArr);
                i += len;
            } else {
                i++;
            }
        }
    }
}

const processArgs = function (app: Application, args: any) {
    app.main = args.main;
    const startAlone = !!args.id;
    app.serverId = args.id || app.masterConfig.id;
    app.isDaemon = !!args.isDaemon;
    if (app.serverId === app.masterConfig.id) {
        app.serverInfo = JSON.parse(JSON.stringify(app.masterConfig));
        (app.serverInfo as any).serverType = 'master';
        app.serverType = 'master';
        app.startMode = startAlone ? 'alone' : 'all';
    } else {
        app.startMode = args.startMode === 'all' ? 'all' : 'alone';
        let serverConfig: ServerInfo = null as any;
        for (const serverType in app.serversConfig) {
            for (const one of app.serversConfig[serverType]) {
                if (one.id === app.serverId) {
                    serverConfig = JSON.parse(JSON.stringify(one));
                    (serverConfig as any).serverType = serverType;
                    app.serverType = serverType;
                    break;
                }
            }
            if (serverConfig) {
                break;
            }
        }
        if (!serverConfig) {
            console.error('ERROR-- no such server: ' + app.serverId);
            process.exit();
        }
        app.serverInfo = serverConfig;
        app.frontend = !!serverConfig.frontend;

        const servers: Record<string, ServerInfo[]> = {};
        servers[app.serverType] = [];
        servers[app.serverType].push(serverConfig);
        app.servers = servers;
        app.serversIdMap.set(serverConfig.id, serverConfig);
    }
};

function startPng(app: Application) {
    if (app.serverType !== 'master' && app.startMode === 'all') {
        return;
    }
    const lines = [
        '  ※----------------------※',
        '  ※   ----------------   ※',
        '  ※  ( omelot  @linyng )  ※',
        '  ※   ----------------   ※',
        '  ※                      ※',
        '  ※                      ※',
        '  ※----------------------※'
    ];
    let version: string = require('../omelot').version;
    version = 'Ver: ' + version;
    console.log('      ');
    for (let i = 0; i < lines.length; i++) {
        if (i === 5) {
            let j: number;
            const chars = lines[i].split('');
            let len = chars.length - 2 - version.length;
            len = Math.floor(len / 2);
            const index = 2 + len;
            for (j = 0; j < version.length; j++) {
                chars[index + j] = version[j];
            }
            lines[i] = chars.join('');
        }
        console.log(lines[i]);
    }
    console.log('  ');
}