import { describe, it, expect, beforeEach, vi } from 'bun:test';
import LoggerFactory from '../src/LoggerFactory';
import { LoggingLevel } from '../src/level/LoggingLevel';
import type IAppender from '../src/appenders/IAppender';

describe('LoggerFactory', () => {
  let mockAppender: IAppender;

  beforeEach(() => {
    // Reset LoggerFactory state between tests
    // Note: This is tricky since LoggerFactory uses static state
    // In a real scenario, we'd need to refactor for better testability
    mockAppender = {
      log: vi.fn(),
    };
  });

  describe('getLogger', () => {
    it('should return a logger instance', () => {
      const logger = LoggerFactory.getLogger('test-category');

      expect(logger).toBeDefined();
      expect(typeof logger.info).toBe('function');
      expect(typeof logger.warn).toBe('function');
      expect(typeof logger.error).toBe('function');
      expect(typeof logger.debug).toBe('function');
    });

    it('should return the same logger instance for the same category', () => {
      const logger1 = LoggerFactory.getLogger('test-category');
      const logger2 = LoggerFactory.getLogger('test-category');

      expect(logger1).toBe(logger2);
    });

    it('should return different logger instances for different categories', () => {
      const logger1 = LoggerFactory.getLogger('category1');
      const logger2 = LoggerFactory.getLogger('category2');

      expect(logger1).not.toBe(logger2);
    });
  });

  describe('setLoggingLevel', () => {
    it('should change the logging threshold', () => {
      LoggerFactory.setLoggingLevel('Debug');

      // Create a logger and check that debug messages are logged
      const logger = LoggerFactory.getLogger('test');
      logger.debug('debug message');

      // Note: We can't easily test this without mocking the appenders
      // This would require refactoring LoggerFactory for better testability
    });
  });

  describe('applyAppender', () => {
    it('should return a disposable', () => {
      const disposable = LoggerFactory.applyAppender(mockAppender);

      expect(disposable).toBeDefined();
      expect(typeof disposable.dispose).toBe('function');
    });

    it('should add appender to all loggers', () => {
      const disposable = LoggerFactory.applyAppender(mockAppender);

      const logger = LoggerFactory.getLogger('test');
      logger.info('test message');

      expect(mockAppender.log).toHaveBeenCalled();

      // Clean up
      disposable.dispose();
    });

    it('should remove appender when disposed', () => {
      const disposable = LoggerFactory.applyAppender(mockAppender);

      const logger = LoggerFactory.getLogger('test');
      logger.info('test message');

      expect(mockAppender.log).toHaveBeenCalledTimes(1);

      // Dispose and try again
      disposable.dispose();
      logger.info('test message 2');

      // Should still be called once since we disposed the mock appender
      // but the default appenders are still there
      expect(mockAppender.log).toHaveBeenCalledTimes(1);
    });
  });
});