/**
 * @vitest-environment node
 */

import { AxiosError } from 'axios';
import { ErrorCategory } from '../utils/errors/categories.js';
import {
  classifyGraphQLError,
  isError,
  isErrorWithMessage,
  isAxiosErrorWithCriteria,
  extractGraphQLErrorMessages,
  handleGraphQLSpecificError,
  handleNetworkError,
  handleHttpStatusError,
  handleApiError,
} from '../utils/errors/handlers.js';

// Helper function to create a mock AxiosError
const createMockAxiosError = (statusCode?: number, data?: unknown, code?: string): AxiosError => {
  const error = new Error('Axios error') as AxiosError;
  error.isAxiosError = true;
  error.code = code;

  if (statusCode) {
    error.response = {
      status: statusCode,
      statusText: `Status ${statusCode}`,
      headers: {},
      config: { headers: {} as Record<string, unknown> },
      data,
    };
  }

  return error;
};

describe('Error Handlers', () => {
  describe('classifyGraphQLError', () => {
    it('should classify authentication errors correctly', () => {
      const authErrors = [
        new Error('Authentication failed'),
        new Error('Unauthorized access'),
        new Error('Access denied'),
        new Error('Not authorized to access this resource'),
        new Error('This action is forbidden'),
        new Error('Invalid token provided'),
        new Error('Missing API key'),
      ];

      for (const error of authErrors) {
        expect(classifyGraphQLError(error)).toBe(ErrorCategory.AUTH);
      }
    });

    it('should classify rate limit errors correctly', () => {
      const rateLimitErrors = [
        new Error('Rate limit exceeded'),
        new Error('Too many requests'),
        new Error('Your account is throttled'),
      ];

      for (const error of rateLimitErrors) {
        expect(classifyGraphQLError(error)).toBe(ErrorCategory.RATE_LIMIT);
      }
    });

    it('should classify network errors correctly', () => {
      const networkErrors = [
        new Error('Network error occurred'),
        new Error('Connection failed'),
        new Error('ECONNRESET error'),
        new Error('ECONNREFUSED error'),
      ];

      for (const error of networkErrors) {
        expect(classifyGraphQLError(error)).toBe(ErrorCategory.NETWORK);
      }
    });

    it('should classify timeout errors correctly', () => {
      const timeoutErrors = [
        new Error('Request timeout'),
        new Error('Operation timed out'),
        new Error('ETIMEDOUT error'),
      ];

      for (const error of timeoutErrors) {
        expect(classifyGraphQLError(error)).toBe(ErrorCategory.TIMEOUT);
      }
    });

    it('should classify schema errors correctly', () => {
      const schemaErrors = [
        new Error('Cannot query field "nonexistent"'),
        new Error('Unknown argument "invalid"'),
        new Error('Unknown type "Invalid"'),
        new Error('Field not defined on type "Object"'),
      ];

      for (const error of schemaErrors) {
        expect(classifyGraphQLError(error)).toBe(ErrorCategory.SCHEMA);
      }
    });

    it('should classify not found errors correctly', () => {
      const notFoundErrors = [
        new Error('Resource not found'),
        new Error('Object not found'),
        new Error('NoneType error'),
        new Error('The requested project does not exist'),
      ];

      for (const error of notFoundErrors) {
        expect(classifyGraphQLError(error)).toBe(ErrorCategory.NOT_FOUND);
      }
    });

    it('should classify server errors correctly', () => {
      const serverErrors = [
        new Error('Server error occurred'),
        new Error('Internal server error'),
        new Error('500 error'),
      ];

      for (const error of serverErrors) {
        expect(classifyGraphQLError(error)).toBe(ErrorCategory.SERVER);
      }
    });

    it('should classify unrecognized errors as OTHER', () => {
      const otherErrors = [
        new Error('Some random error'),
        new Error('Unexpected behavior'),
        new Error('Unknown issue'),
      ];

      for (const error of otherErrors) {
        expect(classifyGraphQLError(error)).toBe(ErrorCategory.OTHER);
      }
    });
  });

  describe('isError', () => {
    it('should return true for Error instances', () => {
      expect(isError(new Error('Test error'))).toBe(true);
    });

    it('should return true for objects with message property', () => {
      expect(isError({ message: 'Test error' })).toBe(true);
    });

    it('should return false for null or undefined', () => {
      expect(isError(null)).toBe(false);
      expect(isError(undefined)).toBe(false);
    });

    it('should return false for primitive values', () => {
      expect(isError(123)).toBe(false);
      expect(isError('string')).toBe(false);
      expect(isError(true)).toBe(false);
    });

    it('should return false for objects without message property', () => {
      expect(isError({})).toBe(false);
      expect(isError({ other: 'property' })).toBe(false);
    });

    it('should return false if message is not a string', () => {
      expect(isError({ message: 123 })).toBe(false);
      expect(isError({ message: true })).toBe(false);
      expect(isError({ message: {} })).toBe(false);
    });
  });

  describe('isErrorWithMessage', () => {
    it('should return true if error message contains the substring', () => {
      const error = new Error('This is a test error message');
      expect(isErrorWithMessage(error, 'test')).toBe(true);
    });

    it('should return false if error message does not contain the substring', () => {
      const error = new Error('This is a test error message');
      expect(isErrorWithMessage(error, 'missing')).toBe(false);
    });

    it('should return false for non-error objects', () => {
      expect(isErrorWithMessage(null, 'test')).toBe(false);
      expect(isErrorWithMessage(undefined, 'test')).toBe(false);
      expect(isErrorWithMessage(123, 'test')).toBe(false);
      expect(isErrorWithMessage('string', 'test')).toBe(false);
      expect(isErrorWithMessage({}, 'test')).toBe(false);
    });
  });

  describe('isAxiosErrorWithCriteria', () => {
    it('should return true for basic axios errors', () => {
      const axiosError = createMockAxiosError();
      expect(isAxiosErrorWithCriteria(axiosError)).toBe(true);
    });

    it('should return true when status code matches', () => {
      const axiosError = createMockAxiosError(404);
      expect(isAxiosErrorWithCriteria(axiosError, 404)).toBe(true);
    });

    it('should return false when status code does not match', () => {
      const axiosError = createMockAxiosError(404);
      expect(isAxiosErrorWithCriteria(axiosError, 500)).toBe(false);
    });

    it('should return true when error code matches', () => {
      const axiosError = createMockAxiosError(undefined, undefined, 'ECONNREFUSED');
      expect(isAxiosErrorWithCriteria(axiosError, undefined, 'ECONNREFUSED')).toBe(true);
    });

    it('should return false when error code does not match', () => {
      const axiosError = createMockAxiosError(undefined, undefined, 'ECONNREFUSED');
      expect(isAxiosErrorWithCriteria(axiosError, undefined, 'ETIMEDOUT')).toBe(false);
    });

    it('should return true when both status and error code match', () => {
      const axiosError = createMockAxiosError(404, undefined, 'ENOTFOUND');
      expect(isAxiosErrorWithCriteria(axiosError, 404, 'ENOTFOUND')).toBe(true);
    });

    it('should return false when either status or error code does not match', () => {
      const axiosError = createMockAxiosError(404, undefined, 'ENOTFOUND');
      expect(isAxiosErrorWithCriteria(axiosError, 500, 'ENOTFOUND')).toBe(false);
      expect(isAxiosErrorWithCriteria(axiosError, 404, 'ECONNREFUSED')).toBe(false);
    });

    it('should return false for non-axios errors', () => {
      expect(isAxiosErrorWithCriteria(new Error('Not an axios error'))).toBe(false);
      expect(isAxiosErrorWithCriteria(null)).toBe(false);
      expect(isAxiosErrorWithCriteria(undefined)).toBe(false);
      expect(isAxiosErrorWithCriteria({})).toBe(false);
    });
  });

  describe('extractGraphQLErrorMessages', () => {
    it('should extract and join error messages from an array of errors', () => {
      const errors = [
        { message: 'First error' },
        { message: 'Second error' },
        { message: 'Third error' },
      ];

      expect(extractGraphQLErrorMessages(errors)).toBe('First error, Second error, Third error');
    });

    it('should handle a single error', () => {
      const errors = [{ message: 'Only error' }];
      expect(extractGraphQLErrorMessages(errors)).toBe('Only error');
    });

    it('should handle an empty array', () => {
      expect(extractGraphQLErrorMessages([])).toBe('');
    });
  });

  describe('handleGraphQLSpecificError', () => {
    it('should create a ClassifiedError for GraphQL errors', () => {
      const graphqlErrors = [{ message: 'Authentication failed' }, { message: 'Invalid token' }];

      const axiosError = createMockAxiosError(200, { errors: graphqlErrors });
      const result = handleGraphQLSpecificError(axiosError);

      expect(result).not.toBeNull();
      expect(result?.message).toContain('GraphQL Error');
      expect(result?.message).toContain('Authentication failed');
      expect(result?.message).toContain('Invalid token');
      expect(result?.category).toBe(ErrorCategory.AUTH);
      expect(result?.originalError).toBe(axiosError);
      expect(result?.metadata).toEqual({ graphqlErrors });
    });

    it('should classify GraphQL errors correctly based on message content', () => {
      const testCases = [
        {
          errors: [{ message: 'Authentication failed' }],
          expectedCategory: ErrorCategory.AUTH,
        },
        {
          errors: [{ message: 'Rate limit exceeded' }],
          expectedCategory: ErrorCategory.RATE_LIMIT,
        },
        {
          errors: [{ message: 'Network error' }],
          expectedCategory: ErrorCategory.NETWORK,
        },
        {
          errors: [{ message: 'Cannot query field' }],
          expectedCategory: ErrorCategory.SCHEMA,
        },
        {
          errors: [{ message: 'Resource not found' }],
          expectedCategory: ErrorCategory.NOT_FOUND,
        },
        {
          errors: [{ message: 'Server error' }],
          expectedCategory: ErrorCategory.SERVER,
        },
        {
          errors: [{ message: 'Unknown error' }],
          expectedCategory: ErrorCategory.OTHER,
        },
      ];

      for (const testCase of testCases) {
        const axiosError = createMockAxiosError(200, { errors: testCase.errors });
        const result = handleGraphQLSpecificError(axiosError);

        expect(result).not.toBeNull();
        expect(result?.category).toBe(testCase.expectedCategory);
      }
    });

    it('should return null for non-GraphQL errors', () => {
      const nonGraphqlError = createMockAxiosError(404, { message: 'Not found' });
      expect(handleGraphQLSpecificError(nonGraphqlError)).toBeNull();
    });

    it('should return null for non-axios errors', () => {
      expect(handleGraphQLSpecificError(new Error('Regular error'))).toBeNull();
      expect(handleGraphQLSpecificError(null)).toBeNull();
      expect(handleGraphQLSpecificError(undefined)).toBeNull();
    });
  });

  describe('handleNetworkError', () => {
    it('should handle ECONNREFUSED errors', () => {
      const connectionError = createMockAxiosError(undefined, undefined, 'ECONNREFUSED');
      const result = handleNetworkError(connectionError);

      expect(result).not.toBeNull();
      expect(result?.message).toContain('Connection error');
      expect(result?.category).toBe(ErrorCategory.NETWORK);
      expect(result?.originalError).toBe(connectionError);
    });

    it('should handle ETIMEDOUT errors', () => {
      const timeoutError = createMockAxiosError(undefined, undefined, 'ETIMEDOUT');
      const result = handleNetworkError(timeoutError);

      expect(result).not.toBeNull();
      expect(result?.message).toContain('Timeout error');
      expect(result?.category).toBe(ErrorCategory.TIMEOUT);
      expect(result?.originalError).toBe(timeoutError);
    });

    it('should return null for other error types', () => {
      const otherError = createMockAxiosError(404);
      expect(handleNetworkError(otherError)).toBeNull();

      const nonAxiosError = new Error('Not an axios error');
      expect(handleNetworkError(nonAxiosError)).toBeNull();
    });
  });

  describe('handleHttpStatusError', () => {
    it('should handle 401 errors', () => {
      const authError = createMockAxiosError(401);
      const result = handleHttpStatusError(authError);

      expect(result).not.toBeNull();
      expect(result?.message).toContain('Authentication error');
      expect(result?.category).toBe(ErrorCategory.AUTH);
      expect(result?.originalError).toBe(authError);
    });

    it('should handle 429 errors', () => {
      const rateLimitError = createMockAxiosError(429);
      const result = handleHttpStatusError(rateLimitError);

      expect(result).not.toBeNull();
      expect(result?.message).toContain('Rate limit exceeded');
      expect(result?.category).toBe(ErrorCategory.RATE_LIMIT);
      expect(result?.originalError).toBe(rateLimitError);
    });

    it('should handle 500+ errors', () => {
      const serverErrors = [
        { status: 500, expectedMessage: 'Server error' },
        { status: 502, expectedMessage: 'Bad Gateway' },
        { status: 503, expectedMessage: 'Service Unavailable' },
        { status: 504, expectedMessage: 'Gateway Timeout' },
        { status: 520, expectedMessage: 'Server error' },
      ];

      for (const { status, expectedMessage } of serverErrors) {
        const error = createMockAxiosError(status);
        const result = handleHttpStatusError(error);
        expect(result).not.toBeNull();
        expect(result?.message).toContain(expectedMessage);
        expect(result?.category).toBe(ErrorCategory.SERVER);
        expect(result?.originalError).toBe(error);
      }
    });

    it('should handle 404 errors', () => {
      const notFoundError = createMockAxiosError(404);
      const result = handleHttpStatusError(notFoundError);

      expect(result).not.toBeNull();
      expect(result?.message).toContain('Not found');
      expect(result?.category).toBe(ErrorCategory.NOT_FOUND);
      expect(result?.originalError).toBe(notFoundError);
    });

    it('should handle other 4xx errors', () => {
      const clientErrors = [400, 403, 405, 422].map((status) => createMockAxiosError(status));

      for (const error of clientErrors) {
        const result = handleHttpStatusError(error);
        expect(result).not.toBeNull();
        expect(result?.message).toContain('Client error');
        expect(result?.category).toBe(ErrorCategory.CLIENT);
        expect(result?.originalError).toBe(error);
      }
    });

    it('should return null for errors without status code', () => {
      const noStatusError = createMockAxiosError();
      expect(handleHttpStatusError(noStatusError)).toBeNull();
    });

    it('should return null for non-axios errors', () => {
      expect(handleHttpStatusError(new Error('Regular error'))).toBeNull();
      expect(handleHttpStatusError(null)).toBeNull();
      expect(handleHttpStatusError(undefined)).toBeNull();
    });

    it('should return null for status codes outside the handled ranges', () => {
      // Status codes like 300, 301, 302 (redirects) don't fall into the 4xx or 5xx ranges
      const redirectError = createMockAxiosError(302);
      expect(handleHttpStatusError(redirectError)).toBeNull();
    });
  });

  describe('handleApiError', () => {
    it('should return input if it is already a ClassifiedError', () => {
      const classifiedError = {
        name: 'Error',
        message: 'Already classified',
        category: ErrorCategory.CLIENT,
      };

      expect(handleApiError(classifiedError)).toBe(classifiedError);
    });

    it('should handle GraphQL errors', () => {
      const graphqlErrors = [{ message: 'Cannot query field' }];
      const graphqlError = createMockAxiosError(200, { errors: graphqlErrors });

      // Create a real GraphQL error that will be detected by handleGraphQLSpecificError
      const result = handleApiError(graphqlError);

      expect(result.category).toBe(ErrorCategory.SCHEMA);
      expect(result.message).toContain('GraphQL Error');
      expect(result.message).toContain('Cannot query field');
    });

    it('should handle network errors', () => {
      const networkError = createMockAxiosError(undefined, undefined, 'ECONNREFUSED');

      const result = handleApiError(networkError);

      expect(result.category).toBe(ErrorCategory.NETWORK);
      expect(result.message).toContain('Connection error');
    });

    it('should handle HTTP errors', () => {
      const httpError = createMockAxiosError(401);

      const result = handleApiError(httpError);

      expect(result.category).toBe(ErrorCategory.AUTH);
      expect(result.message).toContain('Authentication error');
    });

    it('should handle standard Error objects with classification', () => {
      const standardError = new Error('Authentication failed');

      // We can't mock the imported functions directly in ES modules
      // So we'll just test the result of handleApiError
      const result = handleApiError(standardError);

      expect(result.category).toBe(ErrorCategory.AUTH); // Based on message classification
      expect(result.message).toContain('DeepSource API error');
      expect(result.message).toContain('Authentication failed');
    });

    it('should handle unknown error types as a fallback', () => {
      const unknownError = { notAnError: true };

      const result = handleApiError(unknownError);

      expect(result.category).toBe(ErrorCategory.OTHER);
      expect(result.message).toContain('Unknown error occurred');
      expect(result.originalError).toBe(unknownError);
    });
  });
});