/**
 * @vitest-environment node
 */

import { describe, it, expect } from 'vitest';
import {
  calculateBackoffDelay,
  parseRetryAfter,
  calculateRetryDelay,
  sleep,
  calculateMaxTotalDelay,
  canContinueRetrying,
} from '../../../utils/retry/exponential-backoff.js';
import { RetryPolicy } from '../../../utils/retry/retry-policy.js';
import { ErrorCategory } from '../../../utils/errors/categories.js';

describe('Exponential Backoff', () => {
  const testPolicy: RetryPolicy = {
    maxAttempts: 3,
    baseDelay: 1000,
    maxDelay: 10000,
    jitterFactor: 0.25,
    retriableErrors: [ErrorCategory.NETWORK],
    respectRetryAfter: true,
    name: 'test',
  };

  describe('calculateBackoffDelay', () => {
    it('should calculate exponential backoff correctly', () => {
      // Without jitter (jitterFactor = 0)
      const noJitterPolicy = { ...testPolicy, jitterFactor: 0 };

      expect(calculateBackoffDelay(0, noJitterPolicy)).toBe(1000); // 1000 * 2^0 = 1000
      expect(calculateBackoffDelay(1, noJitterPolicy)).toBe(2000); // 1000 * 2^1 = 2000
      expect(calculateBackoffDelay(2, noJitterPolicy)).toBe(4000); // 1000 * 2^2 = 4000
      expect(calculateBackoffDelay(3, noJitterPolicy)).toBe(8000); // 1000 * 2^3 = 8000
    });

    it('should cap delay at maxDelay', () => {
      const noJitterPolicy = { ...testPolicy, jitterFactor: 0 };

      expect(calculateBackoffDelay(4, noJitterPolicy)).toBe(10000); // Would be 16000, capped at 10000
      expect(calculateBackoffDelay(10, noJitterPolicy)).toBe(10000); // Would be 1024000, capped at 10000
    });

    it('should apply jitter within expected range', () => {
      const delays: number[] = [];
      for (let i = 0; i < 100; i++) {
        delays.push(calculateBackoffDelay(1, testPolicy)); // Base 2000ms
      }

      // With 0.25 jitter factor, delays should be between 1500 and 2500
      const minDelay = Math.min(...delays);
      const maxDelay = Math.max(...delays);

      expect(minDelay).toBeGreaterThanOrEqual(1500);
      expect(maxDelay).toBeLessThanOrEqual(2500);

      // Should have good distribution (not all the same)
      const uniqueDelays = new Set(delays);
      expect(uniqueDelays.size).toBeGreaterThan(50);
    });

    it('should never return negative delays', () => {
      const highJitterPolicy = { ...testPolicy, jitterFactor: 1.0 };

      for (let i = 0; i < 100; i++) {
        const delay = calculateBackoffDelay(0, highJitterPolicy);
        expect(delay).toBeGreaterThanOrEqual(0);
      }
    });
  });

  describe('parseRetryAfter', () => {
    it('should parse seconds format', () => {
      const result = parseRetryAfter('120');
      expect(result).toBeTruthy();
      expect(result?.delayMs).toBe(120000);
      expect(result?.source).toBe('header-seconds');
      expect(result?.originalValue).toBe('120');
    });

    it('should parse HTTP-date format', () => {
      const futureDate = new Date(Date.now() + 60000); // 1 minute from now
      const httpDate = futureDate.toUTCString();

      const result = parseRetryAfter(httpDate);
      expect(result).toBeTruthy();
      expect(result?.source).toBe('header-date');
      expect(result?.delayMs).toBeGreaterThan(59000);
      expect(result?.delayMs).toBeLessThan(61000);
    });

    it('should handle past dates gracefully', () => {
      const pastDate = new Date(Date.now() - 60000); // 1 minute ago
      const httpDate = pastDate.toUTCString();

      const result = parseRetryAfter(httpDate);
      expect(result).toBeTruthy();
      expect(result?.delayMs).toBe(0);
      expect(result?.source).toBe('header-date');
    });

    it('should return null for invalid values', () => {
      expect(parseRetryAfter(undefined)).toBeNull();
      expect(parseRetryAfter('')).toBeNull();
      expect(parseRetryAfter('invalid')).toBeNull();
      expect(parseRetryAfter('-5')).toBeNull();
      expect(parseRetryAfter('abc123')).toBeNull();
    });

    it('should handle edge cases', () => {
      expect(parseRetryAfter('0')).toEqual({
        delayMs: 0,
        source: 'header-seconds',
        originalValue: '0',
      });

      expect(parseRetryAfter('  120  ')).toEqual({
        delayMs: 120000,
        source: 'header-seconds',
        originalValue: '120',
      });
    });
  });

  describe('calculateRetryDelay', () => {
    it('should use Retry-After header when policy respects it', () => {
      const result = calculateRetryDelay(0, testPolicy, '5');
      expect(result.delayMs).toBe(5000);
      expect(result.source).toBe('header-seconds');
    });

    it('should cap Retry-After delay at policy maxDelay', () => {
      const result = calculateRetryDelay(0, testPolicy, '20'); // 20 seconds > 10 second max
      expect(result.delayMs).toBe(10000);
      expect(result.source).toBe('header-seconds');
    });

    it('should use exponential backoff when no Retry-After header', () => {
      const noJitterPolicy = { ...testPolicy, jitterFactor: 0 };
      const result = calculateRetryDelay(2, noJitterPolicy);
      expect(result.delayMs).toBe(4000);
      expect(result.source).toBe('exponential');
    });

    it('should ignore Retry-After when policy does not respect it', () => {
      const ignorePolicy = { ...testPolicy, respectRetryAfter: false, jitterFactor: 0 };
      const result = calculateRetryDelay(0, ignorePolicy, '5');
      expect(result.delayMs).toBe(1000); // Uses exponential backoff instead
      expect(result.source).toBe('exponential');
    });
  });

  describe('sleep', () => {
    it('should sleep for specified duration', async () => {
      const start = Date.now();
      await sleep(100);
      const elapsed = Date.now() - start;
      expect(elapsed).toBeGreaterThanOrEqual(95); // Allow small variance
      expect(elapsed).toBeLessThan(150);
    });

    it('should return immediately for zero or negative values', async () => {
      const start = Date.now();
      await sleep(0);
      await sleep(-100);
      const elapsed = Date.now() - start;
      expect(elapsed).toBeLessThan(10);
    });
  });

  describe('calculateMaxTotalDelay', () => {
    it('should calculate total maximum delay correctly', () => {
      const noJitterPolicy = { ...testPolicy, jitterFactor: 0, maxAttempts: 3 };
      // 1000 + 2000 + 4000 = 7000
      expect(calculateMaxTotalDelay(noJitterPolicy)).toBe(7000);
    });

    it('should account for maxDelay cap', () => {
      const noJitterPolicy = { ...testPolicy, jitterFactor: 0, maxAttempts: 5, maxDelay: 5000 };
      // 1000 + 2000 + 4000 + 5000 + 5000 = 17000 (last two capped at 5000)
      expect(calculateMaxTotalDelay(noJitterPolicy)).toBe(17000);
    });

    it('should include jitter buffer', () => {
      const withJitterPolicy = { ...testPolicy, jitterFactor: 0.25, maxAttempts: 3 };
      const total = calculateMaxTotalDelay(withJitterPolicy);
      // Base: 1000 + 2000 + 4000 = 7000
      // Jitter buffer: 10000 * 0.25 * 3 = 7500
      // Total: 7000 + 7500 = 14500
      expect(total).toBeGreaterThan(7000);
      expect(total).toBeLessThanOrEqual(14500);
    });

    it('should return 0 for zero attempts', () => {
      const noAttemptsPolicy = { ...testPolicy, maxAttempts: 0 };
      expect(calculateMaxTotalDelay(noAttemptsPolicy)).toBe(0);
    });
  });

  describe('canContinueRetrying', () => {
    it('should allow retrying within duration', () => {
      const startTime = Date.now();
      expect(canContinueRetrying(startTime, 1000)).toBe(true);
    });

    it('should prevent retrying after max duration', () => {
      const startTime = Date.now() - 2000; // Started 2 seconds ago
      expect(canContinueRetrying(startTime, 1000)).toBe(false); // 1 second limit
    });

    it('should handle edge cases', () => {
      const now = Date.now();
      expect(canContinueRetrying(now, 0)).toBe(false);
      expect(canContinueRetrying(now - 999, 1000)).toBe(true);
      expect(canContinueRetrying(now - 1001, 1000)).toBe(false);
    });
  });

  describe('Property-based tests for jitter distribution', () => {
    it('should maintain jitter within specified bounds', () => {
      const policy = { ...testPolicy, jitterFactor: 0.3 };
      const attemptNumber = 2;
      const baseDelay = policy.baseDelay * Math.pow(2, attemptNumber);
      const samples = 1000;

      const delays: number[] = [];
      for (let i = 0; i < samples; i++) {
        delays.push(calculateBackoffDelay(attemptNumber, policy));
      }

      // Calculate statistics
      const mean = delays.reduce((a, b) => a + b, 0) / samples;
      const min = Math.min(...delays);
      const max = Math.max(...delays);

      // Mean should be close to base delay
      expect(Math.abs(mean - baseDelay)).toBeLessThan(baseDelay * 0.05);

      // Min and max should be within jitter bounds
      const expectedMin = baseDelay * (1 - policy.jitterFactor);
      const expectedMax = baseDelay * (1 + policy.jitterFactor);
      expect(min).toBeGreaterThanOrEqual(expectedMin * 0.95); // Allow small variance
      expect(max).toBeLessThanOrEqual(expectedMax * 1.05);

      // Should have good distribution
      const stdDev = Math.sqrt(
        delays.map((x) => Math.pow(x - mean, 2)).reduce((a, b) => a + b, 0) / samples
      );
      expect(stdDev).toBeGreaterThan(baseDelay * policy.jitterFactor * 0.2);
    });
  });
});