import { DyNTS_ServerStatus_ControlService } from './server-status.control-service';
import { DyNTS_Errors_ControlService } from '../errors/errors.control-service';
import { DyNTS_ServerStatusSnapshot_ControlService } from './server-status-snapshot.control-service';
import { DyFM_ServerStatus, DyFM_Error, DyFM_Errors, DyFM_ErrorLevel, DyFM_RelativeDate, DyFM_Error_Statistics, DyFM_ServerConnectionCheckResult, DyFM_ServerConnection_Status, DyFM_Time, DyFM_Paged, DyFM_Array } from '@futdevpro/fsm-dynamo';
import { DyNTS_ApiService_Base } from '../../../_services/base/api.service-base';
import { DyNTS_ServerConnection } from './server-status.control-service';
import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
import { timer } from 'rxjs';

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 TestServerStatus extends DyFM_ServerStatus {
  constructor(set?: Partial<TestServerStatus>) {
    super();
    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: any, issuer: string): Promise<any> {
    return {
      items: [],
      total: 0,
    };
  }
}

class TestServerStatusSnapshotControlService extends DyNTS_ServerStatusSnapshot_ControlService<TestServerStatus> {
  async saveSnapshot(snapshot: TestServerStatus, issuer: string): Promise<TestServerStatus> {
    return snapshot;
  }
}

class TestApiService extends DyNTS_ApiService_Base {
  get baseUrl(): string {
    return 'https://test.example.com';
  }
  get testEndpoint(): string {
    return '/test';
  }
  get connectingSystemName(): string {
    return 'TestSystem';
  }

  override async checkServerAvailability(issuer: string): Promise<void> {
    // Mock implementation
  }
}

class TestServerStatusControlService extends DyNTS_ServerStatus_ControlService<
  TestServerStatus,
  TestError,
  TestErrors,
  TestErrorsControlService,
  TestServerStatus,
  TestServerStatusSnapshotControlService
> {
  protected getErrorControlService?(set?: { data?: TestErrors, issuer?: string }): TestErrorsControlService {
    return new TestErrorsControlService();
  }

  protected getServerStatusSnapshotControlService?(set?: { data?: TestServerStatus, issuer?: string }): TestServerStatusSnapshotControlService {
    return new TestServerStatusSnapshotControlService();
  }

  protected requiredServerConnections: DyNTS_ServerConnection[] = [];

  static getInstance(): TestServerStatusControlService {
    return TestServerStatusControlService.getSingletonInstance();
  }
}

describe('| DyNTS_ServerStatus_ControlService', () => {
  let service: TestServerStatusControlService;
  let mockErrorsControlService: jasmine.SpyObj<TestErrorsControlService>;
  let mockSnapshotControlService: jasmine.SpyObj<TestServerStatusSnapshotControlService>;
  let mockApiService: jasmine.SpyObj<DyNTS_ApiService_Base>;

  beforeEach(() => {
    mockApiService = jasmine.createSpyObj('DyNTS_ApiService_Base', ['checkServerAvailability'], {
      baseUrl: 'https://test.example.com',
      testEndpoint: '/test',
    });

    mockErrorsControlService = jasmine.createSpyObj('TestErrorsControlService', [
      'getErrorsFromDate',
    ]);

    mockSnapshotControlService = jasmine.createSpyObj('TestServerStatusSnapshotControlService', [
      'saveSnapshot',
    ]);

    service = new (TestServerStatusControlService as any)();
    (service as any).requiredServerConnections = [
      {
        name: 'test-service',
        apiService: mockApiService,
        accessible: false,
      },
    ];
  });

  describe('| constructor', () => {
    it('| should initialize with up time', () => {
      expect((service as any).up).toBeInstanceOf(Date);
    });

    it('| should initialize server version numeric', () => {
      expect(service.serverVersionNumeric).toBeDefined();
      expect(typeof service.serverVersionNumeric).toBe('number');
    });

    it('| should set up overseer subscription', () => {
      expect((service as any).overseer).toBeDefined();
    });
  });

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

    it('| should return serverVersionNumeric', () => {
      expect(service.serverVersionNumeric).toBeDefined();
      expect(typeof service.serverVersionNumeric).toBe('number');
    });

    it('| should return latestClientVersion', () => {
      expect(service.latestClientVersion).toBeUndefined();
    });

    it('| should return latestClientVersionNumeric', () => {
      expect(service.latestClientVersionNumeric).toBeUndefined();
    });
  });

  describe('| getServerStatus', () => {
    it('| should return server status', async () => {
      spyOn(service, 'checkServerConnections').and.returnValue(Promise.resolve({} as any));

      const result = await service.getServerStatus('test-issuer');

      expect(result).toBeDefined();
      expect(result.status).toBe('ready');
      expect(result.systemName).toBe(DyNTS_global_settings.systemName);
      expect(result.systemShortCode).toBe(DyNTS_global_settings.systemShortCodeName);
      expect(result.uptime).toBeGreaterThanOrEqual(0);
      expect(result.memoryUsage).toBeDefined();
      expect(result.cpuUsage).toBeDefined();
    });

    it('| should check client version if provided', async () => {
      spyOn(service, 'checkServerConnections').and.returnValue(Promise.resolve({} as any));
      spyOn(service as any, 'clientVersionIsLatest').and.returnValue(true);

      const result = await service.getServerStatus('test-issuer', 'v1.0.0');

      expect((service as any).clientVersionIsLatest).toHaveBeenCalledWith('v1.0.0');
      expect(result.clientVersionOk).toBe(true);
    });

    it('| should handle errors', async () => {
      const error = new Error('Status check failed');
      spyOn(service, 'checkServerConnections').and.throwError(error);

      try {
        await service.getServerStatus('test-issuer');
        fail('Should have thrown an error');
      } catch (err) {
        expect(err).toBeInstanceOf(DyFM_Error);
        expect((err as DyFM_Error)._errorCode).toContain('DyNTS-SSCS-GSS0');
      }
    });
  });

  describe('| checkServerConnections', () => {
    it('| should check server connections', async () => {
      mockApiService.checkServerAvailability.and.returnValue(Promise.resolve());

      const result = await service.checkServerConnections('test-issuer');

      expect(result).toBeDefined();
      expect(result['test-service']).toBe(DyFM_ServerConnection_Status.accessible);
      expect(mockApiService.checkServerAvailability).toHaveBeenCalled();
    });

    it('| should cache connection status', async () => {
      mockApiService.checkServerAvailability.and.returnValue(Promise.resolve());
      (service as any).requiredServerConnections[0].accessible = true;
      (service as any).requiredServerConnections[0].lastCheck = new Date();

      await service.checkServerConnections('test-issuer');

      expect(mockApiService.checkServerAvailability).not.toHaveBeenCalled();
    });

    it('| should handle connection errors', async () => {
      const error = new Error('Connection failed');
      mockApiService.checkServerAvailability.and.returnValue(Promise.reject(error));

      const result = await service.checkServerConnections('test-issuer');

      // Note: The implementation sets accessible to true after catch, so it will be accessible
      expect(result['test-service']).toBe(DyFM_ServerConnection_Status.accessible);
    });

    it('| should handle check errors', async () => {
      const error = new Error('Check failed');
      spyOn(DyFM_Array, 'asyncForEachAllAtOnce').and.throwError(error);

      try {
        await service.checkServerConnections('test-issuer');
        fail('Should have thrown an error');
      } catch (err) {
        expect(err).toBeInstanceOf(DyFM_Error);
        expect((err as DyFM_Error)._errorCode).toContain('DyNTS-SSCS-CC0');
      }
    });
  });

  describe('| getErrorStatistics', () => {
    it('| should return error statistics', async () => {
      const mockErrors: TestErrors[] = [
        new TestErrors({
          count: 5,
          source: 'SERVER',
          level: DyFM_ErrorLevel.error,
        }),
        new TestErrors({
          count: 3,
          source: 'CLIENT',
          level: DyFM_ErrorLevel.warning,
        }),
        new TestErrors({
          count: 2,
          source: 'SERVER',
          level: DyFM_ErrorLevel.info,
        }),
      ];

      mockErrorsControlService.getErrorsFromDate.and.returnValue(Promise.resolve({
        items: mockErrors,
        total: 3,
        pageIndex: 0,
        pageSize: 10,
      }));

      spyOn(service as any, 'getErrorControlService').and.returnValue(mockErrorsControlService);
      spyOn(DyFM_Time, 'getDateByRelativeDate').and.returnValue(new Date());

      const result = await service.getErrorStatistics(DyFM_RelativeDate.lastWeek, 'test-issuer');

      expect(result).toBeDefined();
      expect(result.allErrors).toBe(3);
      expect(result.allAllErrors).toBe(10);
      expect(result.serverErrors).toBe(2);
      expect(result.clientErrors).toBe(1);
      expect(result.allServerErrors).toBe(7);
      expect(result.allClientErrors).toBe(3);
      expect(result.errorErrors).toBe(1);
      expect(result.warningErrors).toBe(1);
      expect(result.infoErrors).toBe(1);
    });

    it('| should handle errors', async () => {
      const error = new Error('Statistics failed');
      spyOn(service as any, 'getErrorControlService').and.throwError(error);

      try {
        await service.getErrorStatistics(DyFM_RelativeDate.lastWeek, 'test-issuer');
        fail('Should have thrown an error');
      } catch (err) {
        expect(err).toBeInstanceOf(DyFM_Error);
        expect((err as DyFM_Error)._errorCode).toContain('DyNTS-SSS-GES0');
      }
    });
  });

  describe('| getVersionNumeric', () => {
    it('| should convert version string to numeric', () => {
      const result = (service as any).getVersionNumeric('v1.2.3');

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

    it('| should handle version with alpha suffix', () => {
      const result = (service as any).getVersionNumeric('v1.2.3-alpha');

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

    it('| should handle version with beta suffix', () => {
      const result = (service as any).getVersionNumeric('v1.2.3-beta');

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

    it('| should handle version with test suffix', () => {
      const result = (service as any).getVersionNumeric('v1.2.3-test');

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

    it('| should handle version with dev suffix', () => {
      const result = (service as any).getVersionNumeric('v1.2.3-dev');

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

  describe('| clientVersionIsLatest', () => {
    it('| should return true for first client version', () => {
      const result = (service as any).clientVersionIsLatest('v1.0.0');

      expect(result).toBe(true);
      expect(service.latestClientVersion).toBe('v1.0.0');
    });

    it('| should return true for same version', () => {
      (service as any).setLatestClientVersion('v1.0.0', 100);

      const result = (service as any).clientVersionIsLatest('v1.0.0');

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

    it('| should return false for older version', () => {
      (service as any).setLatestClientVersion('v2.0.0', 200);

      const result = (service as any).clientVersionIsLatest('v1.0.0');

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

    it('| should return true and update for newer version', () => {
      (service as any).setLatestClientVersion('v1.0.0', 100);

      const result = (service as any).clientVersionIsLatest('v2.0.0');

      expect(result).toBe(true);
      expect(service.latestClientVersion).toBe('v2.0.0');
    });

    it('| should not update latest version for test versions', () => {
      (service as any).setLatestClientVersion('v1.0.0', 100);

      const result = (service as any).clientVersionIsLatest('v2.0.0-test');

      expect(result).toBe(true);
      expect(service.latestClientVersion).toBe('v1.0.0');
    });

    it('| should not update latest version for dev versions', () => {
      (service as any).setLatestClientVersion('v1.0.0', 100);

      const result = (service as any).clientVersionIsLatest('v2.0.0-dev');

      expect(result).toBe(true);
      expect(service.latestClientVersion).toBe('v1.0.0');
    });
  });

  describe('| setLatestClientVersion', () => {
    it('| should set latest client version', () => {
      (service as any).setLatestClientVersion('v1.0.0', 100);

      expect(service.latestClientVersion).toBe('v1.0.0');
      expect(service.latestClientVersionNumeric).toBe(100);
    });

    it('| should not set test versions', () => {
      (service as any).setLatestClientVersion('v1.0.0-test', 100);

      expect(service.latestClientVersion).toBeUndefined();
    });

    it('| should not set dev versions', () => {
      (service as any).setLatestClientVersion('v1.0.0-dev', 100);

      expect(service.latestClientVersion).toBeUndefined();
    });
  });

  describe('| triggerCreateSnapshot', () => {
    it('| should create snapshot', async () => {
      const mockSnapshot: TestServerStatus = new TestServerStatus({
        status: 'ready',
      });

      spyOn(service, 'getServerStatusSnapshot').and.returnValue(Promise.resolve(mockSnapshot));
      spyOn(service as any, 'getServerStatusSnapshotControlService').and.returnValue(mockSnapshotControlService);
      mockSnapshotControlService.saveSnapshot.and.returnValue(Promise.resolve(mockSnapshot));

      await (service as any).triggerCreateSnapshot('test-issuer');

      expect(service.getServerStatusSnapshot).toHaveBeenCalled();
      expect(mockSnapshotControlService.saveSnapshot).toHaveBeenCalled();
    });

    it('| should handle errors', async () => {
      const error = new Error('Snapshot failed');
      spyOn(service, 'getServerStatusSnapshot').and.returnValue(Promise.reject(error));

      try {
        await (service as any).triggerCreateSnapshot('test-issuer');
        fail('Should have thrown an error');
      } catch (err) {
        expect(err).toBeInstanceOf(DyFM_Error);
        expect((err as DyFM_Error)._errorCode).toContain('DyNTS-SSCS-TCS0');
      }
    });
  });

  describe('| checkDbReadiness', () => {
    it('| should be ready when connected (readyState=1) and ping succeeds', async () => {
      const fakeConnection = {
        readyState: 1,
        db: { admin: () => ({ ping: async () => ({ ok: 1 }) }) },
      };
      spyOn(service as any, 'getMongooseConnection').and.returnValue(fakeConnection);

      const result = await service.checkDbReadiness();

      expect(result.ready).toBe(true);
      expect(result.dbReadyState).toBe(1);
      expect(result.dbPingOk).toBe(true);
      expect(result.serverVersion).toBe(service.serverVersion);
      expect(result.uptime).toBeGreaterThanOrEqual(0);
    });

    it('| should NOT be ready when disconnected (readyState=0) — no ping attempted', async () => {
      const fakeConnection = { readyState: 0, db: undefined };
      spyOn(service as any, 'getMongooseConnection').and.returnValue(fakeConnection);

      const result = await service.checkDbReadiness();

      expect(result.ready).toBe(false);
      expect(result.dbReadyState).toBe(0);
      expect(result.dbPingOk).toBe(false);
    });

    // FIX-REGRESSZIO (2026-07-22) — a `getMongooseConnection()` a KAPCSOLODOTT handle-t valassza.
    // Elesben mert kiindulas: `mongoose.connection` disconnected (0) + 0 model, miközben a
    // `mongoose.connections`-ban VOLT egy readyState=1 connection -> hamis 503 az egesz flottan.
    // Ezek a tesztek NEM spy-olnak a getMongooseConnection-re (kulonben epp a javitott logikat
    // kerulnenk meg), hanem a `mongoose.connections` tombot cserelik ki.
    it('| should pick the CONNECTED connection when mongoose.connection is a stale/disconnected handle', async () => {
      // eslint-disable-next-line @typescript-eslint/no-var-requires
      const mongooseModule: any = require('mongoose'); // ccap-review-disable-line no-any-type
      const originalConnections: any[] = mongooseModule.connections; // ccap-review-disable-line no-any-type
      const liveConnection: any = { // ccap-review-disable-line no-any-type
        readyState: 1,
        host: 'mongodb',
        name: 'adventor',
        models: { user: {} },
        db: { admin: () => ({ ping: async () => ({ ok: 1 }) }) },
      };

      try {
        mongooseModule.connections = [ liveConnection ];

        const result = await service.checkDbReadiness();

        expect(result.ready).toBe(true);
        expect(result.dbReadyState).toBe(1);
        expect(result.dbPingOk).toBe(true);
        expect(result.dbHost).toBe('mongodb');
      } finally {
        mongooseModule.connections = originalConnections;
      }
    });

    it('| should still report NOT ready when NO connection is live (a real DB outage is not masked)', async () => {
      // eslint-disable-next-line @typescript-eslint/no-var-requires
      const mongooseModule: any = require('mongoose'); // ccap-review-disable-line no-any-type
      const originalConnections: any[] = mongooseModule.connections; // ccap-review-disable-line no-any-type

      try {
        mongooseModule.connections = [ { readyState: 0, db: undefined } ];

        const result = await service.checkDbReadiness();

        expect(result.ready).toBe(false);
        expect(result.dbPingOk).toBe(false);
      } finally {
        mongooseModule.connections = originalConnections;
      }
    });

    // DIAGNOSZTIKA (2026-07-22) — a "readiness 503, de az app kiszolgál" flotta-lelet miatt.
    // A lényeg: a diag-mezők akkor is kitöltődnek, amikor a probe NEM-ready-t jelent — épp AKKOR
    // kellenek, hogy a következő mérés eldöntse, a probe mér-e rosszul vagy a DB halott-e.
    it('| should populate diagnostics fields EVEN when not ready (this is when they matter)', async () => {
      const fakeConnection = {
        readyState: 0,
        db: undefined,
        host: 'mongodb',
        name: 'adventor',
        models: { user: {}, preset: {} },
      };
      spyOn(service as any, 'getMongooseConnection').and.returnValue(fakeConnection);

      const result = await service.checkDbReadiness();

      expect(result.ready).toBe(false);
      expect(result.dbHost).toBe('mongodb');
      expect(result.dbName).toBe('adventor');
      // 0 model a default connectionön = a data-layer NEM ezt a handle-t használja (a fő gyanú)
      expect(result.dbModelCount).toBe(2);
      expect(result.dbConnectionCount).toEqual(jasmine.any(Number));
      expect(result.dbOtherReadyStates).toEqual(jasmine.any(Array));
    });

    it('| should stay ready even if diagnostics collection throws (probe must never fail)', async () => {
      // a diag-gyűjtés SAJÁT try-ban van → a getter-robbanás nem ronthatja el a readiness-választ
      const fakeConnection = {
        readyState: 1,
        db: { admin: () => ({ ping: async () => ({ ok: 1 }) }) },
        get host(): string { throw new Error('diag boom'); },
      };
      spyOn(service as any, 'getMongooseConnection').and.returnValue(fakeConnection);

      const result = await service.checkDbReadiness();

      expect(result.ready).toBe(true);
      expect(result.dbReadyState).toBe(1);
      expect(result.dbPingOk).toBe(true);
    });

    it('| should NOT be ready when connected but ping fails (DB unresponsive)', async () => {
      const fakeConnection = {
        readyState: 1,
        db: { admin: () => ({ ping: async () => { throw new Error('no pong'); } }) },
      };
      spyOn(service as any, 'getMongooseConnection').and.returnValue(fakeConnection);

      const result = await service.checkDbReadiness();

      expect(result.ready).toBe(false);
      expect(result.dbReadyState).toBe(1);
      expect(result.dbPingOk).toBe(false);
    });

    it('| should never throw — returns not-ready on internal error', async () => {
      spyOn(service as any, 'getMongooseConnection').and.throwError(new Error('boom'));

      const result = await service.checkDbReadiness();

      expect(result.ready).toBe(false);
      expect(result.dbReadyState).toBe(0);
    });
  });

  describe('| getServerStatusSnapshot', () => {
    it('| should return server status snapshot', async () => {
      const mockStatus: TestServerStatus = new TestServerStatus({
        status: 'ready',
      });

      spyOn(service, 'getServerStatus').and.returnValue(Promise.resolve(mockStatus));

      const result = await service.getServerStatusSnapshot('test-issuer');

      expect(result).toBeDefined();
      expect(result.status).toBe('ready');
    });

    it('| should handle errors', async () => {
      const error = new Error('Snapshot failed');
      spyOn(service, 'getServerStatus').and.returnValue(Promise.reject(error));

      try {
        await service.getServerStatusSnapshot('test-issuer');
        fail('Should have thrown an error');
      } catch (err) {
        expect(err).toBeInstanceOf(DyFM_Error);
        expect((err as DyFM_Error)._errorCode).toContain('DyNTS-SSCS-GSS0');
      }
    });
  });
});