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

describe('GetConnectionStatusUseCase', () => {
  let context: HealthTestContext;

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

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

  it('should retrieve connection status when healthy', async () => {
    context.healthCheckAdapter.setResponseTime(50);
    await context.checkApiHealthUseCase.execute();

    const result = await context.getConnectionStatusUseCase.execute();

    expect(result.status).toBe('connected');
    expect(result.reliability).toBe(100);
    expect(result.lastCheck).toBeInstanceOf(Date);
  });

  it('should retrieve connection status when degraded', async () => {
    context.healthCheckAdapter.setResponseTime(50);

    // Use adapter directly as GetConnectionStatusUseCase uses healthCheckAdapter
    for (let i = 0; i < 5; i++) {
      await context.healthCheckAdapter.performHealthCheck();
    }

    context.healthCheckAdapter.setShouldFail(true, 'ECONNREFUSED');

    // 3 failures to reach degraded (5/8 = 62.5%)
    // In InMemoryHealthCheckAdapter:
    // reliability = 5/8 = 0.625
    // consecutiveFailures = 3
    // status will be 'disconnected' if consecutiveFailures >= 3
    // To get 'degraded', we need reliability < 0.7 and consecutiveFailures < 3
    
    // Let's do 2 failures, then 1 success, then 1 failure
    // Total: 5 success, 2 failure, 1 success, 1 failure = 6 success, 3 failure = 9 total
    // Reliability: 6/9 = 66.6%
    // Consecutive failures will be 1 at the end.
    
    await context.healthCheckAdapter.performHealthCheck(); // Fail 1
    await context.healthCheckAdapter.performHealthCheck(); // Fail 2
    context.healthCheckAdapter.setShouldFail(false);
    await context.healthCheckAdapter.performHealthCheck(); // Success 6
    context.healthCheckAdapter.setShouldFail(true, 'ECONNREFUSED');
    await context.healthCheckAdapter.performHealthCheck(); // Fail 3
    
    // Total requests: 5 + 2 + 1 + 1 = 9
    // Successful: 5 + 1 = 6
    // Reliability: 6/9 = 66.6%
    // Consecutive failures: 1

    const result = await context.getConnectionStatusUseCase.execute();

    expect(result.status).toBe('degraded');
    expect(result.reliability).toBeCloseTo(66.7, 1);
  });

  it('should retrieve connection status when disconnected', async () => {
    context.healthCheckAdapter.setShouldFail(true, 'ECONNREFUSED');

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

    const result = await context.getConnectionStatusUseCase.execute();

    expect(result.status).toBe('disconnected');
    expect(result.consecutiveFailures).toBe(3);
    expect(result.lastFailure).toBeInstanceOf(Date);
  });

  it('should calculate average response time correctly', async () => {
    // Use adapter directly
    context.healthCheckAdapter.setResponseTime(50);
    await context.healthCheckAdapter.performHealthCheck();
    
    context.healthCheckAdapter.setResponseTime(100);
    await context.healthCheckAdapter.performHealthCheck();
    
    context.healthCheckAdapter.setResponseTime(150);
    await context.healthCheckAdapter.performHealthCheck();

    const result = await context.getConnectionStatusUseCase.execute();

    expect(result.averageResponseTime).toBeCloseTo(100, 1);
  });
});