import { afterEach, describe, expect, it, vi } from 'vitest';
import {
  classifyError,
  createErrorResponse,
  createRetryHandler,
  ErrorSeverity,
  ErrorType,
  getUserFriendlyErrorMessage,
  isAuthenticationError,
  isBillingError,
  isRateLimitError,
  isRetryableError,
  logError,
  ProviderErrorHandler,
} from '../../../src/lib/error-handler.js';

const logger = vi.hoisted(() => ({ error: vi.fn(), debug: vi.fn() }));
vi.mock('@automaker/utils', () => ({ createLogger: () => logger }));

afterEach(() => vi.useRealTimers());

describe('provider error policy', () => {
  it.each([
    ['invalid_api_key', ErrorType.AUTHENTICATION, false],
    ['insufficient credit', ErrorType.BILLING, false],
    ['429 too many requests', ErrorType.RATE_LIMIT, true],
    ['ECONNREFUSED', ErrorType.NETWORK, true],
    ['operation aborted', ErrorType.TIMEOUT, true],
    ['403 forbidden', ErrorType.PERMISSION, false],
    ['command not found', ErrorType.CLI_NOT_FOUND, false],
    ['unknown model', ErrorType.MODEL_NOT_SUPPORTED, false],
    ['503 internal server error', ErrorType.SERVER_ERROR, true],
    ['an unfamiliar failure', ErrorType.UNKNOWN, true],
  ])('classifies %s with the correct retry policy', (message, type, retryable) => {
    expect(classifyError(new Error(message), 'codex', { taskId: 'task-a' })).toMatchObject({
      type,
      retryable,
      provider: 'codex',
      technicalMessage: message,
      context: { taskId: 'task-a' },
    });
  });

  it.each([
    [{ message: 'invalid api key' }, 'invalid api key'],
    [{ error: { message: 'payment required' } }, 'payment required'],
    [{ error: 'token revoked' }, 'token revoked'],
    [{ error: { code: 'unexpected' } }, '{"code":"unexpected"}'],
    [{ code: 123 }, '{"code":123}'],
    [null, 'null'],
    [undefined, 'undefined'],
    [42, '42'],
  ])('preserves structured evidence while classifying it', (input, technicalMessage) => {
    expect(classifyError(input).technicalMessage).toBe(technicalMessage);
  });

  it('returns a safe client response with actionable authentication guidance', () => {
    const evidence = 'invalid api key: test-only-sensitive-value';
    const response = createErrorResponse(evidence, 'claude', { taskId: 'task-a' });
    expect(response).toMatchObject({
      success: false,
      errorType: ErrorType.AUTHENTICATION,
      severity: ErrorSeverity.HIGH,
      retryable: false,
    });
    expect(response.suggestedAction).toContain('Verify your API key');
    expect(JSON.stringify(response)).not.toContain('test-only-sensitive-value');
    expect(getUserFriendlyErrorMessage(evidence, 'claude')).toMatch(/^\[CLAUDE\]/);
    expect(getUserFriendlyErrorMessage(evidence)).not.toContain('[CLAUDE]');
  });

  it.each(['claude', 'codex', 'cursor'] as const)(
    'keeps %s error shortcuts consistent with fatal authentication, billing, and retryable rate limits',
    (provider) => {
      const handler = ProviderErrorHandler[provider];
      expect(handler.classify('unauthorized')).toMatchObject({
        provider,
        type: ErrorType.AUTHENTICATION,
        retryable: false,
      });
      expect(handler.getUserMessage('quota exceeded')).toContain(`[${provider.toUpperCase()}]`);
      expect(handler.isAuth('token revoked')).toBe(true);
      expect(handler.isAuth('network')).toBe(false);
      expect(handler.isBilling('payment required')).toBe(true);
      expect(handler.isBilling('network')).toBe(false);
      expect(handler.isRateLimit('429')).toBe(true);
      expect(handler.isRateLimit('network')).toBe(false);
    }
  );

  it('exposes common policy predicates and diagnostic context', () => {
    expect(isAuthenticationError('unauthorized')).toBe(true);
    expect(isBillingError('insufficient credit')).toBe(true);
    expect(isRateLimitError('too many requests')).toBe(true);
    expect(isRetryableError('forbidden')).toBe(false);
    expect(isRetryableError('network')).toBe(true);
    logError('forbidden', 'codex', 'dispatch', { taskId: 'task-a' });
    expect(logger.error).toHaveBeenLastCalledWith(
      'Error in codex during dispatch',
      expect.objectContaining({
        type: ErrorType.PERMISSION,
        context: { operation: 'dispatch', taskId: 'task-a' },
      })
    );
    logError('unfamiliar');
    expect(logger.error.mock.calls.at(-1)?.[0]).toBe('Error in unknown');
  });
});

describe('provider retries', () => {
  it('retries temporary failures with bounded exponential delays and returns the first success', async () => {
    vi.useFakeTimers();
    vi.spyOn(Math, 'random').mockReturnValue(0);
    const operation = vi
      .fn()
      .mockRejectedValueOnce(new Error('network'))
      .mockRejectedValueOnce(new Error('503'))
      .mockResolvedValue('ready');
    const result = createRetryHandler(3, 100)(operation);
    expect(operation).toHaveBeenCalledTimes(1);
    await vi.advanceTimersByTimeAsync(99);
    expect(operation).toHaveBeenCalledTimes(1);
    await vi.advanceTimersByTimeAsync(1);
    expect(operation).toHaveBeenCalledTimes(2);
    await vi.advanceTimersByTimeAsync(199);
    expect(operation).toHaveBeenCalledTimes(2);
    await vi.advanceTimersByTimeAsync(1);
    await expect(result).resolves.toBe('ready');
    expect(operation).toHaveBeenCalledTimes(3);
  });

  it('does not retry invalid credentials or spend the retry budget on permanent failures', async () => {
    vi.useFakeTimers();
    const failure = new Error('unauthorized');
    const operation = vi.fn().mockRejectedValue(failure);
    await expect(createRetryHandler()(operation)).rejects.toBe(failure);
    expect(operation).toHaveBeenCalledTimes(1);
    expect(vi.getTimerCount()).toBe(0);
  });

  it('stops after the configured budget and preserves the last error', async () => {
    vi.useFakeTimers();
    const failure = new Error('custom transient');
    const operation = vi.fn().mockRejectedValue(failure);
    const policy = vi.fn().mockReturnValue(true);
    const result = createRetryHandler(2, 1)(operation, policy);
    const assertion = expect(result).rejects.toBe(failure);
    await vi.runAllTimersAsync();
    await assertion;
    expect(operation).toHaveBeenCalledTimes(3);
    expect(policy).toHaveBeenCalledTimes(2);
  });
});