import { describe, expect, it } from "@effect/vitest";
import {
  AuthTemplateSlug,
  ConnectionAddress,
  ConnectionName,
  IntegrationSlug,
  OAuthClientSlug,
  ProviderKey,
  type Connection,
} from "@executor-js/sdk/shared";

import type { ProviderAccount } from "../lib/provider-accounts";
import {
  activeEnableServiceStep,
  applyEnableServiceStepResult,
  buildEnableServiceOAuthStartPayload,
  continueEnableServiceStep,
  createEnableServicesQueue,
  EnableServicesModal,
  retryEnableServiceStep,
  type EnableServiceIntegration,
  type EnableServiceQueue,
  type EnableServiceStepStatus,
} from "./enable-services-modal";
import type { OAuthStartPayload } from "../plugins/oauth-sign-in";

const service = (
  slug: string,
  name: string,
  template = `${slug}_oauth`,
): EnableServiceIntegration => ({
  slug: IntegrationSlug.make(slug),
  name,
  kind: "google",
  authMethods: [
    {
      id: "oauth",
      label: "OAuth",
      kind: "oauth",
      template,
    },
  ],
});

const gmail = service("google_gmail", "Gmail", "gmail_oauth");
const calendar = service("google_calendar", "Google Calendar", "calendar_oauth");
const drive = service("google_drive", "Google Drive", "drive_oauth");

const connection = (input?: { readonly oauthClientOwner?: "org" | "user" | null }): Connection => ({
  owner: "user",
  name: ConnectionName.make("gmail"),
  integration: IntegrationSlug.make("google_gmail"),
  template: AuthTemplateSlug.make("gmail_oauth"),
  provider: ProviderKey.make("default"),
  address: ConnectionAddress.make("tools.google_gmail.user.gmail"),
  identityLabel: "user@example.com",
  description: null,
  expiresAt: null,
  oauthClient: OAuthClientSlug.make("google-app"),
  oauthClientOwner: input && "oauthClientOwner" in input ? input.oauthClientOwner : "org",
  oauthScope: null,
  lastHealth: null,
});

const account = (input?: {
  readonly label?: string;
  readonly oauthClientOwner?: "org" | "user" | null;
}): ProviderAccount<Connection, EnableServiceIntegration> => ({
  family: "google",
  owner: "user",
  identityKey: "user:google:user@example.com",
  label: input?.label ?? "user@example.com",
  connections: [{ connection: connection(input), integration: gmail }],
});

describe("enable services queue", () => {
  it("advances on success, keeps the remainder on failure, and retries", () => {
    let queue = createEnableServicesQueue([gmail, calendar, drive]);
    expect(activeEnableServiceStep(queue)?.integration.slug).toBe(gmail.slug);

    queue = applyEnableServiceStepResult(queue, gmail.slug, "done");
    expect(activeEnableServiceStep(queue)?.integration.slug).toBe(calendar.slug);

    queue = applyEnableServiceStepResult(queue, calendar.slug, "failed");
    expect(activeEnableServiceStep(queue)?.integration.slug).toBe(calendar.slug);
    expect(queue.steps.map((step) => [String(step.integration.slug), step.status])).toEqual([
      ["google_gmail", "done"],
      ["google_calendar", "failed"],
      ["google_drive", "pending"],
    ]);

    queue = retryEnableServiceStep(queue, calendar.slug);
    expect(activeEnableServiceStep(queue)?.integration.slug).toBe(calendar.slug);
    expect(queue.steps[1]?.status).toBe("pending");

    queue = applyEnableServiceStepResult(queue, calendar.slug, "done");
    expect(activeEnableServiceStep(queue)?.integration.slug).toBe(drive.slug);
  });
});

describe("buildEnableServiceOAuthStartPayload", () => {
  it("builds the startOAuth payload with loginHint, mirrored client, and service template", () => {
    const calls: OAuthStartPayload[] = [];
    const startOAuth = (payload: OAuthStartPayload) => calls.push(payload);
    const payload = buildEnableServiceOAuthStartPayload({
      account: account(),
      integration: calendar,
      organizationId: "org_123",
    });

    expect(payload).not.toBeNull();
    startOAuth(payload!);

    expect(calls).toHaveLength(1);
    expect(calls[0]).toMatchObject({
      client: OAuthClientSlug.make("google-app"),
      clientOwner: "org",
      owner: "user",
      name: ConnectionName.make("userGoogleCalendar"),
      integration: IntegrationSlug.make("google_calendar"),
      template: AuthTemplateSlug.make("calendar_oauth"),
      identityLabel: "user Google Calendar",
      loginHint: "user@example.com",
    });
  });

  it("derives distinct names for two same-owner accounts enabling the same service", () => {
    const first = buildEnableServiceOAuthStartPayload({
      account: account({ label: "rhys@example.com" }),
      integration: calendar,
      organizationId: "org_123",
    });
    const second = buildEnableServiceOAuthStartPayload({
      account: account({ label: "work@example.com" }),
      integration: calendar,
      organizationId: "org_123",
    });

    expect(first?.name).toBe(ConnectionName.make("rhysGoogleCalendar"));
    expect(second?.name).toBe(ConnectionName.make("workGoogleCalendar"));
    expect(first?.identityLabel).toBe("rhys Google Calendar");
    expect(second?.identityLabel).toBe("work Google Calendar");
    expect(first?.name).not.toBe(second?.name);
  });

  it("uses the connection owner when the existing connection has no client owner", () => {
    const payload = buildEnableServiceOAuthStartPayload({
      account: account({ oauthClientOwner: null }),
      integration: drive,
      organizationId: "org_123",
    });

    expect(payload?.clientOwner).toBe("user");
  });

  it("does not build a payload without an email account label", () => {
    expect(
      buildEnableServiceOAuthStartPayload({
        account: account({ label: "Personal Google" }),
        integration: calendar,
        organizationId: "org_123",
      }),
    ).toBeNull();
  });
});

describe("continueEnableServiceStep", () => {
  /** Drives the queue exactly like EnableServicesModalBody: `continueStep`
   *  mirrors handleContinue (Continue click), and step completion flows back
   *  through markActive, so the opener-call count is observable per click. */
  const harness = () => {
    let queue: EnableServiceQueue<EnableServiceIntegration> = createEnableServicesQueue([
      gmail,
      calendar,
    ]);
    const started: {
      readonly payload: OAuthStartPayload;
      readonly onSuccess: () => void;
      readonly onError: () => void;
    }[] = [];
    const markActive = (status: EnableServiceStepStatus) => {
      const active = activeEnableServiceStep(queue);
      if (active) queue = applyEnableServiceStepResult(queue, active.integration.slug, status);
    };
    const continueStep = () => {
      const active = activeEnableServiceStep(queue);
      if (!active) return;
      continueEnableServiceStep({
        account: account(),
        integration: active.integration,
        organizationId: "org_123",
        start: (input) => started.push(input),
        markActive,
      });
    };
    return {
      started,
      continueStep,
      queue: () => queue,
    };
  };

  it("opens exactly one popup per Continue click and never auto-chains on success", () => {
    const { started, continueStep, queue } = harness();

    continueStep();
    expect(started).toHaveLength(1);
    expect(started[0]?.payload.integration).toBe(gmail.slug);

    // The popup completes: the step is marked done and the queue advances,
    // but no second popup opens without a fresh Continue click.
    started[0]!.onSuccess();
    expect(queue().steps[0]?.status).toBe("done");
    expect(activeEnableServiceStep(queue())?.integration.slug).toBe(calendar.slug);
    expect(started).toHaveLength(1);

    continueStep();
    expect(started).toHaveLength(2);
    expect(started[1]?.payload.integration).toBe(calendar.slug);
  });

  it("does not auto-retry or auto-advance when a step fails", () => {
    const { started, continueStep, queue } = harness();

    continueStep();
    started[0]!.onError();
    expect(queue().steps[0]?.status).toBe("failed");
    expect(activeEnableServiceStep(queue())?.integration.slug).toBe(gmail.slug);
    expect(started).toHaveLength(1);
  });

  it("marks the step failed without opening a popup when no payload can be built", () => {
    const started: OAuthStartPayload[] = [];
    const statuses: EnableServiceStepStatus[] = [];
    continueEnableServiceStep({
      account: account({ label: "Personal Google" }),
      integration: calendar,
      organizationId: "org_123",
      start: (input) => started.push(input.payload),
      markActive: (status) => statuses.push(status),
    });
    expect(started).toHaveLength(0);
    expect(statuses).toEqual(["failed"]);
  });
});

describe("EnableServicesModal mount boundary", () => {
  // The wrapper renders nothing while closed, so the body (and with it the
  // useOAuthPopupFlow instance owning the in-flight popup) unmounts on close;
  // the hook's unmount effect cancels the session. The wrapper has no hooks,
  // so calling it as a plain function is safe here.
  const wrapperProps = {
    integrations: [gmail, calendar],
    onOpenChange: () => {},
  };

  it("renders nothing when closed, unmounting the body and its OAuth flow", () => {
    expect(EnableServicesModal({ ...wrapperProps, open: false, account: account() })).toBeNull();
  });

  it("renders nothing without an account", () => {
    expect(EnableServicesModal({ ...wrapperProps, open: true, account: null })).toBeNull();
  });

  it("mounts the body only while open with an account", () => {
    expect(EnableServicesModal({ ...wrapperProps, open: true, account: account() })).not.toBeNull();
  });
});