import { deepEqual, equal, notDeepEqual, throws } from "node:assert/strict"
import { homedir } from "node:os"
import { join } from "node:path"
import { env } from "node:process"
import { afterEach, beforeEach, suite, test } from "node:test"
import { format, transports, type Logger as WinstonLogger } from "winston"
import type { FileTransportInstance } from "winston/lib/winston/transports/index.js"
import Logger from "../src/Logger.ts"

suite("#Logger", () => {
    let originalNodeDebug: string | undefined

    beforeEach(() => {
        originalNodeDebug = env[ "NODE_DEBUG" ]
        delete env?.[ "NODE_DEBUG" ]
    })

    afterEach(() => {
        env[ "NODE_DEBUG" ] = originalNodeDebug
    })

    test("should initialize different loggers", () => {
        env[ "NODE_DEBUG" ] = "test-*2"
        const logger1 = Logger("test-logger1")
        const logger2 = Logger("test-logger2")
        logger1.info("Info test message")
        logger1.error("Error test message")
        logger2.debug("Debug test message")
        logger2.error("Error test message")
        equal(logger1.level, "info")
        equal(logger2.level, "debug")
        notDeepEqual(logger1, logger2)
    })

    test("should have default label", () => {
        const logger: WinstonLogger = Logger()
        logger.info("Info test message")
        logger.debug("Debug test message")
        equal(logger.level, "info")
    })

    test("should check the default log directory", () => {
        const logger: WinstonLogger = Logger()
        const fileTransport: FileTransportInstance | undefined = logger.transports.filter(transport => transport instanceof transports.File)?.[0]
        equal(fileTransport?.filename, `imergo.log`)
        equal(fileTransport?.dirname, join(homedir(), ".cache", "imergo", "log"))
        equal(fileTransport?.name, `file`)
    })

    test("should initialize logger with object configuration", () => {
        const config = {
            level: "error",
            format: format.simple(),
            transports: [ new transports.Console() ]
        }
        const logger = Logger(config)
        equal(logger.level, config.level)
        deepEqual(logger.format, config.format)
        deepEqual(logger.transports, config.transports)
    })

    test("should throw exception with invalid use of constructor (boolean)", () => {
        throws(() => {
            // @ts-ignore
            Logger(false)
        }, TypeError)
    })

    test("should throw exception with invalid use of constructor (function)", () => {
        throws(() => {
            // @ts-ignore
            Logger(function () {})
        }, TypeError)
    })
})