import { describe, it, expect, beforeEach, afterEach } from 'vitest';
import { HealthTestContext } from '../HealthTestContext';

describe('API Connection Monitor - Metrics & Selection', () => {
  let context: HealthTestContext;

  beforeEach(() => {
    context = HealthTestContext.create();
    context.reset();
  });

  afterEach(() => {
    context.teardown();
  });

  describe('Metrics Calculation', () => {
    it('should correctly calculate reliability percentage', async () => {
      context.mockFetch.mockResolvedValue({
        ok: true,
        status: 200,
      });

      for (let i = 0; i < 7; i++) {
        await context.apiConnectionMonitor.performHealthCheck();
      }

      context.mockFetch.mockRejectedValue(new Error('ECONNREFUSED'));

      for (let i = 0; i < 3; i++) {
        await context.apiConnectionMonitor.performHealthCheck();
      }

      expect(context.apiConnectionMonitor.getReliability()).toBeCloseTo(70, 1);
    });

    it('should correctly calculate average response time', async () => {
      const responseTimes = [50, 100, 150];
      
      context.mockFetch.mockImplementation(async () => {
        const time = responseTimes.shift() || 50;
        await new Promise(resolve => setTimeout(resolve, time));
        return {
          ok: true,
          status: 200,
        } as Response;
      });

      await context.apiConnectionMonitor.performHealthCheck();
      await context.apiConnectionMonitor.performHealthCheck();
      await context.apiConnectionMonitor.performHealthCheck();

      const health = context.apiConnectionMonitor.getHealth();
      expect(health.averageResponseTime).toBeGreaterThanOrEqual(100);
    });
  });

  describe('Endpoint Selection', () => {
    it('should try multiple endpoints when primary fails', async () => {
      let callCount = 0;
      context.mockFetch.mockImplementation(() => {
        callCount++;
        if (callCount === 1) {
          return Promise.reject(new Error('ECONNREFUSED'));
        } else {
          return Promise.resolve({
            ok: true,
            status: 200,
          } as Response);
        }
      });

      const result = await context.apiConnectionMonitor.performHealthCheck();

      expect(result.healthy).toBe(true);
      expect(context.apiConnectionMonitor.getStatus()).toBe('connected');
    });

    it('should handle all endpoints being unavailable', async () => {
      context.mockFetch.mockImplementation(async () => {
        throw new Error('ECONNREFUSED');
      });

      // Perform 3 checks to reach disconnected status
      await context.apiConnectionMonitor.performHealthCheck();
      await context.apiConnectionMonitor.performHealthCheck();
      const result = await context.apiConnectionMonitor.performHealthCheck();

      expect(result.healthy).toBe(false);
      expect(context.apiConnectionMonitor.getStatus()).toBe('disconnected');
    });
  });
});