import { afterEach, describe, expect, it, vi } from "vitest";
import {
  buildRovingOrder,
  deriveAttributeLabel,
  getAttributeAccessibleName,
  getRovingTarget,
  isRtlContext,
  resolveRadioKey,
} from "./radiogroup";

afterEach(() => {
  document.body.innerHTML = "";
  document.documentElement.removeAttribute("dir");
  vi.restoreAllMocks();
});

describe("deriveAttributeLabel", () => {
  it("strips attribute_/pa_ prefixes and title-cases", () => {
    expect(deriveAttributeLabel("attribute_pa_color")).toBe("Color");
    expect(deriveAttributeLabel("attribute_size")).toBe("Size");
    expect(deriveAttributeLabel("pa_shoe_size")).toBe("Shoe Size");
    expect(deriveAttributeLabel("")).toBe("");
  });
});

describe("getAttributeAccessibleName", () => {
  it("prefers the associated <label>", () => {
    const select = document.createElement("select");
    select.id = "pa_color";
    const label = document.createElement("label");
    label.setAttribute("for", "pa_color");
    label.textContent = "Colour";
    document.body.append(label, select);
    expect(getAttributeAccessibleName(select)).toBe("Colour");
  });

  it("falls back to aria-label, then slug, then a generic name", () => {
    const aria = document.createElement("select");
    aria.setAttribute("aria-label", "Pick a size");
    expect(getAttributeAccessibleName(aria)).toBe("Pick a size");

    const slug = document.createElement("select");
    slug.setAttribute("name", "attribute_pa_color");
    expect(getAttributeAccessibleName(slug)).toBe("Color");

    const bare = document.createElement("select");
    expect(getAttributeAccessibleName(bare)).toBe("Choose an option");
    expect(getAttributeAccessibleName(null)).toBe("Choose an option");
  });
});

describe("buildRovingOrder", () => {
  it("drops empty placeholders but keeps blur/cross OOS values", () => {
    expect(buildRovingOrder(["", "a", "b", "c"])).toEqual(["a", "b", "c"]);
    expect(
      buildRovingOrder(["a", "b", "c"], {
        outOfStockValues: ["b"],
        outOfStockBehavior: "cross",
      }),
    ).toEqual(["a", "b", "c"]);
  });

  it("removes hidden OOS values from the order", () => {
    expect(
      buildRovingOrder(["a", "b", "c"], {
        outOfStockValues: new Set(["b"]),
        outOfStockBehavior: "hide",
      }),
    ).toEqual(["a", "c"]);
  });

  it("removes native-disabled and explicitly disabled OOS values", () => {
    expect(
      buildRovingOrder(["a", "b", "c", "d"], {
        disabledValues: ["b"],
        outOfStockValues: ["c"],
        outOfStockBehavior: "cross",
        outOfStockDisable: true,
      }),
    ).toEqual(["a", "d"]);
  });

  it("returns an empty order when every rendered option is disabled", () => {
    expect(
      buildRovingOrder(["a", "b"], {
        disabledValues: ["a", "b"],
      }),
    ).toEqual([]);
  });
});

describe("getRovingTarget", () => {
  it("tabs to the selected value when focusable, else the first", () => {
    expect(getRovingTarget(["a", "b", "c"], "b")).toBe("b");
    expect(getRovingTarget(["a", "b", "c"], "gone")).toBe("a");
    expect(getRovingTarget(["a", "b", "c"], "")).toBe("a");
    expect(getRovingTarget([], "a")).toBe("");
  });
});

describe("resolveRadioKey", () => {
  const order = ["a", "b", "c"];

  it("moves with vertical arrows and wraps", () => {
    expect(resolveRadioKey("ArrowDown", "a", order)?.targetValue).toBe("b");
    expect(resolveRadioKey("ArrowUp", "a", order)?.targetValue).toBe("c");
    expect(resolveRadioKey("ArrowDown", "c", order)?.targetValue).toBe("a");
  });

  it("reverses horizontal arrows in RTL", () => {
    expect(resolveRadioKey("ArrowRight", "a", order, false)?.targetValue).toBe(
      "b",
    );
    expect(resolveRadioKey("ArrowLeft", "a", order, false)?.targetValue).toBe(
      "c",
    );
    expect(resolveRadioKey("ArrowRight", "a", order, true)?.targetValue).toBe(
      "c",
    );
    expect(resolveRadioKey("ArrowLeft", "a", order, true)?.targetValue).toBe(
      "b",
    );
  });

  it("handles Home/End and Space/Enter selection intent", () => {
    expect(resolveRadioKey("Home", "c", order)?.targetValue).toBe("a");
    expect(resolveRadioKey("End", "a", order)?.targetValue).toBe("c");
    const space = resolveRadioKey(" ", "b", order);
    expect(space).toEqual({ targetValue: "b", selectIntent: true });
    expect(resolveRadioKey("Enter", "b", order)).toEqual({
      targetValue: "b",
      selectIntent: true,
    });
  });

  it("returns null for unhandled keys or empty groups", () => {
    expect(resolveRadioKey("x", "a", order)).toBeNull();
    expect(resolveRadioKey("ArrowDown", "a", [])).toBeNull();
  });
});

describe("isRtlContext", () => {
  it("detects document.dir and a dir=rtl ancestor", () => {
    const el = document.createElement("div");
    document.body.append(el);
    expect(isRtlContext(el)).toBe(false);

    document.documentElement.setAttribute("dir", "rtl");
    expect(isRtlContext(el)).toBe(true);
    document.documentElement.removeAttribute("dir");

    const wrap = document.createElement("div");
    wrap.setAttribute("dir", "rtl");
    const inner = document.createElement("span");
    wrap.append(inner);
    document.body.append(wrap);
    expect(isRtlContext(inner)).toBe(true);
  });

  it("lets a nested dir=ltr island override an RTL document", () => {
    document.documentElement.setAttribute("dir", "rtl");
    const island = document.createElement("div");
    island.setAttribute("dir", "ltr");
    const inner = document.createElement("span");
    island.append(inner);
    document.body.append(island);

    expect(isRtlContext(inner)).toBe(false);
  });

  it("honors computed RTL when no explicit ancestor declares direction", () => {
    const inner = document.createElement("span");
    document.body.append(inner);
    vi.spyOn(window, "getComputedStyle").mockReturnValue({
      direction: "rtl",
    } as CSSStyleDeclaration);

    expect(isRtlContext(inner)).toBe(true);
  });
});