import { DFWConfig, DFWScheme, DFWModuleSchema } from "../..";
import DatabaseManager, { Database } from "../modules/DatabaseManager";
import SessionManager, { DFWSessionSchema } from "../modules/SessionManager";
import APIManager, { DFWAPISchema } from "../modules/APIManager";
import SecurityManager, { DFWSecuritySchema } from "../modules/SecurityManager";
import { AddressInfo } from "net";
import { Express, Response, Request, NextFunction , json as JSONMiddleware , urlencoded as URLEncodedMiddleware , static as StaticMiddleware } from "express";
import UploadManager, { DFWFileSystemSchema } from "../modules/UploadManager";
import cookieParser = require("cookie-parser");

declare global {
    namespace Express {
        interface Request {
            dfw?: DFWScheme;
        }
    }
}

export default class DFWInstance {

    /**
     * default DFW config
     */
    public config: DFWConfig = {
        server:{}
    };

    /**
    * 
    */
    public modules:DFWModuleSchema;

    /**
     * 
     */
    public server = require("express")() as Express;

    public port!:number;

    /** 
     * Initialices all dependencies and middlewares for DFW
     */
    public constructor(config?: DFWConfig) {

        this.config = Object.assign({},this.config,config?config:{});

        this.modules = {
            "APIManager"        : new APIManager(this),
            "databaseManager"   : new DatabaseManager(this),
            "sessionManager"    : new SessionManager(this),
            "securityManager"   : new SecurityManager(this),
            "uploadManager"     : new UploadManager(this),
        }

        this.server.use(cookieParser()); // Cookie middleware needed

        if(this.config.server !== undefined) { 
            switch(this.config.server.requestBody){
                case "json":{
                    this.server.use(JSONMiddleware(this.config.server.requestBodyConfig));
                    break;
                }
                case "urlencoded":{
                    this.server.use(URLEncodedMiddleware(this.config.server.requestBodyConfig));
                    break;
                }
                case "form-data":{
                    // TODO
                    break;
                }
                case "none":{
                    break;
                }
                default:{
                    this.server.use(JSONMiddleware());
                    this.server.use(URLEncodedMiddleware({ extended: true }));
                    break;
                }
            }
        }

        console.log("[DFW] Core loaded mode: " + process.env.NODE_ENV,this.config);
    }


    /**
     * Initialices the express server
     * @param port 
     * @param callback 
     */
    public startServer(port: number = process.env.NODE_ENV !== 'production' ? parseInt(process.env.PORT || '3000', 10) : 80, callback?: Function): Express {
        this.port = port;
        
        let listener = this.server.listen(port, () => {
            console.log("[DFW] Express server running on port " + (listener.address() as AddressInfo).port);
            if (callback != undefined && callback != null) {
                callback();
            }
        });


        return this.server;
    }

    /**
     * 
     * @param req 
     * @param res 
     */
    public async touchAsync(req: Request, res: Response,next: NextFunction) {
        let dfw: DFWScheme = {

            session: {} as DFWSessionSchema,
            security: {} as DFWSecuritySchema,
            api: {} as DFWAPISchema,
            db: undefined as any,
            file: {} as DFWFileSystemSchema,
            request: req as any,
            response: res,
            next:next,
            modules: this.modules,
            DFWInstance: this,
        }

        var moduleKeys = Object.keys(this.modules);

        for (var i = 0; i < moduleKeys.length; i++) {
            await this.modules[moduleKeys[i]].touchAsync(dfw)
        }

        req.dfw = dfw;

        return dfw;
    }

    /**
     * DFW Express Middleware for this instance
     * @param req 
     * @param res 
     * @param next 
     */
    public middleware = (req: Request, res: Response,next: NextFunction) => {
        this.touchAsync(req, res, next).then((dfw)=>{
            next();
        })
    }

    /**
     * 
     * @param name 
     */
    public getDatabase = (name: string = "default"): Database  => {
        return this.modules.databaseManager.getDatabase(name);
    }
}