import fastify, {FastifyInstance, FastifyReply, FastifyRequest} from 'fastify'
import helmet from 'fastify-helmet'
import { Server, IncomingMessage, ServerResponse } from 'http'
import {RouterMap} from 'decorators/router';
import {mongoose} from "@typegoose/typegoose";
import logger  from 'logger/logger';
import config from 'config/config';

const zTokenParserPlugin = require("./plugins/zTokenParser");


const fs = require('fs');
const join = require('path').join;
const apiAuthPlugin = require('./plugins/apiauth');
const fileUpload = require('fastify-file-upload');

require('./common/Extend');

export class FileServer {
    server: FastifyInstance<Server, IncomingMessage, ServerResponse>;

    public constructor() {
        this.server = fastify({logger: true});
        this.registerPlugins();
    }
    private registerPlugins() {
        this.server.register(require('fastify-formbody'));
        this.server.register(fileUpload, {createParentPath: true});
        this.server.register(
            helmet,
            { hidePoweredBy: false }
        )
        this.server.register(apiAuthPlugin, {
            secret: config.api.token_secret,
            expiresIn: config.api.token_expiresIn
        })
        this.server.register(zTokenParserPlugin, {});
        this.server.register(require('fastify-cors'), {});
    }

    private registerRouter() {
        logger.log('register api routers');
        let self = this;
        for (let [controller, config] of RouterMap.decoratedRouters) {
            for(let data of config.data) {
                logger.info('find api router', data.method || 'all',
                    data.path, controller.name);
                // @ts-ignore
                self.server[data.method || 'all'](data.path, {
                    preValidation: async function (request: FastifyRequest, reply: FastifyReply) {
                        request.roles = config.roles;
                        await this.apiAuth(request, reply);
                    }
                }, controller);
            }
        }
    }
    /**
     * 加载所有的controller
     */
    initControllers() {
        logger.info('Bootstrap controllers...');
        const controllers = join(__dirname, 'file/controllers');
        fs.readdirSync(controllers)
            .filter((file: string) => ~file.search(/^[^.].*\.(ts|js)$/))
            .forEach((file: any) => {
                logger.log(file);
                return require(join(controllers, file))});
    }
    async connectDB() {
        const options = {useNewUrlParser: true,
            poolSize: 5,
            keepAlive: true,
            keepAliveInitialDelay: 300000,
            useUnifiedTopology: true};
        const uri = config.db_main;
        logger.info(`connect to  ${uri} ...`);
        try {
            // await mongoose.createConnection(uri, options)
            await mongoose.connect(uri, options)
            logger.log('DB Connected');
        } catch (err) {
            logger.log(`DB Connection Error: ${err.message}`);
        }
    }
    private setErrHandler() {
        this.server.setNotFoundHandler(function(request, reply){
            reply.send({code: 404, msg: 'page not found'})
        });
        this.server.setErrorHandler(function (error, request, reply) {
            let statusCode = error && error.statusCode || 100;
            if (statusCode >= 500) {
                logger.error(error)
            } else if (statusCode >= 400) {
                logger.info(error)
            } else {
                logger.error(error)
            }
            reply.send({code: statusCode, msg: error ? error.message : 'unknown error'})
        })
    }
    /**
     * 格式化接口返回数据, 统一封装成如下格式
     * {
     *     code: 0,
     *     msg?: '',
     *     data: any
     * }
     * @private
     */
    private setFormatSend() {
        this.server.addHook('preSerialization', async (request: FastifyRequest, reply: FastifyReply, payload) => {
            reply.header('X-Powered-By', 'PHP/5.4.16')
            // @ts-ignore
            if (!payload.code) {
                payload = {
                    code: 0,
                    data: payload
                }
            }
            return payload
        })
    }
    public async start() {
        let self = this;
        return new Promise(async (resolve, reject) => {
            await self.connectDB();
            self.initControllers();
            self.registerRouter();
            self.setErrHandler();
            // self.setFormatSend();
            this.server.listen({port: config.file.port, host: config.file.host}, (err: any, address: any) => {
                if (err) {
                    logger.log(err)
                    process.exit(0)
                }
                resolve && resolve(address);
            })
        });

    }

}