import { LoggerText, LogLevel } from 'crawlee';
import * as winston from 'winston';
import { fileURLToPath } from 'url';
import * as path from 'path';
import * as fs from 'fs';

const __filename = fileURLToPath(import.meta.url);

const __dirname = path.dirname(__filename);

export const BASE_PATH = path.dirname(path.dirname(__dirname));

export type AdditionalData = Record<string, any> | null | unknown;

//mapping winston's log levels to crawlee's on index
// DONT CHANGE
const winstonLogLevelMapping = [
    'info',
    'error',
    'warn',
    'warn',
    'info',
    'debug',
    'verbose',
];

export const initWinstonLogger = (label: string) => {
    const { printf } = winston.format;
    const myFormat = printf(({ level, message, timestamp, label }) => {
        return `${timestamp} [${label}] ${level}: ${message}`;
    });
    //creating logs folder if it doesnt exist
    fs.mkdirSync(`${BASE_PATH}/logs`, { recursive: true });
    winston.loggers.add(label,{
        level: "silly",
        format: winston.format.combine(
            winston.format.label({ label: label }),
            winston.format.timestamp(),
            myFormat
        ),
        transports: [
            new winston.transports.Console({
                format: winston.format.colorize({ all: true }),
            }),
            new winston.transports.File({
                dirname: `${BASE_PATH}/logs/`,
                filename: `output.log`,
                handleExceptions: true,
                maxsize: 50000000,
                maxFiles: 10,
                tailable: true,
                format: winston.format.uncolorize(),
            }),
        ],
    });
    return winston.loggers.get(label)
};

export class CrawlerLogger extends LoggerText {
    winstonLogger: winston.Logger;
    constructor(options: any = {}, label = '') {
        super(options);
        this.winstonLogger = initWinstonLogger(label)
    }

    override log(
        level: LogLevel,
        message: string,
        data?: AdditionalData,
        exception?: Error
    ) {
        const errStack = exception ? this._parseException(exception) : '';
        const dataStr = !data ? '' : ` ${JSON.stringify(data, null, 2)}`;
        const logStr = message + errStack + dataStr;

        this.winstonLogger.log(winstonLogLevelMapping[level], logStr);
    }
}