import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';

/**
 * Regression tests for the `next/navigation` shim fallback (unregistered host).
 *
 * The guarantee under test: an unregistered `useRouter().push/replace` must
 * perform a same-origin SPA navigation via the History API and NEVER hard-load
 * the document — a `?search=` write from `useApiParams` used to hard-reload via
 * `window.location.replace`. The registered path must delegate to the host
 * router untouched.
 *
 * `impl` is module-level singleton state, so each test re-imports the module
 * fresh via `vi.resetModules()` to isolate registration state. We also stub
 * `window.location` with a spy object so any hard navigation (assign/replace/
 * reload) is observable — jsdom leaves those methods unimplemented anyway.
 */

const ORIGIN = 'http://localhost:3000';

async function freshModule() {
  vi.resetModules();
  return import('../next-navigation');
}

let assignSpy: ReturnType<typeof vi.fn>;
let replaceSpy: ReturnType<typeof vi.fn>;
let reloadSpy: ReturnType<typeof vi.fn>;
let pushStateSpy: ReturnType<typeof vi.spyOn>;
let replaceStateSpy: ReturnType<typeof vi.spyOn>;
let originalLocation: Location;

beforeEach(() => {
  originalLocation = window.location;
  assignSpy = vi.fn();
  replaceSpy = vi.fn();
  reloadSpy = vi.fn();
  Object.defineProperty(window, 'location', {
    configurable: true,
    value: {
      href: `${ORIGIN}/`,
      origin: ORIGIN,
      pathname: '/',
      search: '',
      assign: assignSpy,
      replace: replaceSpy,
      reload: reloadSpy,
    },
  });
  // Real jsdom history — spy without changing behavior so we can assert which
  // History API the fallback used (push vs replace encodes the nav semantics).
  pushStateSpy = vi.spyOn(window.history, 'pushState');
  replaceStateSpy = vi.spyOn(window.history, 'replaceState');
});

afterEach(() => {
  Object.defineProperty(window, 'location', { configurable: true, value: originalLocation });
  vi.restoreAllMocks();
});

describe('fallback useRouter (unregistered host)', () => {
  it('replace() writes the URL via history.replaceState — never a hard navigation', async () => {
    const { useRouter } = await freshModule();
    const popstate = vi.fn();
    window.addEventListener('popstate', popstate);

    useRouter().replace('?search=laptop');

    expect(replaceStateSpy).toHaveBeenCalledWith(null, '', `${ORIGIN}/?search=laptop`);
    expect(pushStateSpy).not.toHaveBeenCalled();
    // No full-document navigation of any kind — this is the reported bug.
    expect(assignSpy).not.toHaveBeenCalled();
    expect(replaceSpy).not.toHaveBeenCalled();
    expect(reloadSpy).not.toHaveBeenCalled();
    // Subscribers (usePathname/useSearchParams) get a re-render signal.
    expect(popstate).toHaveBeenCalledTimes(1);

    window.removeEventListener('popstate', popstate);
  });

  it('push() uses history.pushState (new entry) — never a hard navigation', async () => {
    const { useRouter } = await freshModule();
    useRouter().push('/scripts?tab=list');

    expect(pushStateSpy).toHaveBeenCalledWith(null, '', `${ORIGIN}/scripts?tab=list`);
    expect(replaceStateSpy).not.toHaveBeenCalled();
    expect(assignSpy).not.toHaveBeenCalled();
    expect(reloadSpy).not.toHaveBeenCalled();
  });

  it('falls back to a real navigation for cross-origin targets, honoring replace semantics', async () => {
    const { useRouter } = await freshModule();
    useRouter().replace('https://example.com/evil');

    // replace() must use location.replace (no back-button entry), not assign.
    expect(replaceSpy).toHaveBeenCalledWith('https://example.com/evil');
    expect(assignSpy).not.toHaveBeenCalled();
    expect(replaceStateSpy).not.toHaveBeenCalled();
    expect(pushStateSpy).not.toHaveBeenCalled();
  });

  it('uses location.assign for a cross-origin push (new history entry)', async () => {
    const { useRouter } = await freshModule();
    useRouter().push('https://example.com/evil');

    expect(assignSpy).toHaveBeenCalledWith('https://example.com/evil');
    expect(replaceSpy).not.toHaveBeenCalled();
    expect(pushStateSpy).not.toHaveBeenCalled();
  });

  it('falls back to a real navigation for a malformed href (push → assign)', async () => {
    const { useRouter } = await freshModule();
    useRouter().push('http://[invalid');

    expect(assignSpy).toHaveBeenCalledWith('http://[invalid');
    expect(replaceSpy).not.toHaveBeenCalled();
    expect(pushStateSpy).not.toHaveBeenCalled();
  });

  it('falls back to a real navigation for a malformed href (replace → replace)', async () => {
    const { useRouter } = await freshModule();
    useRouter().replace('http://[invalid');

    expect(replaceSpy).toHaveBeenCalledWith('http://[invalid');
    expect(assignSpy).not.toHaveBeenCalled();
    expect(replaceStateSpy).not.toHaveBeenCalled();
  });

  it('back/forward remain history-based (unchanged)', async () => {
    const { useRouter } = await freshModule();
    const backSpy = vi.spyOn(window.history, 'back').mockImplementation(() => {});
    const forwardSpy = vi.spyOn(window.history, 'forward').mockImplementation(() => {});
    useRouter().back();
    useRouter().forward();
    expect(backSpy).toHaveBeenCalledTimes(1);
    expect(forwardSpy).toHaveBeenCalledTimes(1);
  });
});

describe('registered useRouter (Next host)', () => {
  it('delegates to the host router and never touches window.location or history', async () => {
    const { useRouter, registerNavigation } = await freshModule();
    const hostRouter = {
      push: vi.fn(),
      replace: vi.fn(),
      back: vi.fn(),
      forward: vi.fn(),
      refresh: vi.fn(),
      prefetch: vi.fn(),
    };
    registerNavigation({ useRouter: () => hostRouter });

    const r = useRouter();
    r.replace('?search=laptop', { scroll: false });
    r.push('/scripts');

    expect(hostRouter.replace).toHaveBeenCalledWith('?search=laptop', { scroll: false });
    expect(hostRouter.push).toHaveBeenCalledWith('/scripts');
    // The fallback path is completely bypassed — no navigation side effects.
    expect(assignSpy).not.toHaveBeenCalled();
    expect(replaceSpy).not.toHaveBeenCalled();
    expect(reloadSpy).not.toHaveBeenCalled();
    expect(pushStateSpy).not.toHaveBeenCalled();
    expect(replaceStateSpy).not.toHaveBeenCalled();
  });
});