import {expect, jest, test} from '@jest/globals';
import { Handler, StreamHandler, StderrHandler } from '../../src/handler';
import { Formatter, DEFAULT_FORMATTER } from '../../src/formatter';
import { LogRecord } from '../../src/log-record';
import { DEBUG, WARNING, ERROR, NOTSET } from '../../src/log-level';
function makeRecord(level: number, msg: string): LogRecord {
    return new LogRecord('test', { level, msg });
}

describe('Handler', () => {
    describe('constructor', () => {
        test('defaults to NOTSET level', () => {
            const h = new Handler();
            expect(h.level).toBe(NOTSET);
        });

        test('accepts a level argument', () => {
            const h = new Handler(WARNING);
            expect(h.level).toBe(WARNING);
        });
    });

    describe('level setter', () => {
        test('sets the level without infinite recursion', () => {
            const h = new Handler();
            h.level = ERROR;
            expect(h.level).toBe(ERROR);
        });
    });

    describe('formatter', () => {
        test('getter returns null when no formatter set', () => {
            const h = new Handler();
            expect(h.formatter).toBeNull();
        });

        test('getter returns assigned formatter', () => {
            const h = new Handler();
            const fmt = new Formatter();
            h.formatter = fmt;
            expect(h.formatter).toBe(fmt);
        });
    });

    describe('format', () => {
        test('uses DEFAULT_FORMATTER when no formatter assigned', () => {
            const h = new Handler();
            const record = makeRecord(DEBUG, 'hello');
            const result = h.format(record);
            expect(typeof result).toBe('string');
        });

        test('uses assigned formatter', () => {
            const h = new Handler();
            const fmt = new Formatter({ fmt: '%(message)s' });
            h.formatter = fmt;
            const record = makeRecord(DEBUG, 'hello');
            const result = h.format(record);
            expect(typeof result).toBe('string');
        });

        test('returns a string', () => {
            const h = new Handler();
            const record = makeRecord(WARNING, 'test message');
            expect(typeof h.format(record)).toBe('string');
        });
    });

    describe('emit', () => {
        test('throws NotImplementedError on base class', () => {
            const h = new Handler();
            const record = makeRecord(DEBUG, 'hello');
            expect(() => h.emit(record)).toThrow('emit must be implemented');
        });
    });

    describe('close', () => {
        test('sets closed to true', () => {
            const h = new Handler();
            expect(h.closed).toBe(false);
            h.close();
            expect(h.closed).toBe(true);
        });
    });
});

describe('StderrHandler', () => {
    test('accepts a level', () => {
        const h = new StderrHandler(ERROR);
        expect(h.level).toBe(ERROR);
    });
});