import { describe, expect, it } from "vitest";

import {
  shouldRedirectSignedInFromSignIn,
  signedOAuthQueryFromParams,
  socialErrorCallbackURL,
} from "@/client/lib/sign-in-oauth";

describe("signedOAuthQueryFromParams", () => {
  it("returns null when no signed query is present", () => {
    expect(signedOAuthQueryFromParams(new URLSearchParams(""))).toBe(null);
    expect(signedOAuthQueryFromParams(new URLSearchParams("foo=bar"))).toBe(null);
  });

  it("returns null when only client_id is present (no sig)", () => {
    expect(signedOAuthQueryFromParams(new URLSearchParams("client_id=A"))).toBe(null);
  });

  it("returns null when only sig is present (no client_id)", () => {
    expect(signedOAuthQueryFromParams(new URLSearchParams("sig=Z"))).toBe(null);
  });

  it("preserves the signed sequence through sig", () => {
    const params = new URLSearchParams("client_id=A&response_type=code&state=S&sig=Z");
    expect(signedOAuthQueryFromParams(params)).toBe("client_id=A&response_type=code&state=S&sig=Z");
  });

  it("skips a leading local error param while preserving signed order", () => {
    const params = new URLSearchParams("error=social_unavailable&client_id=A&state=S&sig=Z");
    expect(signedOAuthQueryFromParams(params)).toBe("client_id=A&state=S&sig=Z");
  });

  it("skips a leading local redirect param while preserving signed order", () => {
    const params = new URLSearchParams("redirect=%2Faccount&client_id=A&sig=Z");
    expect(signedOAuthQueryFromParams(params)).toBe("client_id=A&sig=Z");
  });

  it("ignores params after sig (stops at the first sig)", () => {
    const params = new URLSearchParams("client_id=A&sig=Z&error=social_unavailable");
    expect(signedOAuthQueryFromParams(params)).toBe("client_id=A&sig=Z");
  });

  it("preserves repeated keys in their original order", () => {
    const params = new URLSearchParams("scope=openid&scope=email&client_id=A&sig=Z");
    expect(signedOAuthQueryFromParams(params)).toBe("scope=openid&scope=email&client_id=A&sig=Z");
  });
});

describe("socialErrorCallbackURL", () => {
  it("returns the bare error URL when no signed query is present", () => {
    expect(socialErrorCallbackURL(null)).toBe("/sign-in?error=social_unavailable");
  });

  it("places signed params first and the local error after sig", () => {
    expect(socialErrorCallbackURL("client_id=A&sig=Z")).toBe("/sign-in?client_id=A&sig=Z&error=social_unavailable");
  });

  it("survives a round trip through signedOAuthQueryFromParams", () => {
    const signed = "client_id=A&response_type=code&state=S&sig=Z";
    const url = new URL(socialErrorCallbackURL(signed), "https://placeholder.invalid");
    expect(signedOAuthQueryFromParams(url.searchParams)).toBe(signed);
  });
});

describe("shouldRedirectSignedInFromSignIn", () => {
  it("returns false while the session is pending", () => {
    expect(
      shouldRedirectSignedInFromSignIn({ sessionPending: true, signedInUserId: "u1", signedOAuthQuery: null }),
    ).toBe(false);
    expect(
      shouldRedirectSignedInFromSignIn({ sessionPending: true, signedInUserId: null, signedOAuthQuery: null }),
    ).toBe(false);
    expect(
      shouldRedirectSignedInFromSignIn({
        sessionPending: true,
        signedInUserId: "u1",
        signedOAuthQuery: "client_id=A&sig=Z",
      }),
    ).toBe(false);
  });

  it("returns false when the user is signed out", () => {
    expect(
      shouldRedirectSignedInFromSignIn({ sessionPending: false, signedInUserId: null, signedOAuthQuery: null }),
    ).toBe(false);
  });

  it("returns true when a signed-in user has no signed query", () => {
    expect(
      shouldRedirectSignedInFromSignIn({ sessionPending: false, signedInUserId: "u1", signedOAuthQuery: null }),
    ).toBe(true);
  });

  it("returns false when a signed-in user has a signed query (prompt=login path)", () => {
    expect(
      shouldRedirectSignedInFromSignIn({
        sessionPending: false,
        signedInUserId: "u1",
        signedOAuthQuery: "client_id=A&sig=Z",
      }),
    ).toBe(false);
  });
});