import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test";

import { EnvironmentId, ThreadId } from "@t3tools/contracts";

const { readPreparedConnection } = vi.hoisted(() => ({
  readPreparedConnection: vi.fn<() => { httpBaseUrl: string } | null>(() => null),
}));

vi.mock("~/state/session", () => ({ readPreparedConnection }));

import {
  BROWSER_HISTORY_MAX_ENTRIES_PER_PROJECT,
  BROWSER_HISTORY_MAX_PROJECTS,
  BROWSER_HISTORY_MAX_TITLE_LENGTH,
  type BrowserHistoryEntry,
  evictExcessProjects,
  mergeBrowserHistoryState,
  migratePersistedBrowserHistoryState,
  normalizeHistoryUrl,
  recordVisitForThread,
  removeUrlForThread,
  resetBrowserHistoryForTests,
  setTitleForThreadUrl,
  upsertHistoryEntry,
  useBrowserHistoryStore,
} from "./browserHistoryStore";

function entry(overrides: Partial<BrowserHistoryEntry> = {}): BrowserHistoryEntry {
  return { url: "http://localhost:3000/", lastVisitedAt: 1000, ...overrides };
}

beforeEach(() => readPreparedConnection.mockReturnValue(null));
afterEach(() => vi.restoreAllMocks());

function spyOnPersistWrites() {
  const storage = useBrowserHistoryStore.persist.getOptions().storage;
  if (!storage) throw new Error("Browser history persistence storage is unavailable.");
  return vi.spyOn(storage, "setItem");
}

describe("normalizeHistoryUrl", () => {
  it("normalizes bare loopback hosts to http and keeps path/query", () => {
    expect(normalizeHistoryUrl("localhost:3000/admin?tab=1")).toBe(
      "http://localhost:3000/admin?tab=1",
    );
  });

  it("normalizes bare public hosts to https", () => {
    expect(normalizeHistoryUrl("myapp.test")).toBe("https://myapp.test/");
  });

  it("preserves hash routes and strips credentials", () => {
    expect(normalizeHistoryUrl("http://localhost:3000/app#/route")).toBe(
      "http://localhost:3000/app#/route",
    );
    expect(normalizeHistoryUrl("https://user:secret@example.com/")).toBe("https://example.com/");
  });

  it("rejects non-http(s), unparseable, and oversized urls", () => {
    expect(normalizeHistoryUrl("ftp://example.com")).toBeNull();
    expect(normalizeHistoryUrl("")).toBeNull();
    expect(normalizeHistoryUrl(`http://localhost/${"a".repeat(2048)}`)).toBeNull();
  });
});

describe("upsertHistoryEntry", () => {
  it("prepends new urls", () => {
    const next = upsertHistoryEntry([entry()], "http://localhost:5173/", 2000);
    expect(next.map((e) => e.url)).toEqual(["http://localhost:5173/", "http://localhost:3000/"]);
    expect(next[0]).toEqual({ url: "http://localhost:5173/", lastVisitedAt: 2000 });
  });

  it("moves revisits to front, updates the timestamp, and keeps the title", () => {
    const existing = [
      entry({ url: "http://a.test/", lastVisitedAt: 500, title: "A" }),
      entry({ url: "http://b.test/", lastVisitedAt: 400 }),
    ];
    const next = upsertHistoryEntry(existing, "http://b.test/", 3000);
    expect(next.map((e) => e.url)).toEqual(["http://b.test/", "http://a.test/"]);
    expect(next[0]?.lastVisitedAt).toBe(3000);
    expect(next[1]?.title).toBe("A");
  });

  it("caps the list at the per-project limit", () => {
    const full = Array.from({ length: BROWSER_HISTORY_MAX_ENTRIES_PER_PROJECT }, (_, i) =>
      entry({ url: `http://localhost:${3000 + i}/`, lastVisitedAt: i }),
    );
    const next = upsertHistoryEntry(full, "http://new.test/", 9999);
    expect(next).toHaveLength(BROWSER_HISTORY_MAX_ENTRIES_PER_PROJECT);
    expect(next[0]?.url).toBe("http://new.test/");
    const lastPort = 3000 + BROWSER_HISTORY_MAX_ENTRIES_PER_PROJECT - 1;
    expect(next.some((e) => e.url === `http://localhost:${lastPort}/`)).toBe(false);
    expect(next.some((e) => e.url === "http://localhost:3000/")).toBe(true);
  });

  it("with insertOrdered, slots an older entry below a newer one instead of prepending", () => {
    const existing = [entry({ url: "http://newer.test/", lastVisitedAt: 2000 })];
    const next = upsertHistoryEntry(existing, "http://older.test/", 1000, {
      insertOrdered: true,
    });
    expect(next.map((e) => e.url)).toEqual(["http://newer.test/", "http://older.test/"]);
  });

  it("with insertOrdered, replaying an older visit for an existing entry keeps its newer timestamp", () => {
    const existing = [entry({ url: "http://a.test/", lastVisitedAt: 2000 })];
    const next = upsertHistoryEntry(existing, "http://a.test/", 1000, { insertOrdered: true });
    expect(next).toEqual([{ url: "http://a.test/", lastVisitedAt: 2000 }]);
  });
});

describe("evictExcessProjects", () => {
  it("keeps the most recently visited projects when over the cap", () => {
    const byProjectKey = Object.fromEntries(
      Array.from({ length: BROWSER_HISTORY_MAX_PROJECTS + 2 }, (_, i) => [
        `project-${i}`,
        [entry({ lastVisitedAt: i })],
      ]),
    );
    const next = evictExcessProjects(byProjectKey);
    expect(Object.keys(next)).toHaveLength(BROWSER_HISTORY_MAX_PROJECTS);
    expect(next["project-0"]).toBeUndefined();
    expect(next["project-1"]).toBeUndefined();
    expect(next[`project-${BROWSER_HISTORY_MAX_PROJECTS + 1}`]).toBeDefined();
  });
});

describe("migratePersistedBrowserHistoryState", () => {
  it("drops malformed state and invalid entries", () => {
    expect(migratePersistedBrowserHistoryState(null)).toEqual({ byProjectKey: {} });
    expect(migratePersistedBrowserHistoryState({ byProjectKey: 42 })).toEqual({ byProjectKey: {} });
    const migrated = migratePersistedBrowserHistoryState({
      byProjectKey: {
        good: [
          { url: "http://a.test/", lastVisitedAt: 100, title: "A" },
          { url: "", lastVisitedAt: 100 },
          { url: "ftp://ghost.test/", lastVisitedAt: 100 },
          { url: "http://b.test/", lastVisitedAt: Number.NaN },
          "junk",
        ],
        bad: "junk",
      },
    });
    expect(migrated.byProjectKey["good"]).toEqual([
      { url: "http://a.test/", lastVisitedAt: 100, title: "A" },
    ]);
    expect(migrated.byProjectKey["bad"]).toBeUndefined();
  });

  it("normalizes persisted urls with the same rules as live writes", () => {
    const migrated = migratePersistedBrowserHistoryState({
      byProjectKey: {
        good: [{ url: "a.test/path#section", lastVisitedAt: 100 }],
      },
    });
    expect(migrated.byProjectKey["good"]).toEqual([
      { url: "https://a.test/path#section", lastVisitedAt: 100 },
    ]);
  });

  it("restores MRU ordering, deduplicates normalized urls, and enforces project bounds", () => {
    const byProjectKey = Object.fromEntries(
      Array.from({ length: BROWSER_HISTORY_MAX_PROJECTS + 1 }, (_, index) => [
        `project-${index}`,
        [{ url: `http://project-${index}.test/`, lastVisitedAt: index }],
      ]),
    );
    byProjectKey["project-1"] = [
      { url: "a.test/", lastVisitedAt: 1 },
      { url: "http://newer.test/", lastVisitedAt: 3 },
      { url: "https://a.test/", lastVisitedAt: 2 },
    ];

    const migrated = migratePersistedBrowserHistoryState({ byProjectKey });

    expect(Object.keys(migrated.byProjectKey)).toHaveLength(BROWSER_HISTORY_MAX_PROJECTS);
    expect(migrated.byProjectKey["project-0"]).toBeUndefined();
    expect(migrated.byProjectKey["project-1"]).toEqual([
      { url: "http://newer.test/", lastVisitedAt: 3 },
      { url: "https://a.test/", lastVisitedAt: 2 },
    ]);
  });

  it("rejects a lastVisitedAt outside Date's valid range", () => {
    const migrated = migratePersistedBrowserHistoryState({
      byProjectKey: {
        good: [
          { url: "http://a.test/", lastVisitedAt: 100 },
          { url: "http://b.test/", lastVisitedAt: 1e20 },
        ],
      },
    });
    expect(migrated.byProjectKey["good"]).toEqual([{ url: "http://a.test/", lastVisitedAt: 100 }]);
  });

  it("truncates oversized persisted titles to the contract bound", () => {
    const oversized = "x".repeat(BROWSER_HISTORY_MAX_TITLE_LENGTH + 100);
    const migrated = migratePersistedBrowserHistoryState({
      byProjectKey: {
        good: [{ url: "http://a.test/", lastVisitedAt: 100, title: oversized }],
      },
    });
    expect(migrated.byProjectKey["good"]?.[0]?.title).toHaveLength(
      BROWSER_HISTORY_MAX_TITLE_LENGTH,
    );
    expect(migrated.byProjectKey["good"]?.[0]?.title).toBe(
      oversized.slice(0, BROWSER_HISTORY_MAX_TITLE_LENGTH),
    );
  });
});

const threadRef = {
  environmentId: EnvironmentId.make("env-1"),
  threadId: ThreadId.make("thread-1"),
};

describe("useBrowserHistoryStore", () => {
  beforeEach(() => {
    resetBrowserHistoryForTests();
  });

  it("records visits for registered threads under the project key", () => {
    useBrowserHistoryStore.getState().registerThreadProject(threadRef, "proj-a");
    recordVisitForThread(threadRef, "myapp.test/admin#section", 1234);
    expect(useBrowserHistoryStore.getState().byProjectKey["proj-a"]).toEqual([
      { url: "https://myapp.test/admin#section", lastVisitedAt: 1234 },
    ]);
  });

  it("does not persist when a thread is already registered to the same project", () => {
    useBrowserHistoryStore.getState().registerThreadProject(threadRef, "proj-a");
    const persist = spyOnPersistWrites();

    useBrowserHistoryStore.getState().registerThreadProject(threadRef, "proj-a");

    expect(persist).not.toHaveBeenCalled();
  });

  it("ignores invalid urls whether queued pending or recorded post-registration", () => {
    recordVisitForThread(threadRef, "ftp://a.test/", 1);
    useBrowserHistoryStore.getState().registerThreadProject(threadRef, "proj-a");
    recordVisitForThread(threadRef, "ftp://a.test/", 2);
    expect(useBrowserHistoryStore.getState().byProjectKey).toEqual({});
  });

  it("sets titles update-only via the thread helper", () => {
    useBrowserHistoryStore.getState().registerThreadProject(threadRef, "proj-a");
    setTitleForThreadUrl(threadRef, "http://a.test/", "Should not create");
    expect(useBrowserHistoryStore.getState().byProjectKey).toEqual({});
    recordVisitForThread(threadRef, "http://a.test/#/settings", 1);
    setTitleForThreadUrl(threadRef, "http://a.test/#/settings", "My App");
    expect(useBrowserHistoryStore.getState().byProjectKey["proj-a"]?.[0]?.title).toBe("My App");
  });

  it("does not persist when the title is already set", () => {
    useBrowserHistoryStore.getState().registerThreadProject(threadRef, "proj-a");
    recordVisitForThread(threadRef, "http://a.test/", 1);
    setTitleForThreadUrl(threadRef, "http://a.test/", "My App");
    const persist = spyOnPersistWrites();
    const byProjectKey = useBrowserHistoryStore.getState().byProjectKey;

    setTitleForThreadUrl(threadRef, "http://a.test/", "My App");

    expect(useBrowserHistoryStore.getState().byProjectKey).toBe(byProjectKey);
    expect(persist).not.toHaveBeenCalled();
  });

  it("sets a title against a settled url that differs from the stored one only by a trailing slash", () => {
    useBrowserHistoryStore.getState().registerThreadProject(threadRef, "proj-a");
    recordVisitForThread(threadRef, "http://a.test/community", 1);
    setTitleForThreadUrl(threadRef, "http://a.test/community/", "Community");
    expect(useBrowserHistoryStore.getState().byProjectKey["proj-a"]?.[0]).toMatchObject({
      url: "http://a.test/community",
      title: "Community",
    });

    useBrowserHistoryStore.setState({ byProjectKey: {} });
    recordVisitForThread(threadRef, "http://a.test/community/", 1);
    setTitleForThreadUrl(threadRef, "http://a.test/community", "Community");
    expect(useBrowserHistoryStore.getState().byProjectKey["proj-a"]?.[0]).toMatchObject({
      url: "http://a.test/community/",
      title: "Community",
    });
  });

  it("matches a requested localhost URL to the resolved environment host", () => {
    useBrowserHistoryStore.getState().registerThreadProject(threadRef, "proj-a");
    recordVisitForThread(threadRef, "http://localhost:5173/app", 1);
    setTitleForThreadUrl(threadRef, "http://192.168.64.2:5173/app", "Local App", "192.168.64.2");
    expect(useBrowserHistoryStore.getState().byProjectKey["proj-a"]?.[0]?.title).toBe("Local App");
  });

  it("deduplicates loopback aliases and the resolved environment host", () => {
    readPreparedConnection.mockReturnValue({ httpBaseUrl: "http://192.168.64.2:3773" });
    useBrowserHistoryStore.getState().registerThreadProject(threadRef, "proj-a");
    recordVisitForThread(threadRef, "http://localhost:5173/app", 1);
    recordVisitForThread(threadRef, "http://127.0.0.1:5173/app", 2);
    recordVisitForThread(threadRef, "http://192.168.64.2:5173/app", 3);
    expect(useBrowserHistoryStore.getState().byProjectKey["proj-a"]).toEqual([
      { url: "http://localhost:5173/app", lastVisitedAt: 3 },
    ]);

    useBrowserHistoryStore.setState({ byProjectKey: {} });
    recordVisitForThread(threadRef, "http://192.168.64.2:5173/app", 4);
    recordVisitForThread(threadRef, "http://localhost:5173/app", 5);
    expect(useBrowserHistoryStore.getState().byProjectKey["proj-a"]).toEqual([
      { url: "http://localhost:5173/app", lastVisitedAt: 5 },
    ]);
  });

  it("does not match a genuinely different path via the trailing-slash comparison", () => {
    useBrowserHistoryStore.getState().registerThreadProject(threadRef, "proj-a");
    recordVisitForThread(threadRef, "http://a.test/community", 1);
    setTitleForThreadUrl(threadRef, "http://a.test/community/foo", "Foo");
    expect(useBrowserHistoryStore.getState().byProjectKey["proj-a"]?.[0]?.title).toBeUndefined();
  });

  it("updates only the most recent entry when several share a trailing-slash comparison key", () => {
    useBrowserHistoryStore.getState().registerThreadProject(threadRef, "proj-a");
    recordVisitForThread(threadRef, "http://a.test/community/", 1);
    recordVisitForThread(threadRef, "http://a.test/community", 2);
    setTitleForThreadUrl(threadRef, "http://a.test/community/", "Community");
    const entries = useBrowserHistoryStore.getState().byProjectKey["proj-a"];
    expect(entries?.[0]).toMatchObject({ url: "http://a.test/community", title: "Community" });
    expect(entries?.[1]).toMatchObject({ url: "http://a.test/community/" });
    expect(entries?.[1]?.title).toBeUndefined();
  });

  it("truncates oversized titles to the contract bound", () => {
    useBrowserHistoryStore.getState().registerThreadProject(threadRef, "proj-a");
    recordVisitForThread(threadRef, "http://a.test/", 1);
    const oversized = "y".repeat(BROWSER_HISTORY_MAX_TITLE_LENGTH + 50);
    setTitleForThreadUrl(threadRef, "http://a.test/", oversized);
    const title = useBrowserHistoryStore.getState().byProjectKey["proj-a"]?.[0]?.title;
    expect(title).toHaveLength(BROWSER_HISTORY_MAX_TITLE_LENGTH);
    expect(title).toBe(oversized.slice(0, BROWSER_HISTORY_MAX_TITLE_LENGTH));
  });

  it("removes entries", () => {
    useBrowserHistoryStore.getState().registerThreadProject(threadRef, "proj-a");
    recordVisitForThread(threadRef, "http://a.test/", 1);
    recordVisitForThread(threadRef, "http://b.test/", 2);
    removeUrlForThread(threadRef, "http://a.test/");
    expect(useBrowserHistoryStore.getState().byProjectKey["proj-a"]?.map((e) => e.url)).toEqual([
      "http://b.test/",
    ]);
  });
});

describe("pendingVisitsByThreadKey", () => {
  beforeEach(() => {
    resetBrowserHistoryForTests();
  });

  it("queues a visit recorded before registration and drains it in order on registration", () => {
    recordVisitForThread(threadRef, "http://a.test/", 1);
    recordVisitForThread(threadRef, "http://b.test/", 2);
    expect(useBrowserHistoryStore.getState().byProjectKey).toEqual({});
    useBrowserHistoryStore.getState().registerThreadProject(threadRef, "proj-a");
    expect(useBrowserHistoryStore.getState().byProjectKey["proj-a"]?.map((e) => e.url)).toEqual([
      "http://b.test/",
      "http://a.test/",
    ]);
    expect(useBrowserHistoryStore.getState().byProjectKey["proj-a"]?.[0]?.lastVisitedAt).toBe(2);
    expect(useBrowserHistoryStore.getState().byProjectKey["proj-a"]?.[1]?.lastVisitedAt).toBe(1);
    expect(useBrowserHistoryStore.getState().pendingVisitsByThreadKey).toEqual({});
  });

  it("caps the per-thread pending list at 10, dropping the oldest", () => {
    for (let i = 0; i < 12; i++) {
      recordVisitForThread(threadRef, `http://a.test/${i}`, i);
    }
    useBrowserHistoryStore.getState().registerThreadProject(threadRef, "proj-a");
    const urls = useBrowserHistoryStore.getState().byProjectKey["proj-a"]?.map((e) => e.url);
    expect(urls).toHaveLength(10);
    expect(urls).not.toContain("http://a.test/0");
    expect(urls).not.toContain("http://a.test/1");
    expect(urls?.[0]).toBe("http://a.test/11");
  });

  it("slots a replayed visit by timestamp instead of hoisting it above a newer live visit", () => {
    const otherThreadRef = {
      environmentId: EnvironmentId.make("env-1"),
      threadId: ThreadId.make("thread-2"),
    };
    useBrowserHistoryStore.getState().registerThreadProject(otherThreadRef, "proj-a");
    recordVisitForThread(otherThreadRef, "http://newer.test/", 2000);
    recordVisitForThread(threadRef, "http://older.test/", 1000);
    useBrowserHistoryStore.getState().registerThreadProject(threadRef, "proj-a");

    const entries = useBrowserHistoryStore.getState().byProjectKey["proj-a"];
    expect(entries?.map((e) => e.url)).toEqual(["http://newer.test/", "http://older.test/"]);
    // `entries[0]` being the most recent is the invariant `evictExcessProjects` relies on.
    expect(entries?.[0]?.lastVisitedAt).toBe(2000);
  });
});

describe("pendingTitlesByThreadKey", () => {
  beforeEach(() => {
    resetBrowserHistoryForTests();
  });

  it("buffers a title set before registration and applies it once the matching visit drains", () => {
    recordVisitForThread(threadRef, "http://a.test/", 1);
    setTitleForThreadUrl(threadRef, "http://a.test/", "My App");
    expect(useBrowserHistoryStore.getState().byProjectKey).toEqual({});

    useBrowserHistoryStore.getState().registerThreadProject(threadRef, "proj-a");

    const entries = useBrowserHistoryStore.getState().byProjectKey["proj-a"];
    expect(entries?.[0]).toMatchObject({ url: "http://a.test/", title: "My App" });
    expect(useBrowserHistoryStore.getState().pendingTitlesByThreadKey).toEqual({});
  });

  it("preserves environment host matching while a title is pending", () => {
    recordVisitForThread(threadRef, "http://localhost:5173/app", 1);
    setTitleForThreadUrl(threadRef, "http://192.168.64.2:5173/app", "Local App", "192.168.64.2");
    useBrowserHistoryStore.getState().registerThreadProject(threadRef, "proj-a");
    expect(useBrowserHistoryStore.getState().byProjectKey["proj-a"]?.[0]?.title).toBe("Local App");
  });
});

describe("mergeBrowserHistoryState", () => {
  it("sanitizes same-version corrupt persisted data and preserves actions", () => {
    // `migrate` only runs when versions differ; `merge` runs on every rehydrate.
    const current = useBrowserHistoryStore.getState();
    const merged = mergeBrowserHistoryState(
      {
        byProjectKey: {
          a: [{ url: "ftp://bad.test/", lastVisitedAt: 1 }],
          b: [{ url: "http://ok.test/", lastVisitedAt: 5 }],
        },
        projectKeyByThreadKey: { good: "b", stale: "a", malformed: 42 },
      },
      current,
    );
    expect(merged.byProjectKey).toEqual({
      b: [{ url: "http://ok.test/", lastVisitedAt: 5 }],
    });
    expect(typeof merged.recordVisit).toBe("function");
    expect(merged.projectKeyByThreadKey).toEqual({ good: "b" });
    expect(merged.pendingVisitsByThreadKey).toEqual({});
    expect(merged.pendingTitlesByThreadKey).toEqual({});
  });
});