import { describe, it, expect } from 'bun:test';
import LoggingLevelMapping from '../src/level/LoggingLevelMapping';
import { LoggingLevel, LoggingLevelType } from '../src/level/LoggingLevel';

describe('LoggingLevelMapping', () => {
  describe('convertLoggingLevelToLoggingLevelType', () => {
    it('should convert LoggingLevel.Off to "Off"', () => {
      expect(LoggingLevelMapping.convertLoggingLevelToLoggingLevelType(LoggingLevel.Off)).toBe('Off');
    });

    it('should convert LoggingLevel.Debug to "Debug"', () => {
      expect(LoggingLevelMapping.convertLoggingLevelToLoggingLevelType(LoggingLevel.Debug)).toBe('Debug');
    });

    it('should convert LoggingLevel.Trace to "Trace"', () => {
      expect(LoggingLevelMapping.convertLoggingLevelToLoggingLevelType(LoggingLevel.Trace)).toBe('Trace');
    });

    it('should convert LoggingLevel.Info to "Info"', () => {
      expect(LoggingLevelMapping.convertLoggingLevelToLoggingLevelType(LoggingLevel.Info)).toBe('Info');
    });

    it('should convert LoggingLevel.Silly to "Silly"', () => {
      expect(LoggingLevelMapping.convertLoggingLevelToLoggingLevelType(LoggingLevel.Silly)).toBe('Silly');
    });

    it('should convert LoggingLevel.Warn to "Warn"', () => {
      expect(LoggingLevelMapping.convertLoggingLevelToLoggingLevelType(LoggingLevel.Warn)).toBe('Warn');
    });

    it('should convert LoggingLevel.Error to "Error"', () => {
      expect(LoggingLevelMapping.convertLoggingLevelToLoggingLevelType(LoggingLevel.Error)).toBe('Error');
    });

    it('should convert LoggingLevel.All to "All"', () => {
      expect(LoggingLevelMapping.convertLoggingLevelToLoggingLevelType(LoggingLevel.All)).toBe('All');
    });
  });

  describe('convertLoggingLevelTypeToLoggingLevel', () => {
    it('should convert "Off" to LoggingLevel.Off', () => {
      expect(LoggingLevelMapping.convertLoggingLevelTypeToLoggingLevel('Off')).toBe(LoggingLevel.Off);
    });

    it('should convert "Debug" to LoggingLevel.Debug', () => {
      expect(LoggingLevelMapping.convertLoggingLevelTypeToLoggingLevel('Debug')).toBe(LoggingLevel.Debug);
    });

    it('should convert "Trace" to LoggingLevel.Trace', () => {
      expect(LoggingLevelMapping.convertLoggingLevelTypeToLoggingLevel('Trace')).toBe(LoggingLevel.Trace);
    });

    it('should convert "Info" to LoggingLevel.Info', () => {
      expect(LoggingLevelMapping.convertLoggingLevelTypeToLoggingLevel('Info')).toBe(LoggingLevel.Info);
    });

    it('should convert "Silly" to LoggingLevel.Silly', () => {
      expect(LoggingLevelMapping.convertLoggingLevelTypeToLoggingLevel('Silly')).toBe(LoggingLevel.Silly);
    });

    it('should convert "Warn" to LoggingLevel.Warn', () => {
      expect(LoggingLevelMapping.convertLoggingLevelTypeToLoggingLevel('Warn')).toBe(LoggingLevel.Warn);
    });

    it('should convert "Error" to LoggingLevel.Error', () => {
      expect(LoggingLevelMapping.convertLoggingLevelTypeToLoggingLevel('Error')).toBe(LoggingLevel.Error);
    });

    it('should convert "All" to LoggingLevel.All', () => {
      expect(LoggingLevelMapping.convertLoggingLevelTypeToLoggingLevel('All')).toBe(LoggingLevel.All);
    });
  });

  describe('round trip conversion', () => {
    it('should maintain consistency in round trip conversions', () => {
      const allLevels: LoggingLevel[] = [
        LoggingLevel.Off,
        LoggingLevel.Debug,
        LoggingLevel.Trace,
        LoggingLevel.Info,
        LoggingLevel.Silly,
        LoggingLevel.Warn,
        LoggingLevel.Error,
        LoggingLevel.All
      ];

      for (const level of allLevels) {
        const type = LoggingLevelMapping.convertLoggingLevelToLoggingLevelType(level);
        const backToLevel = LoggingLevelMapping.convertLoggingLevelTypeToLoggingLevel(type);
        expect(backToLevel).toBe(level);
      }
    });
  });
});