import { afterEach, describe, expect, it, vi } from "vitest";
import type { ISbFetch } from "./sbFetch";
import SbFetch from "./sbFetch";
import { headersToObject } from "../tests/utils";
import type { ISbStoriesParams } from "./interfaces";

describe("sbFetch", () => {
  let sbFetch: SbFetch;
  const mockFetch = vi.fn();

  afterEach(() => {
    vi.restoreAllMocks();
  });

  it("should initialize", () => {
    sbFetch = new SbFetch({} as ISbFetch);
    expect(sbFetch).toBeInstanceOf(SbFetch);
  });

  describe("get", () => {
    it("should correctly construct URLs for GET requests", async () => {
      sbFetch = new SbFetch({
        baseURL: "https://api.storyblok.com/v2/",
        fetch: mockFetch,
      } as ISbFetch);
      const response = new Response(JSON.stringify({ data: "test" }), {
        status: 200,
        headers: { "Content-Type": "application/json" },
      });
      mockFetch.mockResolvedValue(response);
      await sbFetch.get("test", {
        is_startpage: false,
        search_term: "test",
      });
      expect(mockFetch).toHaveBeenCalledWith(
        "https://api.storyblok.com/v2/test?is_startpage=false&search_term=test",
        expect.anything(),
      );
    });
  });

  describe("post", () => {
    it("should handle POST requests correctly", async () => {
      const testPayload = { title: "New Story" };
      const response = new Response(JSON.stringify({ data: "test" }), {
        status: 200,
        headers: { "Content-Type": "application/json" },
      });
      mockFetch.mockResolvedValue(response);
      await sbFetch.post("stories", testPayload);
      expect(mockFetch).toHaveBeenCalledWith("https://api.storyblok.com/v2/stories", {
        method: "post",
        body: JSON.stringify(testPayload),
        headers: expect.any(Headers),
        signal: expect.any(AbortSignal),
      });
    });

    it("should set specific headers for POST requests", async () => {
      sbFetch = new SbFetch({
        baseURL: "https://api.storyblok.com/v2/",
        headers: new Headers({
          "Content-Type": "application/json",
        }),
        fetch: mockFetch,
      } as ISbFetch);
      const testPayload = { title: "New Story" };
      const response = new Response(JSON.stringify({ data: "test" }), {
        status: 200,
        headers: { "Content-Type": "application/json" },
      });
      mockFetch.mockResolvedValue(response);

      await sbFetch.post("stories", testPayload);

      // Get the last call to fetch and extract the headers
      const lastCall = mockFetch.mock.calls[mockFetch.mock.calls.length - 1];
      const actualHeaders = headersToObject(lastCall[1].headers);
      expect(actualHeaders["content-type"]).toBe("application/json");
    });
  });

  describe("put", () => {
    it("should handle PUT requests correctly", async () => {
      const testPayload = { title: "Updated Story" };
      const response = new Response(JSON.stringify({ data: "test" }), {
        status: 200,
        headers: { "Content-Type": "application/json" },
      });
      mockFetch.mockResolvedValue(response);
      await sbFetch.put("stories/1", testPayload);
      expect(mockFetch).toHaveBeenCalledWith("https://api.storyblok.com/v2/stories/1", {
        method: "put",
        body: JSON.stringify(testPayload),
        headers: expect.any(Headers),
        signal: expect.any(AbortSignal),
      });
    });
  });

  describe("patch", () => {
    it("should handle PATCH requests correctly", async () => {
      const testPayload = { winner_id: 42 } as ISbStoriesParams;
      const response = new Response(JSON.stringify({ data: "test" }), {
        status: 200,
        headers: { "Content-Type": "application/json" },
      });
      mockFetch.mockResolvedValue(response);
      await sbFetch.patch("stories/1/experiments/select_winner", testPayload);
      expect(mockFetch).toHaveBeenCalledWith(
        "https://api.storyblok.com/v2/stories/1/experiments/select_winner",
        {
          method: "patch",
          body: JSON.stringify(testPayload),
          headers: expect.any(Headers),
          signal: expect.any(AbortSignal),
        },
      );
    });
  });

  describe("delete", () => {
    it("should handle DELETE requests correctly", async () => {
      const response = new Response(null, {
        status: 204, // Typically, DELETE operations might not return content
      });
      mockFetch.mockResolvedValue(response);
      await sbFetch.delete("stories/1");
      expect(mockFetch).toHaveBeenCalledWith("https://api.storyblok.com/v2/stories/1", {
        method: "delete",
        body: "{}", // Ensuring no body is sent
        headers: expect.any(Headers),
        signal: expect.any(AbortSignal),
      });
    });
  });

  it("should handle network errors gracefully", async () => {
    const mockFetch = vi.fn().mockRejectedValue(new Error("Network Failure"));
    const sbFetch = new SbFetch({
      baseURL: "https://api.example.com",
      headers: new Headers(),
      fetch: mockFetch,
    });

    // Assuming your implementation wraps the error message inside an object under `message`.
    const result = await sbFetch.get("/test", {});

    // Check if the error object format matches your implementation.
    expect(result).toEqual({
      message: expect.any(String), // Checks if `message` is a string
    });

    // If you want to be more specific and check the message of the error:
    expect(result.message).toEqual("Network Failure"); // This path needs to match the structure you actually use.
  });

  describe("timeout behavior", () => {
    // Helper to create mock fetch with configurable delay
    const createMockFetch = (delayMs: number) => {
      return vi.fn((_url: string, options?: any): Promise<Response> => {
        return new Promise((resolve, reject) => {
          const timeoutId = setTimeout(() => {
            resolve(new Response(JSON.stringify({ data: "test" }), { status: 200 }));
          }, delayMs);

          options?.signal?.addEventListener("abort", () => {
            clearTimeout(timeoutId);
            const error = new Error("The operation was aborted");
            error.name = "AbortError";
            reject(error);
          });
        });
      });
    };

    // Helper to create SbFetch instance with timeout
    const createSbFetchWithTimeout = (timeoutSeconds: number, mockFetch: any) => {
      return new SbFetch({
        baseURL: "https://api.storyblok.com/v2",
        timeout: timeoutSeconds,
        headers: new Headers(),
        fetch: mockFetch as any,
      });
    };

    it("should timeout after configured timeout period", async () => {
      const mockFetch = createMockFetch(5000);
      const sbFetch = createSbFetchWithTimeout(1, mockFetch);

      const result = await sbFetch.get("cdn/stories", {});
      expect(result).toEqual({
        message: "Request timeout: The request was aborted due to timeout",
      });
    }, 3000);

    it("should timeout after 2 seconds when configured with 2s timeout", async () => {
      vi.useFakeTimers();

      const mockFetch = createMockFetch(5000);
      const sbFetch = createSbFetchWithTimeout(2, mockFetch);

      const requestPromise = sbFetch.get("cdn/stories", {});

      // After 1.9 seconds, request should still be pending
      await vi.advanceTimersByTimeAsync(1900);
      expect(mockFetch).toHaveBeenCalledTimes(1);

      // After 2+ seconds, should timeout
      await vi.advanceTimersByTimeAsync(200);
      const result = await requestPromise;
      expect(result).toEqual({
        message: "Request timeout: The request was aborted due to timeout",
      });

      vi.useRealTimers();
    }, 3000);

    it("should timeout after 0.5 seconds when configured with 0.5s timeout", async () => {
      vi.useFakeTimers();

      const mockFetch = createMockFetch(5000);
      const sbFetch = createSbFetchWithTimeout(0.5, mockFetch);

      const requestPromise = sbFetch.get("cdn/stories", {});

      // After 0.5+ seconds, should timeout
      await vi.advanceTimersByTimeAsync(600);
      const result = await requestPromise;
      expect(result).toEqual({
        message: "Request timeout: The request was aborted due to timeout",
      });

      vi.useRealTimers();
    }, 3000);

    it("should complete successfully if response arrives before timeout", async () => {
      const mockFetch = createMockFetch(500); // 500ms delay
      const sbFetch = createSbFetchWithTimeout(2, mockFetch);

      const result = await sbFetch.get("cdn/stories", {});
      expect(result).toHaveProperty("data");
      expect(result).toHaveProperty("status", 200);
    }, 3000);

    it("should not timeout when timeout is set to 0 (disabled)", async () => {
      const mockFetch = vi
        .fn()
        .mockResolvedValue(new Response(JSON.stringify({ data: "test" }), { status: 200 }));
      const sbFetch = createSbFetchWithTimeout(0, mockFetch);

      const result = await sbFetch.get("cdn/stories", {});
      expect(result).toHaveProperty("data");
      expect(result).toHaveProperty("status", 200);
    }, 3000);

    it("should return clear error message for timeout", async () => {
      const mockFetch = vi.fn((_url: string, options?: any): Promise<Response> => {
        return new Promise((_resolve, reject) => {
          options?.signal?.addEventListener("abort", () => {
            const error = new Error("The operation was aborted");
            error.name = "AbortError";
            reject(error);
          });
          // Immediately abort to test the error message
          setTimeout(() => options?.signal?.dispatchEvent(new Event("abort")), 10);
        });
      });

      const sbFetch = createSbFetchWithTimeout(1, mockFetch);

      const result = await sbFetch.get("cdn/stories", {});
      expect((result as any).message).toBe(
        "Request timeout: The request was aborted due to timeout",
      );
    });
  });
});