#!/usr/bin/env node
import program = require('commander');
import { exec, execSync } from 'child_process';
import fs = require('fs');
import { packageJson, tsconfigJson, apiConfig, list, cliConfigTemplate, globalVars, environmentLoaderHelper, currentEnvironmentContent, localEnvironmentContent, bootstrapFile, environmentInterface, envinrmentsDirectoryIndex } from './source/config';
import { Instances, CreateRoutesFiles, ControllerTemplate, LoadControllersScriptTemplate } from '@codeplace/express-extensions';
import * as path from 'path';
const cliConfigsFileName = 'app.config.json';

interface CLIConfigs {
    controllersDirectory: string;
    routesDirectory: string;
    loadControllersScript: string;
}

program
  .command('create <type> <name> <package-name>')
  .option('-p, --list <items>', 'Packages to includes in creation', list)
  .action(function (type, packageRootFolder, packageName, cmd) {

        type = type.toLowerCase();
        const directoryExists = fs.existsSync(`./${packageRootFolder}`);
        const packages: string[] = cmd.list ? cmd.list : [];

        if(!directoryExists) {

            // In commmon
            fs.mkdirSync(`./${packageRootFolder}`);
            console.log('Directory created.');
            fs.mkdirSync(`./${packageRootFolder}/source`);
            console.log('Source dir created.');
            fs.writeFileSync(`./${packageRootFolder}/package.json`, packageJson(type, packageName));
            console.log('package.json created.');
            fs.writeFileSync(`./${packageRootFolder}/tsconfig.json`, tsconfigJson());
            console.log('tsconfig.json created.');
            const buffer = execSync(`cd ./${packageRootFolder} && npm install typescript --save-dev`);
            process.stdout.write(buffer);

            // Install packages
            packages.forEach((pack) => { 
                const buffer = execSync(`cd ./${packageRootFolder} && npm install ${pack} --save`) 
                process.stdout.write(buffer);
            });
        
            // Actions to specified command
            switch(type) {
                case 'api':     
                    exec(`cd ./${packageRootFolder} && npm install @codeplace/express-extensions --save`).stdout.pipe(process.stdout);

                    // Root
                    fs.writeFileSync(`./${packageRootFolder}/index.ts`, `require('./source/server')`);
                    fs.writeFileSync(`./${packageRootFolder}/source/server.ts`, `${apiConfig()}`);
                    fs.writeFileSync(`./${packageRootFolder}/source/globalVars.ts`, `${globalVars()}`);

                    // Controllers
                    fs.mkdirSync(`./${packageRootFolder}/source/controllers`);

                    // Config
                    fs.mkdirSync(`./${packageRootFolder}/source/config`);
                    fs.writeFileSync(`./${packageRootFolder}/source/config/loadControllers.ts`, `${LoadControllersScriptTemplate()}`);
                    fs.writeFileSync(`./${packageRootFolder}/source/config/bootstrap.ts`, `${bootstrapFile()}`);

                    //Routes
                    fs.mkdirSync(`./${packageRootFolder}/source/routes`);

                    // Models
                    fs.mkdirSync(`./${packageRootFolder}/source/models`);

                    // Interfaces
                    fs.mkdirSync(`./${packageRootFolder}/source/interfaces`);
                    fs.writeFileSync(`./${packageRootFolder}/source/interfaces/Environment.ts`, `${environmentInterface()}`);
                    fs.writeFileSync(`./${packageRootFolder}/source/interfaces/index.ts`, `${envinrmentsDirectoryIndex()}`);

                    // Helpers
                    fs.mkdirSync(`./${packageRootFolder}/source/helpers`);
                    fs.writeFileSync(`./${packageRootFolder}/source/helpers/EnvironmentLoader.ts`, `${environmentLoaderHelper()}`);

                    // Environments
                    fs.mkdirSync(`./${packageRootFolder}/source/environments`);
                    fs.writeFileSync(`./${packageRootFolder}/source/environments/current.env.json`, `${currentEnvironmentContent()}`);
                    fs.writeFileSync(`./${packageRootFolder}/source/environments/local.env.json`, `${localEnvironmentContent()}`);


                    fs.writeFileSync(path.resolve(process.cwd(), packageRootFolder, cliConfigsFileName), cliConfigTemplate());
                    break;

                case 'lib':
                    fs.writeFileSync(`./${packageRootFolder}/index.ts`, `export * from './source'`);
                    break;
            }
        } else {
            console.log('A Directory with the specified name already exists')
        }
  });

program
    .command('controller <name> <prefix> <version>')
    .action(function (name, prefix, version, cmd) {
    
        const cliConfigs = getCLIConfigs();
        const versionDirectory = `./${cliConfigs.controllersDirectory}/v${version}`;
        console.log(`Controller destination directory: ${versionDirectory}`);

        const directoryExists = fs.existsSync(versionDirectory);
        if(!directoryExists) fs.mkdirSync(versionDirectory);

        const controllerName = `${name}Controller.ts`;
        const controllerPath = path.resolve(versionDirectory, controllerName);
        if(fs.existsSync(controllerPath)) return console.log(`${name}Controller already exists!`) ;

        // Create controller
        fs.writeFileSync(controllerPath, ControllerTemplate(name, version, prefix));

        // Create routes // wait typescript compile js
        setTimeout(() => {
            runRoutesFilesCreator();
        }, 800);
    });

program
    .command('routes')
    .action(function (cmd) {
        runRoutesFilesCreator();
    });

program.parse(process.argv);

function runRoutesFilesCreator() {
    const cliConfigs = getCLIConfigs();
    const loadControllersScript = getLoadControllersScript(cliConfigs);
    const destinationDirectory = getRoutesDestinationDirectory(cliConfigs);
    callRoutesFilesCreator(destinationDirectory, loadControllersScript);
}

function getRoutesDestinationDirectory(cliConfigs: CLIConfigs) {
    const rootDirectory = process.cwd();
    const destinationDirectory = path.resolve(rootDirectory, cliConfigs.routesDirectory);
    console.log(`Routes destination directory: ${destinationDirectory}`);
    return destinationDirectory;
}

function getLoadControllersScript(cliConfigs: CLIConfigs) {
    const rootDirectory = process.cwd();
    const loadControllersScript = path.resolve(rootDirectory, cliConfigs.loadControllersScript)
    console.log(`Load controllers script: ${loadControllersScript}`);
    
    return loadControllersScript;
}

function callRoutesFilesCreator(destinationDirectory: string, loadControllersScript: string) {

    try {
        
        const instances: Instances = require(loadControllersScript);
        console.log(`Available controllers: ${Object.getOwnPropertyNames(instances)}`);
        
        CreateRoutesFiles(instances, destinationDirectory);
        console.log(`Routes created!`);
    } catch (error) {
        console.error(error.message);
    }
}

function getCLIConfigs() { 

    const rootDirectory = process.cwd(); 
    const cliConfigsPath = path.resolve(rootDirectory, cliConfigsFileName);
    if(!fs.existsSync(cliConfigsPath)) {
        console.log('CLI configs not found!'); 
        process.exit(); 
    }

    const cliConfigs = require(cliConfigsPath) as CLIConfigs;
    console.log('CLI configs loaded!');
    return cliConfigs;
}