import { get, patch, post, put } from "@toruslabs/http-helpers";
import { Hex } from "@toruslabs/metadata-helpers";
import { describe, expect, test, vi } from "vitest";

import { BaseStorageManager } from "../src/base";
import { ApiRequestParams } from "../src/interfaces";

// Concrete implementation for testing
type TestData = { testData: string };
class TestStorageManager extends BaseStorageManager<TestData> {
  setSessionId(sessionId: Hex): void {
    this._sessionId = sessionId;
  }

  async createSession(_data: TestData): Promise<string> {
    return Promise.resolve("");
  }

  async authorizeSession(): Promise<TestData> {
    return Promise.resolve({ testData: "" });
  }

  async updateSession(): Promise<void> {
    return Promise.resolve();
  }

  async invalidateSession(): Promise<boolean> {
    return Promise.resolve(true);
  }

  request<T>({ url, method, data, headers }: ApiRequestParams): Promise<T> {
    return super.request({ url, method, data, headers });
  }
}

vi.mock("@toruslabs/http-helpers");

describe("BaseStorageManager", () => {
  test("should throw error if sessionId is not set", () => {
    const storageManager = new TestStorageManager();
    expect(() => storageManager.checkSessionParams()).toThrow("Session id is required");
  });
  test("should pad sessionId with 0s if it is less than 64 characters", () => {
    const storageManager = new TestStorageManager();
    storageManager.setSessionId("0x1234567890");
    storageManager.checkSessionParams();
    expect(storageManager.sessionId).toBe("0x0000000000000000000000000000000000000000000000000000001234567890");
  });
  test("should keep sessionId as is if it is 64 characters", () => {
    const storageManager = new TestStorageManager();
    storageManager.setSessionId("0x0000000000123456789012345678901234567890123456789012345678901234");
    storageManager.checkSessionParams();
    expect(storageManager.sessionId).toBe("0x0000000000123456789012345678901234567890123456789012345678901234");
  });
  test("should pad sessionId to 64 characters if it is greater than 64 characters", () => {
    const storageManager = new TestStorageManager();
    storageManager.setSessionId("0x0000000000123456789012345678901234567890123456789012345678901234567");
    storageManager.checkSessionParams();
    expect(storageManager.sessionId).toBe("0x0000000000123456789012345678901234567890123456789012345678901234");
  });
  test("request method calls GET, POST, PUT, PATCH correctly", () => {
    const storageManager = new TestStorageManager();

    storageManager.request({ url: "https://example.com", method: "GET" });
    expect(get).toHaveBeenCalledWith("https://example.com", { headers: {} });

    storageManager.request({ url: "https://example.com", method: "POST", data: { test: "test" } });
    expect(post).toHaveBeenCalledWith("https://example.com", { test: "test" }, { headers: {} });

    storageManager.request({ url: "https://example.com", method: "PUT", data: { test: "test" } });
    expect(put).toHaveBeenCalledWith("https://example.com", { test: "test" }, { headers: {} });

    storageManager.request({ url: "https://example.com", method: "PATCH", data: { test: "test" } });
    expect(patch).toHaveBeenCalledWith("https://example.com", { test: "test" }, { headers: {} });
  });
  test("request method throws error if method is invalid", () => {
    const storageManager = new TestStorageManager();
    expect(() => storageManager.request({ url: "https://example.com", method: "INVALID" })).toThrow("Invalid method type");
  });
});