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

/**
 * Tests for the Liquid path matching and parameter detection logic.
 * These mirror the logic in seo-injection.liquid to ensure correctness.
 */

// Simulates the Liquid path matching for custom URL paths
function matchesPath(configuredPath: string, requestPath: string): boolean {
  let cleaned = configuredPath.trim();
  if (!cleaned) return false;

  // Add leading slash if missing
  if (!cleaned.includes("/")) {
    cleaned = "/" + cleaned;
  }

  // Remove trailing slash for comparison
  const cleanedNorm = cleaned.endsWith("/") && cleaned.length > 1
    ? cleaned.slice(0, -1)
    : cleaned;
  const requestNorm = requestPath.endsWith("/") && requestPath.length > 1
    ? requestPath.slice(0, -1)
    : requestPath;

  // Exact match (normalized) OR prefix match (configured path is prefix of request)
  return requestNorm === cleanedNorm || requestPath.includes(cleaned);
}

// Simulates the JS parameter detection for custom URL parameters
function matchesParam(paramName: string, queryString: string): boolean {
  if (!queryString) return false;
  const p = paramName.trim();
  if (!p) return false;

  return (
    queryString.includes(p + "=") ||
    queryString.includes(p + "&") ||
    queryString.indexOf("?" + p) === 0 ||
    queryString.endsWith(p)
  );
}

describe("Liquid path matching", () => {
  it("exact match without trailing slash", () => {
    expect(matchesPath("/blogs/news", "/blogs/news")).toBe(true);
  });

  it("exact match with trailing slash on config", () => {
    expect(matchesPath("/blogs/news/", "/blogs/news")).toBe(true);
  });

  it("exact match with trailing slash on request", () => {
    expect(matchesPath("/blogs/news", "/blogs/news/")).toBe(true);
  });

  it("prefix match — subpage", () => {
    expect(matchesPath("/blogs/news/", "/blogs/news/avantages-snowblades")).toBe(true);
  });

  it("prefix match — deep subpage", () => {
    expect(matchesPath("/blogs/news", "/blogs/news/2024/some-post")).toBe(true);
  });

  it("no match — different path", () => {
    expect(matchesPath("/blogs/news", "/collections/all")).toBe(false);
  });

  it("known limitation: /blog matches /blogs/news (contains-based)", () => {
    // Liquid uses `contains` for prefix match — this is a known trade-off
    // Users should use /blogs/news not /blog to be specific
    expect(matchesPath("/blog", "/blogs/news")).toBe(true);
  });

  it("handles without slash — adds leading slash", () => {
    expect(matchesPath("contact", "/contact")).toBe(true);
  });

  it("empty config — no match", () => {
    expect(matchesPath("", "/anything")).toBe(false);
  });

  it("spaces are trimmed", () => {
    expect(matchesPath("  /blogs/news  ", "/blogs/news")).toBe(true);
  });
});

describe("JS parameter detection", () => {
  it("matches param with value (param=value)", () => {
    expect(matchesParam("refSrc", "?refSrc=12345")).toBe(true);
  });

  it("matches param without value (?param)", () => {
    expect(matchesParam("tatayoyo", "?tatayoyo")).toBe(true);
  });

  it("matches param followed by & (?param&other)", () => {
    expect(matchesParam("tatayoyo", "?tatayoyo&foo=bar")).toBe(true);
  });

  it("matches param in middle (?foo=1&param=2)", () => {
    expect(matchesParam("refSrc", "?foo=1&refSrc=abc")).toBe(true);
  });

  it("matches param at end (?foo=1&param)", () => {
    expect(matchesParam("tatayoyo", "?foo=1&tatayoyo")).toBe(true);
  });

  it("no match — empty query", () => {
    expect(matchesParam("refSrc", "")).toBe(false);
  });

  it("no match — different param", () => {
    expect(matchesParam("refSrc", "?utm_source=google")).toBe(false);
  });

  it("known limitation: ref matches refSrc=123 (indexOf-based)", () => {
    // JS indexOf("ref=") doesn't match "refSrc=123", but indexOf("ref&") or endsWith("ref") could
    // This specific case: "ref" + "=" = "ref=" which is NOT in "?refSrc=123" — should be false
    // But "?refSrc=123".endsWith("ref") is false too. Let's verify actual behavior.
    // indexOf("ref=") in "?refSrc=123" = -1 (no match) ✓
    // indexOf("ref&") in "?refSrc=123" = -1 (no match) ✓
    // indexOf("?ref") === 0 in "?refSrc=123" = true! ← this causes false positive
    expect(matchesParam("ref", "?refSrc=123")).toBe(true); // known limitation
  });

  it("empty param name — no match", () => {
    expect(matchesParam("", "?foo=bar")).toBe(false);
  });
});