import type { Discovery } from "@t3tools/client-runtime/relay";
import type { AtomCommandResult } from "@t3tools/client-runtime/state/runtime";
import { EnvironmentId } from "@t3tools/contracts";
import * as Option from "effect/Option";
import { AsyncResult } from "effect/unstable/reactivity";
import { act, useState, type ButtonHTMLAttributes, type ReactNode } from "react";
import { create, type ReactTestRenderer } from "react-test-renderer";
import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test";

type DiscoveredEnvironments = Discovery.RelayEnvironmentDiscoveryState["environments"];

const discovery = vi.hoisted(() => ({
  state: null as Discovery.RelayEnvironmentDiscoveryState | null,
  listeners: new Set<() => void>(),
  refreshCommand: Symbol("refresh"),
  registerCommand: Symbol("register"),
  refresh: vi.fn<() => Promise<AtomCommandResult<void, never>>>(),
  register: vi.fn(),
  listEnvironments: vi.fn<() => Promise<DiscoveredEnvironments>>(),
}));

vi.mock("~/state/relay", () => ({
  relayEnvironmentDiscovery: { refresh: discovery.refreshCommand },
}));
vi.mock("~/connection/catalog", () => ({
  environmentCatalog: { register: discovery.registerCommand },
}));
vi.mock("~/state/use-atom-command", () => ({
  useAtomCommand: (command: unknown) =>
    command === discovery.refreshCommand ? discovery.refresh : discovery.register,
}));
vi.mock("~/state/environments", async () => {
  const { useSyncExternalStore } = await import("react");
  const subscribe = (listener: () => void) => {
    discovery.listeners.add(listener);
    return () => discovery.listeners.delete(listener);
  };
  const read = () => {
    if (discovery.state === null) throw new Error("Discovery fixture is not initialized");
    return discovery.state;
  };
  return { useRelayEnvironmentDiscovery: () => useSyncExternalStore(subscribe, read, read) };
});
vi.mock("../ConnectionStatusDot", () => ({ ConnectionStatusDot: () => null }));
vi.mock("../ui/tooltip", () => ({
  Tooltip: ({ children }: { children: ReactNode }) => children,
  TooltipTrigger: ({ children }: { children: ReactNode }) => <span>{children}</span>,
  TooltipPopup: () => null,
}));
vi.mock("../ui/checkbox", () => ({
  Checkbox: (props: {
    checked: boolean;
    disabled: boolean;
    onCheckedChange: (checked: boolean) => void;
  }) => (
    <input
      type="checkbox"
      checked={props.checked}
      disabled={props.disabled}
      onChange={(event) => props.onCheckedChange(event.target.checked)}
    />
  ),
}));
vi.mock("../ui/button", () => ({
  Button: ({ children, ...props }: ButtonHTMLAttributes<HTMLButtonElement>) => (
    <button {...props}>{children}</button>
  ),
}));
vi.mock("../ui/toast", () => ({ toastManager: { add: vi.fn() } }));

import { CloudEnvironmentConnectRows } from "./CloudEnvironmentConnectList";

const newMachineId = EnvironmentId.make("new-computer");
const linkedMachines: DiscoveredEnvironments = new Map([
  [
    newMachineId,
    {
      environment: {
        environmentId: newMachineId,
        label: "Work laptop",
        endpoint: {
          httpBaseUrl: "https://relay.example.test",
          wsBaseUrl: "wss://relay.example.test/ws",
          providerKind: "manual",
        },
        linkedAt: "2026-09-05T12:00:00.000Z",
      },
      availability: "online",
      status: Option.none(),
      error: Option.none(),
    },
  ],
]);

let renderer: ReactTestRenderer | null;
let page: EventTarget & { visibilityState: DocumentVisibilityState };
let browserWindow: EventTarget;

function publish(state: Discovery.RelayEnvironmentDiscoveryState) {
  discovery.state = state;
  for (const listener of discovery.listeners) listener();
}

async function mount(refreshWhileEmpty = true) {
  await act(async () => {
    renderer = create(
      <CloudEnvironmentConnectRows
        primaryEnvironmentId={null}
        savedEnvironments={[]}
        showSavedEnvironments
        refreshWhileEmpty={refreshWhileEmpty}
        empty={<p>Waiting for your computer to connect.</p>}
      />,
    );
  });
}

async function advance(milliseconds: number) {
  await act(async () => {
    await vi.advanceTimersByTimeAsync(milliseconds);
  });
}

beforeEach(() => {
  vi.useFakeTimers();
  vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
  page = Object.assign(new EventTarget(), { visibilityState: "visible" as const });
  browserWindow = new EventTarget();
  vi.stubGlobal("document", page);
  vi.stubGlobal("window", browserWindow);
  renderer = null;
  discovery.listeners.clear();
  discovery.state = {
    environments: new Map(),
    refreshing: false,
    offline: false,
    error: Option.none(),
  };
  discovery.listEnvironments.mockReset().mockResolvedValue(new Map());
  discovery.register.mockReset().mockResolvedValue(AsyncResult.success(undefined));
  discovery.refresh.mockReset().mockImplementation(async () => {
    publish({ environments: new Map(), refreshing: true, offline: false, error: Option.none() });
    const environments = await discovery.listEnvironments();
    publish({ environments, refreshing: false, offline: false, error: Option.none() });
    return AsyncResult.success(undefined);
  });
});

afterEach(async () => {
  await act(async () => renderer?.unmount());
  vi.useRealTimers();
  vi.unstubAllGlobals();
});

describe("cloud onboarding discovery", () => {
  it("signals that the section can expand after initial discovery settles", async () => {
    let finishDiscovery!: (environments: DiscoveredEnvironments) => void;
    discovery.listEnvironments.mockReturnValue(
      new Promise((resolve) => {
        finishDiscovery = resolve;
      }),
    );
    const onDiscoveryReady = vi.fn();
    await act(async () => {
      renderer = create(
        <CloudEnvironmentConnectRows
          primaryEnvironmentId={null}
          savedEnvironments={[]}
          onDiscoveryReady={onDiscoveryReady}
        />,
      );
    });
    expect(onDiscoveryReady).not.toHaveBeenCalled();
    await act(async () => {
      finishDiscovery(linkedMachines);
    });
    expect(onDiscoveryReady).toHaveBeenCalledTimes(1);
    expect(renderer!.root.findByType("button").children).toEqual(["Connect"]);
  });

  it("connects and selects discovered computers by default without overwriting deselection", async () => {
    discovery.listEnvironments.mockResolvedValue(linkedMachines);
    const autoSelectedComputers = new Set<EnvironmentId>();
    function Setup() {
      const [selectedIds, setSelectedIds] = useState<ReadonlySet<EnvironmentId>>(new Set());
      return (
        <CloudEnvironmentConnectRows
          primaryEnvironmentId={null}
          savedEnvironments={[]}
          showSavedEnvironments
          selection={{
            autoSelectedComputers,
            selectedIds,
            onChange: (id, checked) =>
              setSelectedIds((current) => {
                const next = new Set(current);
                if (checked) next.add(id);
                else next.delete(id);
                return next;
              }),
          }}
        />
      );
    }
    await act(async () => {
      renderer = create(<Setup />);
    });

    expect(discovery.register).toHaveBeenCalledTimes(1);
    expect(renderer!.root.findByType("input").props.checked).toBe(true);
    await act(async () => {
      await renderer!.root.findByType("input").props.onChange({ target: { checked: false } });
    });
    await act(async () => {
      publish({ ...discovery.state!, environments: new Map(linkedMachines) });
    });
    expect(renderer!.root.findByType("input").props.checked).toBe(false);
    expect(discovery.register).toHaveBeenCalledTimes(1);
  });

  it("shows a newly linked computer without remounting and stops polling once found", async () => {
    discovery.listEnvironments
      .mockResolvedValueOnce(new Map())
      .mockResolvedValueOnce(linkedMachines);
    await mount();
    expect(renderer!.root.findByType("p").children).toEqual([
      "Waiting for your computer to connect.",
    ]);

    await advance(5_000);

    expect(renderer!.root.findAllByType("p").map((node) => node.children)).toContainEqual([
      "Work laptop",
    ]);
    expect(renderer!.root.findByType("button").children).toEqual(["Connect"]);
    await advance(30_000);
    expect(discovery.listEnvironments).toHaveBeenCalledTimes(2);
  });

  it("keeps a discovered computer visible when it is added to the browser", async () => {
    discovery.listEnvironments.mockResolvedValue(linkedMachines);
    await mount();
    expect(renderer!.root.findByType("button").children).toEqual(["Connect"]);
    await act(async () => {
      renderer!.update(
        <CloudEnvironmentConnectRows
          primaryEnvironmentId={null}
          savedEnvironments={[
            {
              environmentId: newMachineId,
              connection: { phase: "connected", error: null, traceId: null },
            },
          ]}
          showSavedEnvironments
          refreshWhileEmpty
        />,
      );
    });
    expect(renderer!.root.findAllByType("p").map((node) => node.children)).toContainEqual([
      "Work laptop",
    ]);
    expect(renderer!.root.findByType("button").children).toEqual(["Connected"]);
  });

  it("waits while hidden and refreshes immediately when visible again", async () => {
    page.visibilityState = "hidden";
    await mount();
    await advance(30_000);
    expect(discovery.listEnvironments).not.toHaveBeenCalled();

    await act(async () => {
      page.visibilityState = "visible";
      page.dispatchEvent(new Event("visibilitychange"));
    });
    expect(discovery.listEnvironments).toHaveBeenCalledTimes(1);

    page.visibilityState = "hidden";
    page.dispatchEvent(new Event("visibilitychange"));
    browserWindow.dispatchEvent(new Event("focus"));
    await advance(30_000);
    expect(discovery.listEnvironments).toHaveBeenCalledTimes(1);
  });

  it("does not overlap a slow refresh or restart polling after unmount", async () => {
    let resolveRefresh!: (environments: DiscoveredEnvironments) => void;
    const pending = new Promise<DiscoveredEnvironments>((resolve) => {
      resolveRefresh = resolve;
    });
    discovery.listEnvironments.mockResolvedValueOnce(new Map()).mockReturnValueOnce(pending);
    await mount();
    await advance(5_000);
    expect(renderer!.root.findByType("p").children).toEqual([
      "Waiting for your computer to connect.",
    ]);

    browserWindow.dispatchEvent(new Event("focus"));
    page.dispatchEvent(new Event("visibilitychange"));
    await advance(30_000);
    expect(discovery.listEnvironments).toHaveBeenCalledTimes(2);

    await act(async () => renderer!.unmount());
    renderer = null;
    await act(async () => resolveRefresh(new Map()));
    await advance(30_000);
    expect(discovery.listEnvironments).toHaveBeenCalledTimes(2);
  });

  it("pauses while offline and resumes when discovery is online", async () => {
    await mount();
    await act(async () => publish({ ...discovery.state!, offline: true }));
    await advance(30_000);
    expect(discovery.listEnvironments).toHaveBeenCalledTimes(1);

    await act(async () => publish({ ...discovery.state!, offline: false }));
    await advance(5_000);
    expect(discovery.listEnvironments).toHaveBeenCalledTimes(2);
  });

  it("does not add polling to other cloud lists", async () => {
    await mount(false);
    await advance(30_000);
    expect(discovery.listEnvironments).toHaveBeenCalledTimes(1);
  });
});