import path from "path";
import winston, {transports, config, LoggerOptions, format} from "winston";
import DailyRotateFile from "winston-daily-rotate-file";
import ApplicationConfig from "../config/ApplicationConfig";
import {LOG_DISPLAY_TYPE, LOGGER_TYPE_DEF} from "../@types/types";
import {__approot, __env_type} from "../config/ApplicationEnvironment";
const defaultConfig = ApplicationConfig.loadDefault();
const { combine, colorize, json,printf, timestamp, label, prettyPrint } = format;

const logFilename = `${__env_type}-%DATE%`;

export const LOG_ENV = !process.env.DEBUG?'LIVE':process.env.DEBUG;
export const LOG_TYPE = !process.env["LOGGER.TYPE"]?'CONSOLE':process.env["LOGGER.TYPE"];

// export let logDirectory = "/Users/gdmanian/Desktop/projects/bi-flow/testElectron/logs";
export let logDirectory = path.resolve(__approot, "./logs");

export const setLoggerPath = (path:string) =>{
    logDirectory = path;
}

const defaultPrintFormat = printf(info => {
    let msg = `[${info.level}] ${info.timestamp} : ${info.message}`;
    if (info.stack) return `${msg} \n ${info.stack}`;
    return msg;
});

const LOG_OPT_COMM = {
    datePattern: 'YYYY-MM-DD',
    dirname: logDirectory,
    filename: `${logFilename}.log`,
    maxFiles: 30,  // 30일치 로그 파일 저장
    exitOnError: false,
    zippedArchive: true,
    json:false,
    transports:[],
    format:combine(
        timestamp({format:'YYYY-MM-DD HH:mm:ss:SSS'}),
        defaultPrintFormat,
    )
}

function getWinstonRootOption(value: LOGGER_TYPE_DEF):LoggerOptions {
    let newOption = Object.assign({}, LOG_OPT_COMM);
    Object.assign(newOption, {
        level:value.toLocaleLowerCase(),
        typeDef:value,
    });
    return newOption;
}

function getWinstonTransformOption(level:string, type:LOG_DISPLAY_TYPE) {
    const logPath = path.join(logDirectory, `${__env_type}-%DATE%.${level}.log`);
    let newOption = {};
    if(type == "FILE"){
        Object.assign(newOption, {
            level:level, handleExceptions: true,filename:logPath, json:true, colorize:true
            , format: getLogFormat(type)
        });
    }else{
        Object.assign(newOption, {
            level:level, handleExceptions: true, json:true, colorize:true
            , format: getLogFormat(type)
        });
    }
    return newOption;
}

function getLogFormat(type:LOG_DISPLAY_TYPE) {
    if (type === "FILE") {
        return combine(
            prettyPrint(),
            json(),
        );
    }else if(type === "CONSOLE"){
        return combine(
            colorize(),
            prettyPrint(),
            defaultPrintFormat,
        );
    }else{
        return combine(
            colorize(),
            prettyPrint(),
            defaultPrintFormat,
        );
    }
}

export function logOptions():LoggerOptions{
    let transforms:LoggerOptions[] = [];
    if (defaultConfig != null) {
        const logConfig = defaultConfig.getArray("LOGGER");
        if (logConfig && logConfig.length > 0) {
            logConfig.forEach((value:string, index:number)=>{
                if(value !== ""){
                    // console.log(LOGGER_TYPE_DEF.indexOf(value));
                    let rootOption = getWinstonRootOption(value as LOGGER_TYPE_DEF);
                    transforms.push(rootOption);
                }
            });
        }
    }
    transforms = transforms.filter((item,index)=>{
        return (
            transforms.findIndex((item2, index2) => {
                return item.level === item2.level;
            }) === index
        );
    });
    if(transforms.length == 0){
        if (__env_type === 'prod') {
            transforms.push(getWinstonRootOption('ERROR'));
        }else{
            transforms.push(getWinstonRootOption('DEBUG'));
        }
    }
    if (transforms.length > 0) {
        transforms.forEach((el:LoggerOptions, index:number)=>{
            if (__env_type === 'prod' || LOG_TYPE == "FILE") {
                Object.assign(el, {
                    transports:new DailyRotateFile(getWinstonTransformOption(el.level!, 'FILE'))
                });
            }else{
                Object.assign(el, {
                    transports:new transports.Console(getWinstonTransformOption(el.level!,'CONSOLE'))
                });
            }
        });
    }
    let winOption = getWinstonRootOption('ERROR');
    let transList:any[] = [];
    transforms.forEach((value,key)=>{
        if (value.transports !== undefined) {
            transList.push(value.transports);
        }
    })
    winOption.transports = transList;
    return winOption;
}