import {
  getCookie,
  getParsedCookie,
  getUTMs,
  removeUTMs,
  setCookie,
  setUTMs,
} from "./cookie";
import { Base64 } from "js-base64";
import Cookies from "js-cookie";

jest.mock("js-cookie");

const mockCookiesGet = Cookies.get as jest.Mock;
const mockCookiesSet = Cookies.set as jest.Mock;
const mockCookiesRemove = Cookies.remove as jest.Mock;

describe("cookie utilities", () => {
  afterEach(() => {
    mockCookiesGet.mockReset();
    mockCookiesSet.mockReset();
    mockCookiesRemove.mockReset();
  });

  // ── getUTMs ──────────────────────────────────────────
  describe("getUTMs", () => {
    it("returns null when window is undefined", () => {
      const origWindow = globalThis.window;
      // @ts-expect-error - intentionally deleting window
      delete globalThis.window;
      expect(getUTMs()).toBeNull();
      globalThis.window = origWindow;
    });

    it("returns null when cookie does not exist", () => {
      mockCookiesGet.mockReturnValue(undefined as any);
      expect(getUTMs()).toBeNull();
      expect(mockCookiesGet).toHaveBeenCalledWith("utm_parameters");
    });

    it("decodes and parses a valid Base64 cookie", () => {
      const utms = { utm_source: "google", utm_medium: "cpc" };
      const encoded = Base64.encode(JSON.stringify(utms));
      mockCookiesGet.mockReturnValue(encoded as any);

      expect(getUTMs()).toEqual(utms);
    });

    it("returns null for an invalid Base64/JSON cookie", () => {
      mockCookiesGet.mockReturnValue("not-valid-base64!!!" as any);
      expect(getUTMs()).toBeNull();
    });
  });

  // ── setUTMs ──────────────────────────────────────────
  describe("setUTMs", () => {
    it("returns early when window is undefined", () => {
      const origWindow = globalThis.window;
      // @ts-expect-error - intentionally deleting window
      delete globalThis.window;
      setUTMs({ utm_source: "test" });
      expect(mockCookiesSet).not.toHaveBeenCalled();
      globalThis.window = origWindow;
    });

    it("encodes UTMs to Base64 and sets cookie with default domain", () => {
      const utms = { utm_source: "google" };
      setUTMs(utms);

      const expectedEncoded = Base64.encode(JSON.stringify(utms));
      expect(mockCookiesSet).toHaveBeenCalledWith(
        "utm_parameters",
        expectedEncoded,
        { domain: ".gokinetic.com", path: "/", sameSite: "Lax" }
      );
    });

    it("accepts a custom domain", () => {
      setUTMs({ utm_source: "bing" }, ".custom.com");
      expect(mockCookiesSet).toHaveBeenCalledWith(
        "utm_parameters",
        expect.any(String),
        { domain: ".custom.com", path: "/", sameSite: "Lax" }
      );
    });
  });

  // ── removeUTMs ───────────────────────────────────────
  describe("removeUTMs", () => {
    it("removes cookie with default domain", () => {
      removeUTMs();
      expect(mockCookiesRemove).toHaveBeenCalledWith("utm_parameters", {
        domain: ".gokinetic.com",
        path: "/",
      });
    });

    it("removes cookie with custom domain", () => {
      removeUTMs(".other.com");
      expect(mockCookiesRemove).toHaveBeenCalledWith("utm_parameters", {
        domain: ".other.com",
        path: "/",
      });
    });
  });

  // ── getCookie ────────────────────────────────────────
  describe("getCookie", () => {
    it("returns empty string when window is undefined", () => {
      const origWindow = globalThis.window;
      // @ts-expect-error - intentionally deleting window
      delete globalThis.window;
      expect(getCookie("key")).toBe("");
      globalThis.window = origWindow;
    });

    it("returns decoded value when cookie exists", () => {
      const value = "hello world";
      mockCookiesGet.mockReturnValue(Base64.encode(value) as any);
      expect(getCookie("my_key")).toBe(value);
    });

    it("returns null when cookie does not exist", () => {
      mockCookiesGet.mockReturnValue(undefined as any);
      expect(getCookie("missing")).toBeNull();
    });
  });

  // ── getParsedCookie ──────────────────────────────────
  describe("getParsedCookie", () => {
    it("returns parsed JSON from cookie", () => {
      const obj = { foo: "bar", num: 42 };
      mockCookiesGet.mockReturnValue(Base64.encode(JSON.stringify(obj)) as any);
      expect(getParsedCookie("key")).toEqual(obj);
    });

    it("returns null when cookie is missing", () => {
      mockCookiesGet.mockReturnValue(undefined as any);
      expect(getParsedCookie("missing")).toBeNull();
    });

    it("returns null when cookie has invalid JSON", () => {
      mockCookiesGet.mockReturnValue(Base64.encode("not json") as any);
      expect(getParsedCookie("bad")).toBeNull();
    });
  });

  // ── setCookie ────────────────────────────────────────
  describe("setCookie", () => {
    it("returns early when window is undefined", () => {
      const origWindow = globalThis.window;
      // @ts-expect-error - intentionally deleting window
      delete globalThis.window;
      setCookie("key", "value", {});
      expect(mockCookiesSet).not.toHaveBeenCalled();
      globalThis.window = origWindow;
    });

    it("encodes value to Base64 and sets cookie with options", () => {
      const value = { plan: "fiber", speed: 500 };
      const options = { domain: ".test.com", path: "/" };
      setCookie("plan_data", value, options);

      const expectedEncoded = Base64.encode(JSON.stringify(value));
      expect(mockCookiesSet).toHaveBeenCalledWith(
        "plan_data",
        expectedEncoded,
        options
      );
    });

    it("handles string values", () => {
      setCookie("simple", "hello", { path: "/" });
      const expectedEncoded = Base64.encode(JSON.stringify("hello"));
      expect(mockCookiesSet).toHaveBeenCalledWith("simple", expectedEncoded, {
        path: "/",
      });
    });
  });
});