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);

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

interface Error {
    name: string;
    message: string;
    stack?: string;
}
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 class CrawlerLogger extends LoggerText {
    winstonLogger: winston.Logger;

    constructor(options: any) {
        super(options);
        //creating logs folder if it doesnt exist
        fs.mkdirSync(`${BASE_PATH}/logs`, { recursive: true });
        const logger = winston.createLogger({
            level: 'info',
            format: winston.format.combine(
                winston.format.timestamp(),
                winston.format.json()
            ),
            transports: [
                new winston.transports.Console({
                    format: winston.format.colorize({ all: true }),
                }),
                new winston.transports.File({
                    level: 'info',
                    dirname: `${BASE_PATH}/logs/`,
                    filename: `output.log`,
                    handleExceptions: true,
                    maxsize: 50000000,
                    maxFiles: 10,
                    tailable: true,
                }),
            ],
        });
        this.winstonLogger = logger;
    }

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

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