/* eslint-disable @typescript-eslint/no-explicit-any */

import { describe, expect, it, beforeEach } from 'vitest';

import { Base, ApiError, ApiTimeoutError, AxiosError } from '../../';
import { BaseConfig, CalApiParams } from '../../types';

class Client extends Base {
  constructor(params: BaseConfig) {
    super(params);
  }

  async makeApiCall(params: CalApiParams) {
    return this.callApi(params);
  }

  async makeApiCallV2(params: CalApiParams) {
    return this.callApiV2(params);
  }
}

describe('Base', () => {
  let client: Client;
  let controller: AbortController;
  let signal: AbortSignal;

  beforeEach(() => {
    client = new Client({
      serviceUrl: 'https://example2.com',
      token: 'token',
      serviceKey: 'service',
    });
    controller = new AbortController();
    signal = controller.signal;
  });

  describe('timeout handling', () => {
    it('timeout of request will throw ApiTimeoutError', async () => {
      await expect(() => client.makeApiCall({
        route: '/',
        timeout: 1,
      })).rejects.toThrowError(ApiTimeoutError);
      await expect(() => client.makeApiCallV2({
        route: '/',
        timeout: 1,
      })).rejects.toThrowError(ApiTimeoutError);
    });

    it('timeout with custom AbortController signal will throw ApiTimeoutError', async () => {
      await expect(() => client.makeApiCall({
        route: '/',
        timeout: 1,
        signal,
      })).rejects.toThrowError(ApiTimeoutError);
      await expect(() => client.makeApiCallV2({
        route: '/',
        timeout: 1,
        signal,
      })).rejects.toThrowError(ApiTimeoutError);
    });


    it('ApiTimeoutError should have cause field with AxiosError', async () => {
      try {
        await client.makeApiCall({
          route: '/',
          timeout: 1,
        });

        throw new Error('This should never happen');
      } catch (error: any) {
        expect(error).toBeInstanceOf(ApiTimeoutError);
        expect(error).toBeInstanceOf(ApiError);
        expect(error).toHaveProperty('cause');
        expect(error.cause).toBeInstanceOf(AxiosError);
        expect(error.message.startsWith('[Client]')).toBe(true);
      }

      try {
        await client.makeApiCallV2({
          route: '/',
          timeout: 1,
        });

        throw new Error('This should never happen');
      } catch (error: any) {
        expect(error).toBeInstanceOf(ApiTimeoutError);
        expect(error).toBeInstanceOf(ApiError);
        expect(error).toHaveProperty('cause');
        expect(error.cause).toBeInstanceOf(AxiosError);
      }
    });

    it('ApiTimeoutError with custom signal should have cause field with AxiosError', async () => {
      const controller = new AbortController();
      const signal = controller.signal;

      try {
        await client.makeApiCall({
          route: '/',
          timeout: 1,
          signal,
        });

        throw new Error('This should never happen');
      } catch (error: any) {
        expect(error).toBeInstanceOf(ApiTimeoutError);
        expect(error).toHaveProperty('cause');
        expect(error.cause).toBeInstanceOf(AxiosError);
      }

      try {
        await client.makeApiCallV2({
          route: '/',
          timeout: 1,
          signal,
        });

        throw new Error('This should never happen');
      } catch (error: any) {
        expect(error).toBeInstanceOf(ApiTimeoutError);
        expect(error).toHaveProperty('cause');
        expect(error.cause).toBeInstanceOf(AxiosError);
        expect(error.message.startsWith('[Client]')).toBe(true);
      }
    });
  });

  describe('statusCode in ApiError', () => {
    it('ApiError should have statusCode field with AxiosError status code', async () => {
      try {
        await client.makeApiCall({
          route: '/',
        });

        throw new Error('This should never happen');
      } catch (error: any) {
        expect(error).toBeInstanceOf(ApiError);
        expect(error).toHaveProperty('statusCode');
        expect(error.statusCode).toEqual(error.cause.status);
        expect(error.message.startsWith('[Client]')).toBe(true);
      }

      try {
        await client.makeApiCallV2({
          route: '/',
        });

        throw new Error('This should never happen');
      } catch (error: any) {
        expect(error).toBeInstanceOf(ApiError);
        expect(error).toHaveProperty('statusCode');
        expect(error.statusCode).toEqual(error.cause.status);
        expect(error.message.startsWith('[Client]')).toBe(true);
      }
    });

    it('ApiTimeoutError should have `statusCode` field with AxiosError status code', async () => {
      try {
        await client.makeApiCall({
          route: '/',
          timeout: 1,
        });

        throw new Error('This should never happen');
      } catch (error: any) {
        expect(error).toBeInstanceOf(ApiTimeoutError);
        expect(error).toHaveProperty('statusCode');
        expect(error.statusCode).toEqual(error.cause.status);
        expect(error.message.startsWith('[Client]')).toBe(true);
      }

      try {
        await client.makeApiCallV2({
          route: '/',
          timeout: 1,
        });

        throw new Error('This should never happen');
      } catch (error: any) {
        expect(error).toBeInstanceOf(ApiTimeoutError);
        expect(error).toHaveProperty('statusCode');
        expect(error.statusCode).toEqual(error.cause.status);
        expect(error.message.startsWith('[Client]')).toBe(true);
      }
    });
  });
});