import { isValidElement, type FunctionComponent, type ReactElement } from "react";
import {
  EnvironmentId,
  ProviderDriverKind,
  ProviderInstanceId,
  type ProviderAuthState,
  type ProviderInstallState,
  type ServerProvider,
} from "@t3tools/contracts";
import { beforeEach, describe, expect, it, vi } from "vite-plus/test";

import { visitElements } from "../../test/reactElementTree";
import { reactHookHarness as hooks } from "../../test/reactHookHarness";

const setup = vi.hoisted(() => ({
  auth: null as ProviderAuthState | null,
  installation: null as ProviderInstallState | null,
  authState: vi.fn(() => "auth"),
  installState: vi.fn(() => "installation"),
  startAuth: vi.fn(),
  completeAuth: vi.fn(),
  cancelAuth: vi.fn(),
  logoutAuth: vi.fn(),
  startInstall: vi.fn(),
  cancelInstall: vi.fn(),
  removeInstall: vi.fn(),
  confirm: vi.fn(),
}));

vi.mock("react", async (importOriginal) => {
  const actual = await importOriginal<typeof import("react")>();
  const { reactHookHarness } = await import("../../test/reactHookHarness");
  return {
    ...actual,
    useRef: reactHookHarness.useRef,
    useState: reactHookHarness.useState,
  };
});

vi.mock("react/compiler-runtime", async () => {
  const { reactHookHarness } = await import("../../test/reactHookHarness");
  return { c: reactHookHarness.useMemoCache };
});

vi.mock("../../state/server", () => ({
  serverEnvironment: {
    providerAuthState: setup.authState,
    providerInstallState: setup.installState,
    startProviderAuth: setup.startAuth,
    completeProviderAuth: setup.completeAuth,
    cancelProviderAuth: setup.cancelAuth,
    logoutProviderAuth: setup.logoutAuth,
    startProviderInstall: setup.startInstall,
    cancelProviderInstall: setup.cancelInstall,
    removeProviderInstallation: setup.removeInstall,
  },
}));

vi.mock("../../state/use-atom-command", () => ({
  useAtomCommand: (command: unknown) => command,
}));

vi.mock("../../state/query", () => ({
  useEnvironmentQuery: (atom: string) => ({
    data: atom === "auth" ? setup.auth : setup.installation,
    error: null,
    isPending: false,
    refresh: vi.fn(),
  }),
}));

vi.mock("../../localApi", () => ({
  ensureLocalApi: () => ({ dialogs: { confirm: setup.confirm } }),
}));

import { ProviderSetupSection } from "./ProviderSetupSection";

const environmentId = EnvironmentId.make("remote-google");
const instanceId = ProviderInstanceId.make("antigravity_work");
const provider: ServerProvider = {
  instanceId,
  driver: ProviderDriverKind.make("antigravity"),
  installed: true,
  enabled: true,
  version: "test-version",
  status: "error",
  auth: { status: "unauthenticated" },
  checkedAt: "2026-09-02T00:00:00.000Z",
  models: [],
  skills: [],
  slashCommands: [],
  setup: { canAuthenticate: true, canInstall: true },
};

function authState(patch: Partial<ProviderAuthState> = {}): ProviderAuthState {
  return {
    instanceId,
    phase: "waiting",
    flowId: "flow-1",
    authorizationUrl: "https://accounts.google.com/o/oauth2/v2/auth?state=test-only",
    expiresAt: "2026-09-02T00:05:00.000Z",
    message: null,
    ...patch,
  };
}

function renderSetup(
  options: {
    readOnly?: boolean;
    provider?: ServerProvider;
    enabled?: boolean;
    binaryPath?: string;
  } = {},
) {
  hooks.beginRender();
  const view = ProviderSetupSection({
    environmentId,
    environmentLabel: "Remote Google device",
    instanceId,
    provider: options.provider ?? provider,
    binaryPath: options.binaryPath,
    enabled: options.enabled ?? true,
    readOnly: options.readOnly ?? false,
    onEnable: vi.fn(),
  });
  const actions = visitElements(
    view,
    (element) =>
      typeof element.type === "function" &&
      element.props.environmentId === environmentId &&
      element.props.instanceId === instanceId,
  );
  if (!actions) return view;
  const Actions = actions.type as FunctionComponent<Record<string, unknown>>;
  return Actions(actions.props) as ReactElement<Record<string, unknown>>;
}

function button(view: unknown, label: string) {
  return visitElements(
    view,
    (element) => element.props.children === label && typeof element.props.onClick === "function",
  );
}

function countElements(
  node: unknown,
  predicate: (element: ReactElement<Record<string, unknown>>) => boolean,
): number {
  if (Array.isArray(node)) {
    return node.reduce((total, child) => total + countElements(child, predicate), 0);
  }
  if (!isValidElement<Record<string, unknown>>(node)) return 0;
  return (
    Number(predicate(node)) +
    Object.values(node.props).reduce<number>(
      (total, value) => total + countElements(value, predicate),
      0,
    )
  );
}

function click(view: unknown, label: string) {
  const target = button(view, label);
  if (!target) throw new Error(`Missing button: ${label}`);
  if (target.props.disabled) throw new Error(`Button is disabled: ${label}`);
  (target.props.onClick as () => void)();
}

function setCallback(view: unknown, value: string) {
  const input = visitElements(
    view,
    (element) => element.props.id === `provider-callback-${instanceId}`,
  );
  if (!input) throw new Error("Missing callback input.");
  (input.props.onChange as (event: { target: { value: string } }) => void)({ target: { value } });
}

function submitCallback(view: unknown) {
  const form = visitElements(view, (element) => element.type === "form");
  if (!form) throw new Error("Missing callback form.");
  (form.props.onSubmit as (event: { preventDefault: () => void }) => void)({
    preventDefault: vi.fn(),
  });
}

async function flushPromises() {
  await Promise.resolve();
  await Promise.resolve();
  await Promise.resolve();
}

describe("Antigravity setup", () => {
  beforeEach(() => {
    hooks.reset();
    vi.clearAllMocks();
    setup.auth = authState();
    setup.installation = {
      driver: ProviderDriverKind.make("antigravity"),
      operationId: null,
      phase: "idle",
      downloadedBytes: 0,
      totalBytes: null,
      version: null,
      installedVersion: null,
      canRemove: false,
      message: null,
    };
    for (const command of [
      setup.startAuth,
      setup.completeAuth,
      setup.cancelAuth,
      setup.logoutAuth,
      setup.startInstall,
      setup.cancelInstall,
      setup.removeInstall,
    ]) {
      command.mockReset().mockResolvedValue({ _tag: "Success", value: undefined });
    }
    setup.confirm.mockReset().mockResolvedValue(false);
  });

  it("waits for verified auth after submitting a callback to the selected environment", async () => {
    const callbackUrl = "http://127.0.0.1:5555/?state=test-only&code=test-only";
    setCallback(renderSetup(), callbackUrl);
    submitCallback(renderSetup());
    await flushPromises();

    expect(setup.completeAuth).toHaveBeenCalledWith({
      environmentId,
      input: { instanceId, flowId: "flow-1", callbackUrl },
    });
    let view = renderSetup();
    expect(
      visitElements(view, (element) => element.props.children === "Signed in with Google."),
    ).toBeNull();
    expect(
      visitElements(view, (element) => element.props.id === `provider-callback-${instanceId}`)
        ?.props.value,
    ).toBe("");

    setup.auth = authState({ phase: "verifying", authorizationUrl: null });
    expect(
      visitElements(
        renderSetup(),
        (element) => element.props.children === "Signed in with Google.",
      ),
    ).toBeNull();
    setup.auth = authState({ phase: "succeeded", authorizationUrl: null });
    view = renderSetup({
      provider: { ...provider, status: "ready", auth: { status: "authenticated" } },
    });
    expect(
      visitElements(view, (element) => element.props.children === "Signed in with Google."),
    ).not.toBeNull();
  });

  it("offers sign-in again when credentials expire after a completed auth flow", () => {
    setup.auth = authState({
      phase: "succeeded",
      authorizationUrl: null,
      message: "Google sign-in complete.",
    });
    renderSetup({
      provider: { ...provider, status: "ready", auth: { status: "authenticated" } },
    });
    const expired = renderSetup();
    expect(button(expired, "Sign in with Google")).not.toBeNull();
    expect(
      visitElements(expired, (element) => element.props.children === "Signed in with Google."),
    ).toBeNull();
    expect(
      visitElements(expired, (element) => element.props.children === "Google sign-in complete."),
    ).toBeNull();
  });

  it("does not send a callback left over from a replaced sign-in flow", async () => {
    setCallback(renderSetup(), "http://127.0.0.1:5555/?state=old-flow&code=test-only");
    setup.auth = authState({ flowId: "flow-2" });
    submitCallback(renderSetup());
    await flushPromises();

    expect(setup.completeAuth).not.toHaveBeenCalled();
    expect(setup.authState).toHaveBeenLastCalledWith({ environmentId, input: { instanceId } });
  });

  it("coalesces repeated sign-in clicks while start is pending", async () => {
    setup.auth = authState({ phase: "idle", flowId: null, authorizationUrl: null });
    let completeStart: (value: { _tag: "Success"; value: undefined }) => void = () => {
      throw new Error("Missing start resolver.");
    };
    const pending = new Promise<{ _tag: "Success"; value: undefined }>((resolve) => {
      completeStart = resolve;
    });
    setup.startAuth.mockReturnValueOnce(pending);
    const view = renderSetup();
    click(view, "Sign in with Google");
    click(view, "Sign in with Google");

    expect(setup.startAuth).toHaveBeenCalledTimes(1);
    expect(setup.startAuth).toHaveBeenCalledWith({ environmentId, input: { instanceId } });
    completeStart({ _tag: "Success", value: undefined });
    await flushPromises();
  });

  it("shows a repeated runtime status message only once", () => {
    setup.installation = {
      ...setup.installation!,
      operationId: "install-1",
      phase: "verifying",
      message: "Checking the downloaded runtime.",
    };

    const view = renderSetup();
    expect(
      countElements(
        view,
        (element) => element.props.children === "Checking the downloaded runtime.",
      ),
    ).toBe(1);
  });

  it("removes an owned damaged runtime only after confirmation", async () => {
    setup.auth = authState({ phase: "idle", flowId: null, authorizationUrl: null });
    setup.installation = {
      ...setup.installation!,
      phase: "failed",
      canRemove: true,
      installedVersion: null,
    };
    const view = renderSetup();
    click(view, "Remove downloaded runtime");
    await flushPromises();
    expect(setup.removeInstall).not.toHaveBeenCalled();

    setup.confirm.mockResolvedValue(true);
    click(view, "Remove downloaded runtime");
    await flushPromises();
    expect(setup.removeInstall).toHaveBeenCalledWith({ environmentId, input: { instanceId } });
  });

  it.each([true, false])(
    "can sign out an unchecked account when its instance is enabled=%s",
    async (enabled) => {
      setup.auth = authState({ phase: "idle", flowId: null, authorizationUrl: null });
      setup.confirm.mockResolvedValue(true);
      const view = renderSetup({
        enabled,
        provider: {
          ...provider,
          enabled,
          installed: false,
          status: enabled ? "warning" : "disabled",
          auth: { status: "unknown" },
        },
      });
      click(view, "Sign out of Google");
      await flushPromises();
      expect(setup.logoutAuth).toHaveBeenCalledWith({ environmentId, input: { instanceId } });
    },
  );

  it("does not let a shared managed install hide an invalid custom binary path", () => {
    setup.auth = authState({ phase: "idle", flowId: null, authorizationUrl: null });
    setup.installation = {
      ...setup.installation!,
      installedVersion: "test-version",
      canRemove: true,
    };
    const view = renderSetup({
      provider: { ...provider, installed: false },
      binaryPath: "/missing/antigravity",
    });
    expect(button(view, "Sign in with Google")?.props.disabled).toBe(true);
    expect(setup.startAuth).not.toHaveBeenCalled();
  });

  it.each(["read-only", "older-server"] as const)(
    "does not open private setup subscriptions for a %s view",
    (mode) => {
      const { setup: _setup, ...olderProvider } = provider;
      renderSetup(mode === "read-only" ? { readOnly: true } : { provider: olderProvider });
      expect(setup.authState).not.toHaveBeenCalled();
      expect(setup.installState).not.toHaveBeenCalled();
      expect(setup.startAuth).not.toHaveBeenCalled();
    },
  );
});