import {Service} from "./src/Service";
import {LogCall} from "./calls/logger/LogCall";
import {ApiCallID} from "./ApiCallID";
import {LogRequestAndResponseToDiscordCall} from "./calls/logger/LogRequestAndResponseToDiscordCall";
import {BaseRequestPayload, BaseResponsePayload, Request, Response} from "./src/AbstractCall";

/**
 * class to handle logging
 */
export class Logger{
    readonly service: Service;
    readonly namespace: string;

    constructor(service : Service, namespace : string){
        this.service = service;
        this.namespace = namespace;
    }

    private createConsoleMessage(msg : string) : string{
        return `[${new Date().toLocaleString()}|${this.service}|${this.namespace}] ${msg} \n`
    }

    /**
     * sends to the api request channel
     * @param {Request<BaseRequestPayload>} request
     * @param {Response<BaseResponsePayload>} response
     * @param {String} handlerName
     */
    apiRequest(request : Request<BaseRequestPayload>, response : Response<BaseResponsePayload>,handlerName:String){
        if(Service.TEST === this.service || Service.LOGGER === this.service) return;

        if(request.payload){
            //Professional error fixing
            //@ts-ignore
            if(request.payload.password){
                //@ts-ignore
                delete request.payload.password
            }
        }

        new LogRequestAndResponseToDiscordCall({
            id : request.id,
            payload : {
                request: request,
                response: response,
                source: this.service,
                isApiRequest: true,
                handler_name:handlerName as string
            }}).get().catch(console.error);
    }

    /**
     * sends to the request channel
     * @param {Request<BaseRequestPayload>} request
     * @param {Response<BaseResponsePayload>} response
     * @param {String} handlerName
     */
    request(request : Request<BaseRequestPayload>, response : Response<BaseResponsePayload>,handlerName:String){
        if(Service.TEST === this.service || Service.LOGGER === this.service) return;

        if(request.payload){
            //Professional error fixing
            //@ts-ignore
            if(request.payload.password){
                //@ts-ignore
                delete request.payload.password
            }
        }

        new LogRequestAndResponseToDiscordCall({
            id : request.id,
            payload : {
                request: request,
                response: response,
                source: this.service,
                handler_name: handlerName as string
            }}).get().catch(console.error);
    }

    /**
     * sends to the info channel
     * @param {ApiCallID} id
     * @param {string} msg
     * @param optionalParams
     */
    info(id : ApiCallID, msg : string, ...optionalParams: any[]){
        for(let parameter of optionalParams){
            if(parameter.request && parameter.request.payload && parameter.request.payload.password){
                delete parameter.request.payload.password
            }
            if(parameter.request && parameter.request.payload && parameter.request.payload.poll && parameter.request.payload.poll.password){
                delete parameter.request.payload.poll.password
            }
        }
        console.info(this.createConsoleMessage(msg), optionalParams);
        if(Service.TEST === this.service || Service.LOGGER === this.service) return;
        new LogCall({
            id : id,
            payload : {
                level : "info",
                source : this.service,
                message : msg,
                data : optionalParams
            }
        }).get().catch(console.error)
    }

    /**
     * sends to the debug channel
     * @param {ApiCallID} id
     * @param {string} msg
     * @param optionalParams
     */
    debug(id : ApiCallID, msg : string, ...optionalParams: any[]){
        for(let parameter of optionalParams){
            if(parameter.request && parameter.request.payload && parameter.request.payload.password){
                delete parameter.request.payload.password
            }
            if(parameter.request && parameter.request.payload && parameter.request.payload.poll && parameter.request.payload.poll.password){
                delete parameter.request.payload.poll.password
            }
        }
        console.debug(this.createConsoleMessage(msg), optionalParams);
        if(Service.TEST === this.service || Service.LOGGER === this.service) return;
        new LogCall({
            id : id,
            payload : {
                level : "debug",
                source : this.service,
                message : msg,
                data : optionalParams
            }
        }).get().catch(console.error)
    }

    /**
     * sends to the warn channel
     * @param {ApiCallID} id
     * @param {string} msg
     * @param optionalParams
     */
    warn(id : ApiCallID, msg : string, ...optionalParams: any[]){
        for(let parameter of optionalParams){
            if(parameter.request && parameter.request.payload && parameter.request.payload.password){
                delete parameter.request.payload.password
            }
            if(parameter.request && parameter.request.payload && parameter.request.payload.poll && parameter.request.payload.poll.password){
                delete parameter.request.payload.poll.password
            }
        }
        console.warn(this.createConsoleMessage(msg), optionalParams);
        if(Service.TEST === this.service || Service.LOGGER === this.service) return;
        new LogCall({
            id : id,
            payload : {
                level : "warn",
                source : this.service,
                message : msg,
                data : optionalParams
            }
        }).get().catch(console.error)
    }

    /**
     * sends to the error channel
     * @param {ApiCallID} id
     * @param {string} msg
     * @param optionalParams
     */
    error(id : ApiCallID, msg : string, ...optionalParams: any[]) {
        for(let parameter of optionalParams){
            if(parameter.request && parameter.request.payload && parameter.request.payload.password){
                delete parameter.request.payload.password
            }
            if(parameter.request && parameter.request.payload && parameter.request.payload.poll && parameter.request.payload.poll.password){
                delete parameter.request.payload.poll.password
            }
        }
        console.error(this.createConsoleMessage(msg), optionalParams);
        if(Service.TEST === this.service || Service.LOGGER === this.service) return;
        new LogCall({
            id: id,
            payload: {
                level: "error",
                source: this.service,
                message: msg,
                data: optionalParams
            }
        }).get().catch(console.error);
    }

    /**
     * sends to the fatal channel
     * @param {ApiCallID} id
     * @param {string} msg
     * @param optionalParams
     */
    fatal(id : ApiCallID, msg : string, ...optionalParams: any[]){
        for(let parameter of optionalParams){
            if(parameter.request && parameter.request.payload && parameter.request.payload.password){
                delete parameter.request.payload.password
            }
            if(parameter.request && parameter.request.payload && parameter.request.payload.poll && parameter.request.payload.poll.password){
                delete parameter.request.payload.poll.password
            }
        }
        console.error(this.createConsoleMessage(msg), optionalParams);
        if(Service.TEST === this.service || Service.LOGGER === this.service) return;
            new LogCall({
                id : id,
                payload : {
                    level : "fatal",
                    source : this.service,
                    message : msg,
                    data : optionalParams
                }
            }).get().catch(console.error)
    }
}