/**
 * @jest-environment jsdom
 */
import { renderMenuOverlay } from "../../../src/reader-view/renderers/menu-overlay";
import { ReaderObject } from "../../../src/adapters/reader/lisio-reader-adapter";
import { LisioBroadcastChannelController } from "../../../src/controllers/broadcastChannel/lisio-broadcast-channel-controller";

function tier1(position: number, href: string, content: string): ReaderObject {
  return { position, href, content, name: "a", isHidden: true, tier: 1 };
}

function tier2(position: number, parent: number, href: string, content: string): ReaderObject {
  return { position, parent, href, content, name: "a", isHidden: true, tier: 2 };
}

function buildFixture(): ReaderObject[] {
  return [
    tier1(0, "https://example.com/decouvrir-albi/", "Visiter Albi"),
    tier2(1, 0, "https://example.com/decouvrir-albi/les-incontournables/", "Les incontournables"),
    tier2(2, 0, "https://example.com/decouvrir-albi/musees/", "Musées et expositions"),
    tier1(3, "https://example.com/sejourner/", "Organiser mon séjour"),
    // untiered promo card — must never appear in the menu.
    { position: 4, href: "https://example.com/le-blog/", content: "Le blog", name: "a", isHidden: true },
  ];
}

function fakeBroadcastChannel(): { sendNavigateMessage: jest.Mock } & LisioBroadcastChannelController {
  return {
    sendNavigateMessage: jest.fn(),
  } as unknown as { sendNavigateMessage: jest.Mock } & LisioBroadcastChannelController;
}

// Plain light-DOM content (no shadow root) — see renderMenuOverlay()'s
// docstring for why: the menu's text needs to stay reachable by Lisio's own
// accessibility scaling, which only ever walks document.body's light DOM.
//
// Every tier's <ul> is built up front and stays in the DOM even when not
// the current one (only its `hidden` attribute changes — see
// buildLevel()/showLevel()), so this deliberately scopes to the CURRENTLY
// VISIBLE tier only, matching what a sighted user actually sees at any
// given moment.
function items(parent: HTMLElement): HTMLLIElement[] {
  return Array.from(
    parent.querySelectorAll<HTMLLIElement>(".lisio-menu-list:not([hidden]) > .lisio-menu-item"),
  );
}

function findItem(parent: HTMLElement, linkText: string): HTMLLIElement {
  return items(parent).find((li) => li.querySelector("a")?.textContent === linkText)!;
}

describe("renderMenuOverlay", () => {
  it("renders a closed overlay by default, with only the fixed Menu button visible", () => {
    const parent = document.createElement("div");
    renderMenuOverlay(buildFixture(), fakeBroadcastChannel(), parent);

    const toggle = parent.querySelector<HTMLButtonElement>(".lisio-menu-toggle");
    expect(toggle).not.toBeNull();
    expect(toggle?.textContent).toBe("Menu");

    const overlay = parent.querySelector<HTMLElement>(".lisio-menu-overlay");
    expect(overlay?.hidden).toBe(true);
  });

  it("builds every tier's <li> elements up front, at construction time — before the overlay is ever opened, and before drilling into any submenu", () => {
    const parent = document.createElement("div");
    renderMenuOverlay(buildFixture(), fakeBroadcastChannel(), parent);

    // The whole tree already exists as real HTML: 2 Tier 1 items + the 2
    // Tier 2 children of "Visiter Albi" — none of this required opening the
    // overlay or clicking "Voir les sous-menus" first.
    expect(parent.querySelectorAll(".lisio-menu-item")).toHaveLength(4);

    // One <ul> for the root tier, one for "Visiter Albi"'s submenu — both
    // already built, both starting hidden.
    const lists = Array.from(parent.querySelectorAll<HTMLUListElement>(".lisio-menu-list"));
    expect(lists).toHaveLength(2);
    expect(lists.every((ul) => ul.hidden)).toBe(true);
  });

  it("opens on click, showing Tier 1 items with the root breadcrumb and no back button", () => {
    const parent = document.createElement("div");
    renderMenuOverlay(buildFixture(), fakeBroadcastChannel(), parent);

    parent.querySelector<HTMLButtonElement>(".lisio-menu-toggle")!.click();

    const overlay = parent.querySelector<HTMLElement>(".lisio-menu-overlay")!;
    expect(overlay.hidden).toBe(false);

    expect(items(parent).map((li) => li.querySelector("a")?.textContent)).toEqual([
      "Visiter Albi",
      "Organiser mon séjour",
    ]);
    // The untiered promo card never appears.
    expect(parent.querySelector(".lisio-menu-list")?.textContent).not.toContain("Le blog");

    expect(overlay.querySelector(".lisio-menu-breadcrumb-current")?.textContent).toBe("Menu");
    // At the root there's nowhere to go "back" to — "Fermer" (top
    // right) is the only closing action.
    expect(overlay.querySelector<HTMLButtonElement>(".lisio-menu-back")?.hidden).toBe(true);
  });

  it("only shows \"Voir les sous-menus\" on items that actually have children", () => {
    const parent = document.createElement("div");
    renderMenuOverlay(buildFixture(), fakeBroadcastChannel(), parent);
    parent.querySelector<HTMLButtonElement>(".lisio-menu-toggle")!.click();

    const visiterAlbi = findItem(parent, "Visiter Albi");
    const sejour = findItem(parent, "Organiser mon séjour");

    expect(visiterAlbi.querySelector(".lisio-menu-item-toggle")?.textContent).toBe("Voir les sous-menus");
    expect(sejour.querySelector(".lisio-menu-item-toggle")).toBeNull();
  });

  it("drills into a submenu, updating the breadcrumb and switching the back label to \"Menu précédent\"", () => {
    const parent = document.createElement("div");
    renderMenuOverlay(buildFixture(), fakeBroadcastChannel(), parent);
    parent.querySelector<HTMLButtonElement>(".lisio-menu-toggle")!.click();

    findItem(parent, "Visiter Albi").querySelector<HTMLButtonElement>(".lisio-menu-item-toggle")!.click();

    expect(items(parent).map((li) => li.querySelector("a")?.textContent)).toEqual([
      "Les incontournables",
      "Musées et expositions",
    ]);

    const overlay = parent.querySelector<HTMLElement>(".lisio-menu-overlay")!;
    expect(overlay.querySelector(".lisio-menu-breadcrumb-current")?.textContent).toBe("Visiter Albi");
    expect(overlay.querySelector(".lisio-menu-breadcrumb-link")?.textContent).toBe("Menu");
    const back = overlay.querySelector<HTMLButtonElement>(".lisio-menu-back")!;
    expect(back.hidden).toBe(false);
    expect(back.textContent).toBe("Menu précédent");
  });

  it("the back button steps back one tier when drilled in, then hides again at the root", () => {
    const parent = document.createElement("div");
    renderMenuOverlay(buildFixture(), fakeBroadcastChannel(), parent);
    const overlay = parent.querySelector<HTMLElement>(".lisio-menu-overlay")!;

    parent.querySelector<HTMLButtonElement>(".lisio-menu-toggle")!.click();
    findItem(parent, "Visiter Albi").querySelector<HTMLButtonElement>(".lisio-menu-item-toggle")!.click();

    overlay.querySelector<HTMLButtonElement>(".lisio-menu-back")!.click();

    expect(overlay.hidden).toBe(false); // still open, just back at the root
    expect(overlay.querySelector(".lisio-menu-breadcrumb-current")?.textContent).toBe("Menu");
    expect(overlay.querySelector<HTMLButtonElement>(".lisio-menu-back")?.hidden).toBe(true);
  });

  it("going back and forth repeatedly never touches the back button's own text (only .hidden toggles)", () => {
    // Regression for the reported bug: clicking back in a submenu made the
    // back button visibly balloon in size — caused by Reading Mode's own
    // Lisio widget instance reapplying accessibility scaling every time a
    // PERSISTENT element's own text was mutated in place. The label is now
    // set once at creation and never touched again; only `.hidden` changes.
    const parent = document.createElement("div");
    renderMenuOverlay(buildFixture(), fakeBroadcastChannel(), parent);
    const overlay = parent.querySelector<HTMLElement>(".lisio-menu-overlay")!;

    parent.querySelector<HTMLButtonElement>(".lisio-menu-toggle")!.click();
    const back = overlay.querySelector<HTMLButtonElement>(".lisio-menu-back")!;
    for (let i = 0; i < 5; i++) {
      findItem(parent, "Visiter Albi").querySelector<HTMLButtonElement>(".lisio-menu-item-toggle")!.click();
      expect(back.textContent).toBe("Menu précédent");
      expect(back.getAttribute("style")).toBeNull();
      expect(back.className).toBe("lisio-menu-back");
      back.click();
    }
  });

  it("drilling in and back out never creates or destroys a submenu's <li> elements — only .hidden toggles on the <ul>", () => {
    const parent = document.createElement("div");
    renderMenuOverlay(buildFixture(), fakeBroadcastChannel(), parent);
    parent.querySelector<HTMLButtonElement>(".lisio-menu-toggle")!.click();

    // Found by content, not DOM order: buildLevel() appends a tier's own
    // <ul> only after recursing into its children's tiers first, so the
    // submenu's <ul> actually lands BEFORE its parent's in document order.
    const subMenuList = Array.from(
      parent.querySelectorAll<HTMLUListElement>(".lisio-menu-list"),
    ).find((ul) => ul.textContent?.includes("Les incontournables"))!;
    const originalItems = Array.from(subMenuList.querySelectorAll("li"));

    for (let i = 0; i < 3; i++) {
      findItem(parent, "Visiter Albi").querySelector<HTMLButtonElement>(".lisio-menu-item-toggle")!.click();
      expect(subMenuList.hidden).toBe(false);
      expect(Array.from(subMenuList.querySelectorAll("li"))).toEqual(originalItems);
      parent.querySelector<HTMLElement>(".lisio-menu-overlay")!
        .querySelector<HTMLButtonElement>(".lisio-menu-back")!
        .click();
      expect(subMenuList.hidden).toBe(true);
    }
  });

  it("the breadcrumb's ancestor links jump straight back to that level", () => {
    const parent = document.createElement("div");
    renderMenuOverlay(buildFixture(), fakeBroadcastChannel(), parent);
    const overlay = parent.querySelector<HTMLElement>(".lisio-menu-overlay")!;

    parent.querySelector<HTMLButtonElement>(".lisio-menu-toggle")!.click();
    findItem(parent, "Visiter Albi").querySelector<HTMLButtonElement>(".lisio-menu-item-toggle")!.click();

    overlay.querySelector<HTMLButtonElement>(".lisio-menu-breadcrumb-link")!.click();

    expect(overlay.querySelector(".lisio-menu-breadcrumb-current")?.textContent).toBe("Menu");
    expect(items(parent).map((li) => li.querySelector("a")?.textContent)).toEqual([
      "Visiter Albi",
      "Organiser mon séjour",
    ]);
  });

  it("\"Fermer\" always closes the overlay outright, regardless of drill depth", () => {
    const parent = document.createElement("div");
    renderMenuOverlay(buildFixture(), fakeBroadcastChannel(), parent);
    const overlay = parent.querySelector<HTMLElement>(".lisio-menu-overlay")!;

    parent.querySelector<HTMLButtonElement>(".lisio-menu-toggle")!.click();
    findItem(parent, "Visiter Albi").querySelector<HTMLButtonElement>(".lisio-menu-item-toggle")!.click();

    overlay.querySelector<HTMLButtonElement>(".lisio-menu-close")!.click();

    expect(overlay.hidden).toBe(true);
  });

  it("sends a navigate event over the broadcast channel on link click, rather than touching window.opener", () => {
    const broadcastChannel = fakeBroadcastChannel();
    const parent = document.createElement("div");
    renderMenuOverlay(buildFixture(), broadcastChannel, parent);
    parent.querySelector<HTMLButtonElement>(".lisio-menu-toggle")!.click();

    const link = Array.from(parent.querySelectorAll("a")).find(
      (a) => a.textContent === "Visiter Albi",
    ) as HTMLAnchorElement;
    link.dispatchEvent(new MouseEvent("click", { bubbles: true, cancelable: true }));

    expect(broadcastChannel.sendNavigateMessage).toHaveBeenCalledWith({
      href: "https://example.com/decouvrir-albi/",
      blank: false,
    });
  });

  it("every menu link is clickable and triggers a navigate event, not just leaves", () => {
    const broadcastChannel = fakeBroadcastChannel();
    const parent = document.createElement("div");
    renderMenuOverlay(buildFixture(), broadcastChannel, parent);
    parent.querySelector<HTMLButtonElement>(".lisio-menu-toggle")!.click();

    // "Organiser mon séjour" has no children (no "Voir les sous-menus"
    // button) but is still, itself, a real link to its own page.
    const sejour = Array.from(parent.querySelectorAll("a")).find(
      (a) => a.textContent === "Organiser mon séjour",
    ) as HTMLAnchorElement;
    sejour.dispatchEvent(new MouseEvent("click", { bubbles: true, cancelable: true }));

    expect(broadcastChannel.sendNavigateMessage).toHaveBeenCalledWith({
      href: "https://example.com/sejourner/",
      blank: false,
    });
  });

  it("renders nothing when there are no tiered items", () => {
    const parent = document.createElement("div");
    renderMenuOverlay(
      [{ position: 0, href: "https://example.com/le-blog/", content: "Le blog", name: "a", isHidden: true }],
      fakeBroadcastChannel(),
      parent,
    );
    expect(parent.children).toHaveLength(0);
  });

  it("renders nothing when hiddenTexts is undefined", () => {
    const parent = document.createElement("div");
    renderMenuOverlay(undefined, fakeBroadcastChannel(), parent);
    expect(parent.children).toHaveLength(0);
  });

  it("replaces a previous render instead of stacking duplicate buttons/overlays on re-render (in-reader navigation)", () => {
    const parent = document.createElement("div");
    renderMenuOverlay(buildFixture(), fakeBroadcastChannel(), parent);
    renderMenuOverlay(buildFixture(), fakeBroadcastChannel(), parent);

    expect(parent.querySelectorAll(".lisio-menu-toggle")).toHaveLength(1);
    expect(parent.querySelectorAll(".lisio-menu-overlay")).toHaveLength(1);
  });

  it("removes a stale menu when the new page has no hidden menu at all", () => {
    const parent = document.createElement("div");
    renderMenuOverlay(buildFixture(), fakeBroadcastChannel(), parent);
    renderMenuOverlay(undefined, fakeBroadcastChannel(), parent);

    expect(parent.children).toHaveLength(0);
  });
});
