import { RealBLEManager } from '../BLEManager';
import { MockBLEManager } from '../MockBLEManager';
import {
  SensorHealthStatus,
  WiFiSignalQuality,
  SensorHealthMetrics,
} from '../types';

describe('BLEManager - Health Monitoring', () => {
  let manager: MockBLEManager; // Use MockBLEManager for testing

  beforeEach(() => {
    manager = new MockBLEManager();
  });

  afterEach(async () => {
    await manager.cleanup();
  });

  describe('getSensorHealth', () => {
    it('should return health metrics for a sensor', async () => {
      const wellId = 497;
      const mac = '142B2F81A14C';

      const health = await manager.getSensorHealth(wellId, mac);

      expect(health).not.toBeNull();
      expect(health?.deviceName).toBe('WP_497_81a14c');
      expect(health?.overallHealth).toBeDefined();
      expect(health?.connectionStatus).toMatch(/online|warning|offline/);
      expect(health?.wifiSignalQuality).toBeDefined();
    });

    it('should include WiFi metrics', async () => {
      const health = await manager.getSensorHealth(497, '142B2F81A14C');

      expect(health).not.toBeNull();
      expect(health?.wifiRssi).toBeDefined();
      expect(health?.wifiSsid).toBeDefined();
      expect(health?.wifiConnected).toBe(true);
    });

    it('should include communication stats', async () => {
      const health = await manager.getSensorHealth(497, '142B2F81A14C');

      expect(health).not.toBeNull();
      expect(health?.communication).toBeDefined();
      expect(health?.communication.successfulCommands).toBeGreaterThanOrEqual(0);
      expect(health?.communication.failedCommands).toBeGreaterThanOrEqual(0);
      expect(health?.communication.averageResponseTime).toBeGreaterThan(0);
    });

    it('should include BLE metrics', async () => {
      const health = await manager.getSensorHealth(497, '142B2F81A14C');

      expect(health).not.toBeNull();
      expect(health?.bleRssi).toBeDefined();
      expect(health?.bleConnectionAttempts).toBeGreaterThanOrEqual(0);
      expect(health?.bleConnectionFailures).toBeGreaterThanOrEqual(0);
    });

    it('should return null for non-existent sensor', async () => {
      // Mock implementation always returns data, but real one would return null
      const health = await manager.getSensorHealth(999, 'NONEXISTENT');
      // For mock, this will still return data - in real implementation it would be null
      expect(health).toBeDefined();
    });
  });

  describe('getAllSensorHealth', () => {
    it('should return empty map initially', () => {
      const allHealth = manager.getAllSensorHealth();
      expect(allHealth.size).toBe(0);
    });

    it('should return cached health metrics after getSensorHealth call', async () => {
      await manager.getSensorHealth(497, '142B2F81A14C');

      const allHealth = manager.getAllSensorHealth();
      expect(allHealth.size).toBeGreaterThan(0);
      expect(allHealth.has('WP_497_81a14c')).toBe(true);
    });

    it('should cache multiple sensor metrics', async () => {
      await manager.getSensorHealth(497, '142B2F81A14C');
      await manager.getSensorHealth(523, '142B2F81AAD4');

      const allHealth = manager.getAllSensorHealth();
      expect(allHealth.size).toBe(2);
      expect(allHealth.has('WP_497_81a14c')).toBe(true);
      expect(allHealth.has('WP_523_81aad4')).toBe(true);
    });
  });

  describe('Health status calculation', () => {
    it('should categorize WiFi signal strength correctly', async () => {
      const health = await manager.getSensorHealth(497, '142B2F81A14C');

      if (health) {
        // Mock returns -60 dBm which is GOOD
        expect(health.wifiSignalQuality).toBe(WiFiSignalQuality.GOOD);
      }
    });

    it('should calculate overall health status', async () => {
      const health = await manager.getSensorHealth(497, '142B2F81A14C');

      expect(health).not.toBeNull();
      expect(Object.values(SensorHealthStatus)).toContain(health?.overallHealth);
    });

    it('should track last seen time', async () => {
      const health = await manager.getSensorHealth(497, '142B2F81A14C');

      expect(health).not.toBeNull();
      expect(health?.lastSeen).toBeInstanceOf(Date);
      expect(health?.lastSeenMinutesAgo).toBeGreaterThanOrEqual(0);
    });
  });

  describe('Cleanup', () => {
    it('should clear health metrics on cleanup', async () => {
      await manager.getSensorHealth(497, '142B2F81A14C');
      expect(manager.getAllSensorHealth().size).toBeGreaterThan(0);

      await manager.cleanup();

      expect(manager.getAllSensorHealth().size).toBe(0);
    });
  });
});