// __tests__/auth.test.ts
import {
  Auth,
  Callback,
  clientConfig,
  getClientConfig,
  Logout,
} from "@/features/User/oidcAuth";
import * as apiUtils from "@/utils/apiUtils";
import * as client from "openid-client";

clientConfig.url = "https://example.com";
const localAdress = "https://local.exemple.com";

describe("OpenID Client Auth Module", () => {
  beforeEach(() => {
    jest.clearAllMocks();
    jest.spyOn(apiUtils, "getLocation").mockImplementation(() => localAdress);
  });

  describe("getClientConfig", () => {
    it("should call discovery with clientConfig.url", async () => {
      const discoveryMock = client.discovery as jest.Mock;
      discoveryMock.mockResolvedValue("discoveredClient");

      const result = await getClientConfig();

      expect(discoveryMock).toHaveBeenCalledWith(
        new URL(clientConfig.url),
        clientConfig.client_id
      );
      expect(result).toBe("discoveredClient");
    });
  });

  describe("Auth", () => {
    it("should generate PKCE and build authorization URL with PKCE", async () => {
      (client.randomPKCECodeVerifier as jest.Mock).mockReturnValue(
        "verifier123"
      );
      (client.calculatePKCECodeChallenge as jest.Mock).mockResolvedValue(
        "challenge123"
      );

      // Mock discovery returning an object with serverMetadata()
      const discoveredClient = {
        serverMetadata: jest.fn(() => ({
          supportsPKCE: () => true,
        })),
      };
      (client.discovery as jest.Mock).mockResolvedValue(discoveredClient);

      (client.buildAuthorizationUrl as jest.Mock).mockReturnValue(
        "https://auth.url"
      );

      const result = await Auth();

      expect(client.randomPKCECodeVerifier).toHaveBeenCalled();
      expect(client.calculatePKCECodeChallenge).toHaveBeenCalledWith(
        "verifier123"
      );
      expect(client.buildAuthorizationUrl).toHaveBeenCalledWith(
        discoveredClient,
        expect.objectContaining({
          code_challenge: "challenge123",
          code_challenge_method: clientConfig.code_challenge_method,
          redirect_uri: clientConfig.redirect_uri,
          scope: clientConfig.scope,
        })
      );
      expect(result).toEqual({
        redirectTo: "https://auth.url",
        code_verifier: "verifier123",
        state: undefined,
      });
    });

    it("should generate state when PKCE not supported", async () => {
      (client.randomPKCECodeVerifier as jest.Mock).mockReturnValue(
        "verifier123"
      );
      (client.calculatePKCECodeChallenge as jest.Mock).mockResolvedValue(
        "challenge123"
      );

      const discoveredClient = {
        serverMetadata: jest.fn(() => ({
          supportsPKCE: () => false,
        })),
      };
      (client.discovery as jest.Mock).mockResolvedValue(discoveredClient);
      (client.randomState as jest.Mock).mockReturnValue("state123");
      (client.buildAuthorizationUrl as jest.Mock).mockReturnValue(
        "https://auth.url"
      );

      const result = await Auth();

      expect(client.randomState).toHaveBeenCalled();
      expect(result.state).toBe("state123");
      expect(result.redirectTo).toBe("https://auth.url");
    });
  });

  describe("Logout", () => {
    it("should build end session URL", async () => {
      const discoveredClient = {};
      (client.discovery as jest.Mock).mockResolvedValue(discoveredClient);
      (client.buildEndSessionUrl as jest.Mock).mockReturnValue(
        "https://logout.url"
      );

      const result = await Logout();

      expect(client.buildEndSessionUrl).toHaveBeenCalledWith(discoveredClient, {
        post_logout_redirect_uri: clientConfig.post_logout_redirect_uri,
      });
      expect(result).toBe("https://logout.url");
    });
  });

  describe("Callback", () => {
    it("should perform authorization code grant and fetch user info", async () => {
      const discoveredClient = {};
      (client.discovery as jest.Mock).mockResolvedValue(discoveredClient);

      const mockTokenSet = {
        access_token: "access123",
        claims: jest.fn(() => ({ sub: "user123" })),
      };
      (client.authorizationCodeGrant as jest.Mock).mockResolvedValue(
        mockTokenSet
      );
      (client.fetchUserInfo as jest.Mock).mockResolvedValue({ name: "User" });
      const result = await Callback("verifier123", "state123");

      expect(client.authorizationCodeGrant).toHaveBeenCalledWith(
        discoveredClient,
        new URL(localAdress),
        { pkceCodeVerifier: "verifier123", expectedState: "state123" }
      );

      expect(client.fetchUserInfo).toHaveBeenCalledWith(
        discoveredClient,
        "access123",
        "user123"
      );

      expect(result).toEqual({
        tokenSet: mockTokenSet,
        userinfo: { name: "User" },
      });
    });

    it("should catch and log errors", async () => {
      const error = new Error("fail");
      (client.discovery as jest.Mock).mockResolvedValue({});
      (client.authorizationCodeGrant as jest.Mock).mockRejectedValue(error);
      const consoleErrorSpy = jest
        .spyOn(console, "error")
        .mockImplementation(() => {});

      const result = await Callback("verifier", "state");

      expect(consoleErrorSpy).toHaveBeenCalledWith("Token grant error:", error);
      expect(result).toBeUndefined();

      consoleErrorSpy.mockRestore();
    });
  });
});