/**
 * @author Martin Karkowski
 * @email m.karkowski@zema.de
 * @create date 2020-11-11 13:27:58
 * @modify date 2020-11-14 17:53:35
 * @desc [description]
 */

import { ArgumentParser } from "argparse";
import { readFile } from "fs/promises";
import "reflect-metadata";
import { AmqpLayer } from "../communication/amqpLayer";
import { EventLayer } from "../communication/eventLayer";
import { IoSocketClient } from "../communication/IoSocketClient";
import { IoSocketServer } from "../communication/IoSocketServer";
import { getPackageLoader } from "../loader/getPackageLoader";
import { loadFunctions, loadPackages } from "../loader/loadPackages";
import { getNopeLogger } from "../logger/getLogger";
import { LoggerLevels } from "../logger/nopeLogger";
import { setGlobalLoggerLevel } from "../logger/setGlobalLoggerLevel";
import { INopePackageLoader } from "../types/nope/nopePackageLoader.interface";


// Define the Main Function.
// This function is used as cli tool.
export async function runNopeBackend() {

    const parser = new ArgumentParser({
        version: "1.0.0",
        addHelp: true,
        description: "Command Line interface, determines the available Packages."
    });

    const validLayers= {
        "event": EventLayer,
        "amqp": AmqpLayer,
        "io-server": IoSocketServer,
        "io-client": IoSocketClient
    };

    const layerDefaults= {
        "event": [],
        "amqp": ["localhost"],
        "io-server": [7000],
        "io-client": ["http://localhost:7000"]
    };

    let opts: {
        params: any[],
    };

    try{
        // Try to read in the default config file.
        opts = JSON.parse(await readFile("./nopeconfig.json", {
            encoding: "utf-8"
        }));
        
    } catch (error) {
        opts = {} as any;
    }

    parser.addArgument(
        ["-f", "--file"],
        {
            help: "File containing containing the package definitions.",
            defaultValue: "./config/settings.json",
            type: "string",
            dest: "file"
        }
    );
    parser.addArgument(
        ["-c", "--channel"],
        {
            help: "The Communication Channel, which should be used. Possible Values are: " + 
                // Display all Options:
                Object.getOwnPropertyNames(validLayers).map(item => "\"" + item + "\"").join(", "),
            defaultValue: "event",
            type: "string",
            dest: "channel"
        }
    );
    parser.addArgument(
        ["-p", "--params"],
        {
            help: "Paramas for the Channel, to connect to. The Following Defaults are used: \n" + JSON.stringify(layerDefaults, undefined, 4),
            defaultValue: "not-provided",
            type: "string",
            dest: "params"
        }
    );
    parser.addArgument(
        ["-s", "--skipLoadingConfig"],
        {
            help: "Flag to prevent loading the elements defined in the settings.json.",
            action: "append", nargs: "?",
            dest: "skipLoadingConfig"
        }
    );
    parser.addArgument(
        ["-l", "--log"],
        {
            help: "Specify the Logger Level. Defaults to \"info\". Valid values are: " + LoggerLevels.join(", "),
            defaultValue: "silly",
            type: "string",
            dest: "log"
        }
    );

    const args = parser.parseArgs();

    if (LoggerLevels.includes(args.log)){
        setGlobalLoggerLevel(args.log);
    }    

    args.skipLoadingConfig = Array.isArray(args.skipLoadingConfig);

    // Define a Logger
    const logger = getNopeLogger("starter");

    if ( !Object.getOwnPropertyNames(validLayers).includes(args.channel)) {
        logger.error("Invalid Channel. Please use the following values. " + Object.getOwnPropertyNames(validLayers).map(item => "\"" + item + "\"").join(", "));
        return;
    }

    // Assign the Default Setting for the Channel.
    opts.params = layerDefaults[args.channel];

    if (args.params != "not-provided"){
        try {
            opts.params = JSON.parse(args.params);
        } catch (e) {
            logger.error("Unable to parse the Parameters for the channel. Please use valid JSON!");
            return;
        }
    }

    // If required load all Packages.
    if (!args.skipLoadingConfig){
        // Try to load the Modules.
        try {
            logger.info("loading Functions");
            await loadFunctions(args.file);
        } catch (e) {
            logger.error("Unable to load the Packages defined in " + args.file + " See Output for detailled information");
            console.error(e);
            return;
        }
    }


    let loader: INopePackageLoader;
    try {
        loader = getPackageLoader({
            communicator: new validLayers[args.channel](...opts.params),
            logger: getNopeLogger("dispatcher", "silly")
        });
    } catch (e){

    }


    // If required load all Packages.
    if (!args.skipLoadingConfig){
        // Try to load the Modules.
        try {
            logger.info("loading Packages");
            await loadPackages(loader, args.file);
        } catch (e) {
            logger.error("Unable to load the Packages defined in " + args.file + " See Output for detailled information");
            console.error(e);
            return;
        }
    }

    return loader.dispatcher;
}

// If requested As Main => Perform the Operation.
if (require.main === module) {
    runNopeBackend().catch(console.error);
}