import { DyNTS_Errors_ControlService } from './errors.control-service';
import { DyFM_Error, DyFM_Errors, DyFM_ErrorLevel, DyFM_RelativeDate, DyFM_Paged, DyFM_SearchQuery, DyFM_SearchResult } from '@futdevpro/fsm-dynamo';
import { DyNTS_global_settings } from '../../../_collections/global-settings.const';

class TestError extends DyFM_Error {
  constructor(set?: Partial<TestError>) {
    super(set);
    Object.assign(this, set);
  }
}

class TestErrors extends DyFM_Errors<TestError> {
  constructor(set?: Partial<TestErrors>) {
    super(set);
    Object.assign(this, set);
  }
}

class TestErrorsControlService extends DyNTS_Errors_ControlService<TestError, TestErrors> {
  async recordError(data: TestErrors, issuer: string, alwaysRecord?: boolean): Promise<void> {
    // Mock implementation
  }

  async handleInternalError(error: any, issuer: string, alwaysRecord?: boolean): Promise<void> {
    // Mock implementation
  }

  checkErrorIsStringifyableOrResolvable(error: TestError, issuer: string): TestError | 'UNRESOLVABLE' {
    return error;
  }

  getPriorityMultiplierByLevel(level: DyFM_ErrorLevel, issuer: string): number {
    return 1;
  }

  async getErrorsFromDate(date: Date, issuer: string): Promise<DyFM_Paged<TestErrors>> {
    return {
      items: [],
      total: 0,
      pageIndex: 0,
      pageSize: 0,
    };
  }

  async deleteError(errorId: string, issuer: string, alwaysDelete?: boolean): Promise<void> {
    // Mock implementation
  }

  async deleteAllErrors(issuer: string, alwaysDelete?: boolean): Promise<void> {
    // Mock implementation
  }

  async recordFixAttempt(errorId: string, version: string, hypothesis: string, issuer: string): Promise<any> {
    return { at: new Date(), by: issuer, version, hypothesis };
  }

  async getErrorsByCategoryPaged(category: string, range: any, pageSize: number, pageIndex: number, issuer: string): Promise<any> {
    return { items: [], total: 0, pageIndex, pageSize };
  }

  async resolveError(errorId: string, issuer: string, notes?: string): Promise<void> {
    return;
  }

  async getErrorsByStatusPaged(status: string, range: any, pageSize: number, pageIndex: number, issuer: string): Promise<any> {
    return { items: [], total: 0, pageIndex, pageSize };
  }

  async getErrorsInRange(range: DyFM_RelativeDate, issuer: string): Promise<DyFM_Paged<TestErrors>> {
    return {
      items: [],
      total: 0,
      pageIndex: 0,
      pageSize: 0,
    };
  }

  async getErrorsPaged(range: DyFM_RelativeDate, pageSize: number, pageIndex: number, issuer: string): Promise<DyFM_Paged<TestErrors>> {
    return {
      items: [],
      total: 0,
      pageIndex,
      pageSize,
    };
  }

  async getLastErrors(range: DyFM_RelativeDate, pageSize: number, pageIndex: number, issuer: string): Promise<DyFM_Paged<TestErrors>> {
    return {
      items: [],
      total: 0,
      pageIndex,
      pageSize,
    };
  }

  async searchErrors(searchQuery: DyFM_SearchQuery<TestErrors>, issuer: string): Promise<DyFM_SearchResult<TestErrors>> {
    return {
      results: [],
      totalItems: 0,
    };
  }

  static getInstance(): TestErrorsControlService {
    return (TestErrorsControlService as any).getSingletonInstance();
  }
}

describe('| DyNTS_Errors_ControlService', () => {
  let service: TestErrorsControlService;

  beforeEach(() => {
    service = new (TestErrorsControlService as any)();
  });

  describe('| constructor', () => {
    it('| should initialize with default values', () => {
      expect(service.debugLog).toBe(false);
      expect(service.version).toBe(DyNTS_global_settings.systemVersion);
      expect(service.duplicationCounter).toBeUndefined();
    });
  });

  describe('| properties', () => {
    it('| should have version property', () => {
      expect(service.version).toBeDefined();
      expect(typeof service.version).toBe('string');
    });

    it('| should have debugLog property', () => {
      expect(service.debugLog).toBeDefined();
      expect(typeof service.debugLog).toBe('boolean');
    });
  });

  describe('| recordError', () => {
    it('| should record error', async () => {
      const errors = new TestErrors({
        error: new TestError({ _message: 'Test error' }),
      });

      await service.recordError(errors, 'test-issuer');

      expect(service.recordError).toBeDefined();
    });
  });

  describe('| handleInternalError', () => {
    it('| should handle internal error', async () => {
      const error = new Error('Internal error');

      await service.handleInternalError(error, 'test-issuer');

      expect(service.handleInternalError).toBeDefined();
    });
  });

  describe('| checkErrorIsStringifyableOrResolvable', () => {
    it('| should check if error is stringifyable', () => {
      const error = new TestError({ _message: 'Test error' });

      const result = service.checkErrorIsStringifyableOrResolvable(error, 'test-issuer');

      expect(result).toBe(error);
    });
  });

  describe('| getPriorityMultiplierByLevel', () => {
    it('| should return priority multiplier', () => {
      const result = service.getPriorityMultiplierByLevel(DyFM_ErrorLevel.error, 'test-issuer');

      expect(result).toBe(1);
    });
  });

  describe('| getErrorsFromDate', () => {
    it('| should get errors from date', async () => {
      const date = new Date();
      const result = await service.getErrorsFromDate(date, 'test-issuer');

      expect(result).toBeDefined();
      expect(result.items).toBeDefined();
      expect(result.total).toBeDefined();
    });
  });

  describe('| deleteError', () => {
    it('| should delete error', async () => {
      await service.deleteError('error-123', 'test-issuer');

      expect(service.deleteError).toBeDefined();
    });
  });

  describe('| deleteAllErrors', () => {
    it('| should delete all errors', async () => {
      await service.deleteAllErrors('test-issuer');

      expect(service.deleteAllErrors).toBeDefined();
    });
  });

  describe('| getErrorsInRange', () => {
    it('| should get errors in range', async () => {
      const result = await service.getErrorsInRange(DyFM_RelativeDate.lastWeek, 'test-issuer');

      expect(result).toBeDefined();
      expect(result.items).toBeDefined();
    });
  });

  describe('| getErrorsPaged', () => {
    it('| should get errors paged', async () => {
      const result = await service.getErrorsPaged(DyFM_RelativeDate.lastWeek, 10, 0, 'test-issuer');

      expect(result).toBeDefined();
      expect(result.items).toBeDefined();
      expect(result.pageIndex).toBe(0);
      expect(result.pageSize).toBe(10);
    });
  });

  describe('| getLastErrors', () => {
    it('| should get last errors', async () => {
      const result = await service.getLastErrors(DyFM_RelativeDate.lastWeek, 10, 0, 'test-issuer');

      expect(result).toBeDefined();
      expect(result.items).toBeDefined();
    });
  });

  describe('| searchErrors', () => {
    it('| should search errors', async () => {
      const searchQuery: DyFM_SearchQuery<TestErrors> = {
        filterBy: {},
      };

      const result = await service.searchErrors(searchQuery, 'test-issuer');

      expect(result).toBeDefined();
      expect(result.results).toBeDefined();
      expect(result.totalItems).toBeDefined();
    });
  });
});