import { describe, expect, test } from "vitest";
import { defaultAppRoleSeeds, defaultPermissionSeedDescriptors } from "@toolctrl/db/permissions-seed.server";
import { missingReadinessEnv } from "./run-playwright-a11y.mjs";

import {
  E2E_READINESS_API_KEY_ALIAS,
  E2E_READINESS_API_LOG_ENDPOINT,
  E2E_READINESS_API_LOG_METHOD,
  E2E_READINESS_PLUGIN_ID,
  E2E_READINESS_PLUGIN_VERSION,
  E2E_READINESS_WEBHOOK_WORKFLOW_ID,
  E2E_READINESS_WAITING_EXECUTION_ID,
  E2E_READINESS_WAITING_MANUAL_BLOCK_EXECUTION_ID,
  E2E_READINESS_WAITING_WORKFLOW_ID,
  E2E_READINESS_WORKFLOW_EXECUTION_ID,
  E2E_READINESS_WORKFLOW_ID,
  E2E_READINESS_WORKFLOW_LOG_BLOCK_EXECUTION_ID,
  E2E_READINESS_WORKFLOW_OUTBOX_DRAIN_ASSERTION,
  E2E_READINESS_WORKFLOW_OUTBOX_DRAIN_BLOCKER,
  E2E_READINESS_LIFECYCLE_PLUGIN_ID,
  E2E_READINESS_LIFECYCLE_PLUGIN_VERSION,
  E2E_READINESS_NO_TENANT_EMAIL,
  E2E_READINESS_NO_TENANT_PASSWORD,
  E2E_READINESS_PLUGIN_READONLY_EMAIL,
  E2E_READINESS_PLUGIN_READONLY_PASSWORD,
  E2E_READINESS_PLUGIN_READONLY_ROLE_NAME,
  E2E_READINESS_SUBSCRIPTION_PLAN_STRIPE_ID,
  E2E_READINESS_SUBSCRIPTION_PRICE_STRIPE_ID,
  E2E_READINESS_TENANT_NAME,
  E2E_READINESS_TENANT_SLUG,
  E2E_READINESS_UPGRADE_PLAN_STRIPE_ID,
  E2E_READINESS_UPGRADE_PRICE_STRIPE_ID,
  E2E_READINESS_USER_EMAIL,
  E2E_READINESS_USER_PASSWORD,
  appFixturePath,
  assertCanRunE2eReadinessSeed,
  buildE2eReadinessEnv,
  buildE2eReadinessEmailSequenceDefinitions,
  buildE2eReadinessLifecyclePluginManifest,
  buildE2eReadinessManualWorkflowDefinition,
  buildE2eReadinessPluginManifest,
  buildE2eReadinessPluginSettingsHtml,
  buildE2eReadinessWaitingWorkflowDefinition,
  buildE2eReadinessWebhookWorkflowDefinition,
  renderE2eReadinessEnvFile,
} from "./seed-e2e-readiness";

describe("seed-e2e-readiness", () => {
  test("refuses production and requires an explicit local opt-in", () => {
    expect(() =>
      assertCanRunE2eReadinessSeed({
        DATABASE_URL: "postgresql://localhost/app",
        E2E_LOCAL_READINESS_SEED: "1",
        NODE_ENV: "production",
      })
    ).toThrow("production");

    expect(() =>
      assertCanRunE2eReadinessSeed({
        DATABASE_URL: "postgresql://localhost/app",
        NODE_ENV: "development",
      })
    ).toThrow("E2E_LOCAL_READINESS_SEED=1");

    expect(() =>
      assertCanRunE2eReadinessSeed({
        E2E_LOCAL_READINESS_SEED: "1",
        NODE_ENV: "development",
      })
    ).toThrow("DATABASE_URL");
  });

  test("builds the readiness env contract consumed by the Playwright gate", () => {
    const env = buildE2eReadinessEnv({
      tenantSlug: E2E_READINESS_TENANT_SLUG,
      workflowId: "wf_123",
      webhookWorkflowId: "wf_webhook_123",
      waitingWorkflowId: "wf_waiting_123",
      waitingExecutionId: "wfe_waiting_123",
      pluginBasePath: "/tmp/e2e-plugins",
    });

    expect(env).toMatchObject({
      E2E_TENANT_EMAIL: E2E_READINESS_USER_EMAIL,
      E2E_TENANT_PASSWORD: E2E_READINESS_USER_PASSWORD,
      E2E_NO_TENANT_EMAIL: E2E_READINESS_NO_TENANT_EMAIL,
      E2E_NO_TENANT_PASSWORD: E2E_READINESS_NO_TENANT_PASSWORD,
      E2E_PLUGIN_READONLY_EMAIL: E2E_READINESS_PLUGIN_READONLY_EMAIL,
      E2E_PLUGIN_READONLY_PASSWORD: E2E_READINESS_PLUGIN_READONLY_PASSWORD,
      E2E_TENANT_ACCOUNT_NAME: E2E_READINESS_TENANT_NAME,
      E2E_TENANT_ACCOUNT_SLUG: E2E_READINESS_TENANT_SLUG,
      E2E_REGISTRATION_EXPECTS_EMAIL_VERIFICATION: "0",
      E2E_TENANT_DASHBOARD_PATH: "/e2e-readiness/dashboard",
      E2E_TENANT_SETTINGS_ACCOUNT_PATH: "/e2e-readiness/settings/account",
      E2E_TENANT_SETTINGS_PROFILE_PATH: "/e2e-readiness/settings/profile",
      E2E_TENANT_SUBSCRIPTION_PATH: "/e2e-readiness/settings/subscription",
      E2E_TENANT_MEMBERS_PATH: "/e2e-readiness/settings/members",
      E2E_TENANT_ROLES_AND_PERMISSIONS_PATH: "/e2e-readiness/settings/roles-and-permissions",
      E2E_TENANT_NOTIFICATIONS_PATH: "/e2e-readiness/settings/notifications",
      E2E_TENANT_LOGS_PATH: "/e2e-readiness/settings/logs",
      E2E_TENANT_LOG_EVENTS_PATH: "/e2e-readiness/settings/logs/events",
      E2E_TENANT_AUDIT_EXPORT_PATH: "/e2e-readiness/settings/audit-export",
      E2E_TENANT_PRIVACY_PATH: "/e2e-readiness/settings/privacy",
      E2E_TENANT_CHATBOT_PATH: "/e2e-readiness/settings/chatbot",
      E2E_TENANT_AI_USAGE_PATH: "/e2e-readiness/settings/ai-usage",
      E2E_TENANT_API_PATH: "/e2e-readiness/settings/api",
      E2E_TENANT_API_KEYS_PATH: "/e2e-readiness/settings/api/keys",
      E2E_TENANT_API_DOCS_PATH: "/e2e-readiness/settings/api/docs",
      E2E_TENANT_API_LOGS_PATH: "/e2e-readiness/settings/api/logs",
      E2E_TENANT_POLICIES_PATH: "/e2e-readiness/settings/policies",
      E2E_ADMIN_EMAIL_SEQUENCES_PATH: "/email-sequences",
      E2E_PLUGIN_SETTINGS_PATH: "/e2e-readiness/settings/plugins",
      E2E_WORKFLOW_ENGINE_PATH: "/e2e-readiness/workflow-engine/workflows",
      E2E_WORKFLOW_BUILDER_PATH: "/e2e-readiness/workflow-engine/workflows/wf_123",
      E2E_WORKFLOW_RUN_API_PATH: "/e2e-readiness/workflow-engine/workflows/wf_123/run/api",
      E2E_WORKFLOW_RUN_MANUAL_PATH: "/e2e-readiness/workflow-engine/workflows/wf_123/run/manual",
      E2E_WORKFLOW_WEBHOOK_BUILDER_PATH: "/e2e-readiness/workflow-engine/workflows/wf_webhook_123",
      E2E_WORKFLOW_WEBHOOK_RUN_MANUAL_PATH: "/e2e-readiness/workflow-engine/workflows/wf_webhook_123/run/manual",
      E2E_WORKFLOW_WAITING_BUILDER_PATH: "/e2e-readiness/workflow-engine/workflows/wf_waiting_123",
      E2E_WORKFLOW_WAITING_RUN_MANUAL_PATH: "/e2e-readiness/workflow-engine/workflows/wf_waiting_123/run/manual",
      E2E_WORKFLOW_WAITING_RUN_API_PATH: "/e2e-readiness/workflow-engine/workflows/wf_waiting_123/run/api",
      E2E_WORKFLOW_WAITING_EXECUTIONS_PATH: "/e2e-readiness/workflow-engine/workflows/wf_waiting_123/executions",
      E2E_WORKFLOW_WAITING_EXECUTION_ID: "wfe_waiting_123",
      E2E_ALLOW_WORKFLOW_RUN: "1",
      E2E_ALLOW_WORKFLOW_WEBHOOK_RUN: "0",
      E2E_WORKFLOW_WEBHOOK_TARGET_URL: "",
      E2E_REQUIRE_WORKFLOW_OUTBOX_DRAIN: "0",
      E2E_WORKFLOW_OUTBOX_DRAIN_EXPECTED_STATUS: "success",
      E2E_WORKFLOW_OUTBOX_DRAIN_ASSERTION: "operator-gated",
      E2E_WORKFLOW_OUTBOX_DRAIN_BLOCKER:
        "Workflow outbox-drain readiness is operator-gated: set E2E_REQUIRE_WORKFLOW_OUTBOX_DRAIN=1 only when the general worker is running and the seeded manual workflow can reach the expected success execution status.",
      PLUGIN_BINARY_BASE_PATH: "/tmp/e2e-plugins",
    });

    expect(missingReadinessEnv({ env })).toEqual([]);
    expect(renderE2eReadinessEnvFile(env)).toContain('E2E_TENANT_EMAIL="e2e.readiness@example.test"');
    expect(renderE2eReadinessEnvFile(env)).toContain('E2E_NO_TENANT_EMAIL="e2e.no-tenant@example.test"');
    expect(renderE2eReadinessEnvFile(env)).toContain('E2E_NO_TENANT_PASSWORD="NoTenantPass123!"');
    expect(renderE2eReadinessEnvFile(env)).toContain('E2E_PLUGIN_READONLY_EMAIL="e2e.plugin-readonly@example.test"');
    expect(renderE2eReadinessEnvFile(env)).toContain('E2E_PLUGIN_READONLY_PASSWORD="PluginReadOnlyPass123!"');
    expect(renderE2eReadinessEnvFile(env)).toContain('E2E_REGISTRATION_EXPECTS_EMAIL_VERIFICATION="0"');
    expect(renderE2eReadinessEnvFile(env)).toContain('E2E_TENANT_SETTINGS_ACCOUNT_PATH="/e2e-readiness/settings/account"');
    expect(renderE2eReadinessEnvFile(env)).toContain('E2E_TENANT_MEMBERS_PATH="/e2e-readiness/settings/members"');
    expect(renderE2eReadinessEnvFile(env)).toContain('E2E_TENANT_PRIVACY_PATH="/e2e-readiness/settings/privacy"');
    expect(renderE2eReadinessEnvFile(env)).toContain('E2E_TENANT_AI_USAGE_PATH="/e2e-readiness/settings/ai-usage"');
    expect(renderE2eReadinessEnvFile(env)).toContain('E2E_TENANT_API_LOGS_PATH="/e2e-readiness/settings/api/logs"');
    expect(renderE2eReadinessEnvFile(env)).toContain('E2E_ADMIN_EMAIL_SEQUENCES_PATH="/email-sequences"');
    expect(renderE2eReadinessEnvFile(env)).toContain('E2E_ALLOW_WORKFLOW_WEBHOOK_RUN="0"');
    expect(renderE2eReadinessEnvFile(env)).toContain('E2E_WORKFLOW_WEBHOOK_TARGET_URL=""');
    expect(renderE2eReadinessEnvFile(env)).toContain('E2E_WORKFLOW_WAITING_EXECUTIONS_PATH="/e2e-readiness/workflow-engine/workflows/wf_waiting_123/executions"');
    expect(renderE2eReadinessEnvFile(env)).toContain('E2E_WORKFLOW_WAITING_EXECUTION_ID="wfe_waiting_123"');
    expect(renderE2eReadinessEnvFile(env)).toContain('E2E_REQUIRE_WORKFLOW_OUTBOX_DRAIN="0"');
    expect(renderE2eReadinessEnvFile(env)).toContain('E2E_WORKFLOW_OUTBOX_DRAIN_EXPECTED_STATUS="success"');
    expect(renderE2eReadinessEnvFile(env)).toContain('E2E_WORKFLOW_OUTBOX_DRAIN_ASSERTION="operator-gated"');
  });

  test("documents workflow outbox-drain readiness as an operator-gated expected-success probe", () => {
    expect(E2E_READINESS_WORKFLOW_OUTBOX_DRAIN_ASSERTION).toBe("operator-gated");
    expect(E2E_READINESS_WORKFLOW_OUTBOX_DRAIN_BLOCKER).toBe(
      "Workflow outbox-drain readiness is operator-gated: set E2E_REQUIRE_WORKFLOW_OUTBOX_DRAIN=1 only when the general worker is running and the seeded manual workflow can reach the expected success execution status."
    );
  });

  test("defines deterministic API key and log fixture identifiers", () => {
    expect(E2E_READINESS_API_KEY_ALIAS).toBe("E2E Readiness API Key");
    expect(E2E_READINESS_API_LOG_ENDPOINT).toBe("/v1/e2e-readiness");
    expect(E2E_READINESS_API_LOG_METHOD).toBe("GET");
  });

  test("defines separate owned and unowned subscription fixtures for billing smokes", () => {
    expect(E2E_READINESS_SUBSCRIPTION_PLAN_STRIPE_ID).toBe("e2e_readiness_plan");
    expect(E2E_READINESS_SUBSCRIPTION_PRICE_STRIPE_ID).toBe("e2e_readiness_price_monthly");
    expect(E2E_READINESS_UPGRADE_PLAN_STRIPE_ID).toBe("e2e_readiness_upgrade_plan");
    expect(E2E_READINESS_UPGRADE_PRICE_STRIPE_ID).toBe("e2e_readiness_upgrade_price_monthly");
  });

  test("keeps the plugin read-only fixture on the default User app role contract", () => {
    expect(E2E_READINESS_PLUGIN_READONLY_EMAIL).toBe("e2e.plugin-readonly@example.test");
    expect(E2E_READINESS_PLUGIN_READONLY_PASSWORD).toBe("PluginReadOnlyPass123!");
    expect(E2E_READINESS_PLUGIN_READONLY_ROLE_NAME).toBe("User");
    expect(defaultAppRoleSeeds.find((role) => role.name === E2E_READINESS_PLUGIN_READONLY_ROLE_NAME)).toMatchObject({
      type: "app",
      assignToNewUsers: true,
    });

    expect(defaultPermissionSeedDescriptors.find((permission) => permission.name === "app.plugins.use")?.inRoles).toContain(
      E2E_READINESS_PLUGIN_READONLY_ROLE_NAME
    );
    expect(defaultPermissionSeedDescriptors.find((permission) => permission.name === "app.plugins.manage")?.inRoles).not.toContain(
      E2E_READINESS_PLUGIN_READONLY_ROLE_NAME
    );
  });

  test("keeps the plugin fixture shaped for consent, revoke, and iframe settings coverage", () => {
    const manifest = buildE2eReadinessPluginManifest();

    expect(manifest.id).toBe(E2E_READINESS_PLUGIN_ID);
    expect(manifest.version).toBe(E2E_READINESS_PLUGIN_VERSION);
    expect(manifest.capabilities.map((capability) => capability.name)).toEqual(["log", "audit"]);
    expect(manifest.hooks).toEqual([{ name: "workflow.executed", export: "onWorkflowExecuted" }]);
    expect(manifest.ui?.settings?.entry).toBe("settings/index.html");
    expect(manifest.ui?.settings?.sha256).toMatch(/^[a-f0-9]{64}$/u);
  });

  test("keeps the plugin settings HTML compatible with the hardened iframe protocol", () => {
    const html = buildE2eReadinessPluginSettingsHtml();

    expect(html).toContain('meta[name="plugin-id"]');
    expect(html).toContain('meta[name="plugin-settings-channel"]');
    expect(html).toContain('meta[name="plugin-settings-protocol"]');
    expect(html).toContain("parent.postMessage");
    expect(html).toContain("type: 'plugin.settings.set'");
    expect(html).toContain("version: protocolVersion");
    expect(html).toContain("pluginId: pluginId");
    expect(html).toContain("channelId: channelId");
    expect(html).toContain("requestId: 'seed-fixture-save'");
    expect(html).toContain("key: 'theme'");
    expect(html).toContain("value: 'ready'");
    expect(html).toContain("<script>");
    expect(html).not.toContain("onclick=");
  });

  test("keeps a separate plugin fixture for real lifecycle persistence coverage", () => {
    const manifest = buildE2eReadinessLifecyclePluginManifest();

    expect(manifest.id).toBe(E2E_READINESS_LIFECYCLE_PLUGIN_ID);
    expect(manifest.version).toBe(E2E_READINESS_LIFECYCLE_PLUGIN_VERSION);
    expect(manifest.capabilities.map((capability) => capability.name)).toEqual(["log", "audit"]);
    expect(manifest.hooks).toEqual([{ name: "workflow.executed", export: "onWorkflowExecuted" }]);
    expect(manifest.ui?.settings).toBeUndefined();
  });

  test("defines deterministic workflow graph fixtures for log-only and webhook readiness", () => {
    expect(E2E_READINESS_WORKFLOW_EXECUTION_ID).toBe("wfe_123");
    expect(E2E_READINESS_WORKFLOW_LOG_BLOCK_EXECUTION_ID).toBe("wfbe_log_123");

    expect(buildE2eReadinessManualWorkflowDefinition()).toMatchObject({
      id: E2E_READINESS_WORKFLOW_ID,
      blocks: [
        { key: "manual", type: "manual", isTrigger: true, isBlock: false, input: {} },
        { key: "log", type: "log", isTrigger: false, isBlock: true, input: { message: "E2E readiness {{$params.message}}" } },
      ],
      edges: [{ from: "manual", to: "log" }],
      inputExample: { title: "Readiness payload", input: { message: "ready" } },
    });

    expect(buildE2eReadinessWebhookWorkflowDefinition()).toMatchObject({
      id: E2E_READINESS_WEBHOOK_WORKFLOW_ID,
      blocks: [
        { key: "manual", type: "manual", isTrigger: true, isBlock: false, input: {} },
        {
          key: "httpRequest",
          type: "httpRequest",
          isTrigger: false,
          isBlock: true,
          input: {
            url: "{{$params.webhookUrl}}",
            method: "POST",
            headers: { "content-type": "application/json" },
            body: '{"message":"{{$params.message}}"}',
            throwsError: true,
          },
        },
        { key: "log", type: "log", isTrigger: false, isBlock: true, input: { message: "Webhook readiness status {{$httpRequest.statusCode}}" } },
      ],
      edges: [
        { from: "manual", to: "httpRequest" },
        { from: "httpRequest", to: "log" },
      ],
      inputExample: {
        title: "Webhook readiness payload",
        input: { webhookUrl: "http://127.0.0.1:1/e2e-readiness-webhook", message: "ready" },
      },
    });

    expect(E2E_READINESS_WAITING_WORKFLOW_ID).toBe("wf_waiting_123");
    expect(E2E_READINESS_WAITING_EXECUTION_ID).toBe("wfe_waiting_123");
    expect(E2E_READINESS_WAITING_MANUAL_BLOCK_EXECUTION_ID).toBe("wfbe_waiting_manual_123");
    expect(buildE2eReadinessWaitingWorkflowDefinition()).toMatchObject({
      id: E2E_READINESS_WAITING_WORKFLOW_ID,
      blocks: [
        { key: "manual", type: "manual", isTrigger: true, isBlock: false, input: {} },
        {
          key: "wait",
          type: "waitForInput",
          isTrigger: false,
          isBlock: true,
          input: { title: "E2E approval", placeholder: "Type approval" },
        },
        {
          key: "variable",
          type: "variable",
          isTrigger: false,
          isBlock: true,
          input: { variableName: "approvalMessage", value: "approved {{waitForInput.input.approved}}" },
        },
        { key: "log", type: "log", isTrigger: false, isBlock: true, input: { message: "continued {{$vars.approvalMessage}}" } },
      ],
      edges: [
        { from: "manual", to: "wait" },
        { from: "wait", to: "variable" },
        { from: "variable", to: "log" },
      ],
      inputExample: { title: "Waiting readiness payload", input: { input: { approved: false } } },
    });
  });

  test("defines deterministic email sequence fixtures for admin and trigger readiness", () => {
    const sequences = buildE2eReadinessEmailSequenceDefinitions("tenant_123");

    expect(sequences).toHaveLength(4);
    expect(sequences.map((sequence) => sequence.id)).toEqual([
      "seq_e2e_welcome",
      "seq_e2e_trial_expiring",
      "seq_e2e_stale_lead",
      "seq_e2e_customer_welcome",
    ]);
    expect(sequences.map((sequence) => sequence.triggerEvent)).toEqual([
      "tenant.signup",
      "tenant.trial_expiring",
      "lead.stale_60d",
      "lead.converted_to_customer",
    ]);
    expect(sequences.every((sequence) => sequence.tenantId === "tenant_123")).toBe(true);
    expect(sequences.every((sequence) => sequence.isEnabled)).toBe(true);
    expect(sequences.every((sequence) => sequence.steps.length === 1)).toBe(true);
    expect(sequences.map((sequence) => sequence.steps[0]?.template)).toEqual([
      "welcome",
      "trial-reminder",
      "re-activation",
      "generic-step",
    ]);
  });

  test("normalizes app fixture paths without host assumptions", () => {
    expect(appFixturePath("acme", "dashboard")).toBe("/acme/dashboard");
    expect(appFixturePath("acme", "/settings/subscription")).toBe("/acme/settings/subscription");
  });
});