import { HttpApiBuilder } from "effect/unstable/httpapi";
import { Effect } from "effect";
import { Schema } from "effect";

import { ExecutorApi } from "../api";
import { formatExecuteResult, formatPausedExecution } from "@executor-js/execution";
import { resolveArtifactAction } from "@executor-js/host-mcp/artifact-action";
import { TOOL_CALL_CONTRACT_MESSAGE } from "@executor-js/host-mcp/tool-call-code";
import { PENDING_APPROVAL_TTL_MS } from "@executor-js/sdk";
import { ExecutionEngineService, ExecutorService } from "../services";
import { capture, captureEngineError } from "@executor-js/api";

class ExecutionNotFoundError extends Schema.TaggedErrorClass<ExecutionNotFoundError>()(
  "ExecutionNotFoundError",
  {
    executionId: Schema.String,
  },
) {}

/**
 * An artifact-originated execution that could not be resolved into a call.
 *
 * Carries the same vocabulary the MCP host's `execute-action` returns
 * (`invalid_action_code`, `artifact_unavailable`, `binding_unresolved`) so the
 * shell sees one contract whichever transport it reached the server through,
 * and the binding UI that ships with sharing can key off `role`/`integration`.
 */
class ArtifactActionError extends Schema.TaggedErrorClass<ArtifactActionError>()(
  "ArtifactActionError",
  {
    error: Schema.Literals(["invalid_action_code", "artifact_unavailable", "binding_unresolved"]),
    reason: Schema.String,
    role: Schema.optional(Schema.String),
    integration: Schema.optional(Schema.String),
  },
  { httpApiStatus: 400 },
) {
  override get message(): string {
    return this.reason;
  }
}

/**
 * An approval that expired before the human answered.
 *
 * Distinct from `ExecutionNotFoundError` (an id that was never ours) so the
 * shell can tell the user their approval window closed and the action can simply
 * be triggered again — nothing ran. 410 Gone, because the resource existed and
 * deliberately no longer does.
 */
class ApprovalExpiredError extends Schema.TaggedErrorClass<ApprovalExpiredError>()(
  "ApprovalExpiredError",
  {
    executionId: Schema.String,
  },
  { httpApiStatus: 410 },
) {
  override get message(): string {
    return "This approval expired. Trigger the action again.";
  }
}

/**
 * Parse and bind one artifact-originated call, or fail with something the shell
 * can render inside the component that made it.
 *
 * The artifact is read through the request's own scoped executor, so an id that
 * isn't this caller's simply doesn't resolve.
 */
const resolveArtifactCode = (
  code: string,
  artifactId: string,
): Effect.Effect<string, ArtifactActionError, ExecutorService> =>
  Effect.gen(function* () {
    const executor = yield* ExecutorService;
    const resolution = yield* resolveArtifactAction({
      code,
      artifactId,
      loadArtifact: (id) =>
        executor.artifacts.get(id).pipe(Effect.catchCause(() => Effect.succeed(null))),
    });

    if (resolution.status === "ok") return resolution.code;
    if (resolution.status === "binding_unresolved") {
      return yield* new ArtifactActionError({
        error: "binding_unresolved",
        reason: resolution.message,
        role: resolution.role,
        integration: resolution.integration,
      });
    }
    return yield* new ArtifactActionError({
      error: resolution.status,
      reason:
        resolution.status === "artifact_unavailable"
          ? "This action refers to an artifact that isn't available on this account."
          : TOOL_CALL_CONTRACT_MESSAGE,
    });
  });

/**
 * Record a paused artifact call so a later request can honour the approval.
 *
 * Best-effort by design: the in-memory pause is still live and still the fast
 * path, so a storage hiccup here must not turn a working approval into a failed
 * execution. It degrades to exactly the behaviour we had before this record
 * existed.
 */
const recordPendingApproval = (approval: {
  readonly executionId: string;
  readonly artifactId: string;
  readonly code: string;
  readonly address: string;
}): Effect.Effect<void, never, ExecutorService> =>
  Effect.gen(function* () {
    const executor = yield* ExecutorService;
    yield* executor.pendingApprovals
      .put({ ...approval, expiresAt: Date.now() + PENDING_APPROVAL_TTL_MS })
      .pipe(Effect.catchCause(() => Effect.void));
  });

/**
 * Honour an approval whose paused fiber is no longer reachable.
 *
 * The record is read through the caller's OWN scoped executor, so an execution
 * id that is not this caller's reads as absent — the same-query ownership rule
 * the artifact path already uses. It is consumed on read, so one approval
 * authorizes exactly one invocation.
 *
 * A non-accept answer discards the record and reports the decline, which is the
 * same observable outcome as declining a live pause: nothing runs.
 */
const resumeFromPendingApproval = (executionId: string, action: "accept" | "decline" | "cancel") =>
  Effect.gen(function* () {
    const executor = yield* ExecutorService;
    const engine = yield* ExecutionEngineService;

    const approval = yield* executor.pendingApprovals
      .consume(executionId)
      .pipe(Effect.catchCause(() => Effect.succeed(null)));
    if (!approval) return null;

    if (action !== "accept") {
      return {
        status: "completed" as const,
        text: `Approval ${action === "decline" ? "declined" : "cancelled"}. Nothing ran.`,
        structured: { status: "declined", executionId, address: approval.address },
        isError: false,
      };
    }

    // The human approved, so run the recorded call with the gate satisfied.
    // `code` is the address the server itself resolved at pause time, so this
    // runs exactly the call that was described in the approval prompt.
    const outcome = yield* captureEngineError(
      engine.executeWithPause(approval.code, { autoApprove: true }),
    );

    if (outcome.status === "completed") {
      const formatted = formatExecuteResult(outcome.result);
      return {
        status: "completed" as const,
        text: formatted.text,
        structured: formatted.structured,
        isError: formatted.isError,
      };
    }

    // `autoApprove` accepts every gate inline, so a second pause is not
    // reachable here; surface it rather than silently dropping the call.
    const formatted = formatPausedExecution(outcome.execution);
    return {
      status: "paused" as const,
      text: formatted.text,
      structured: formatted.structured,
    };
  });

export const ExecutionsHandlers = HttpApiBuilder.group(ExecutorApi, "executions", (handlers) =>
  handlers
    .handle("getPaused", ({ params: path }) =>
      capture(
        Effect.gen(function* () {
          const engine = yield* ExecutionEngineService;
          const paused = yield* captureEngineError(engine.getPausedExecution(path.executionId));

          if (!paused) {
            return yield* new ExecutionNotFoundError({ executionId: path.executionId });
          }

          return formatPausedExecution(paused);
        }),
      ),
    )
    .handle("execute", ({ payload }) =>
      capture(
        Effect.gen(function* () {
          const engine = yield* ExecutionEngineService;
          // An artifact-originated request is not arbitrary code. It is parsed
          // against the shell proxy's one grammar and rewritten through the
          // artifact's connection bindings, exactly as `execute-action` does in
          // the MCP host — the console's artifact page must not be a wider door
          // onto the same iframe.
          const code =
            payload.artifactId === undefined
              ? payload.code
              : yield* resolveArtifactCode(payload.code, payload.artifactId);
          const outcome = yield* captureEngineError(
            engine.executeWithPause(code, { autoApprove: payload.autoApprove }),
          );

          if (outcome.status === "completed") {
            const formatted = formatExecuteResult(outcome.result);
            return {
              status: "completed" as const,
              text: formatted.text,
              structured: formatted.structured,
              isError: formatted.isError,
            };
          }

          // The pause is a live fiber in THIS engine, which on a host that
          // builds an engine per request is gone the moment this response is
          // written. Record the resolved call so the approval can be honoured by
          // whichever instance serves the resume. Artifact calls only: a general
          // codemode pause can sit anywhere inside arbitrary code and is not
          // reconstructible from one address.
          if (payload.artifactId !== undefined) {
            yield* recordPendingApproval({
              executionId: outcome.execution.id,
              artifactId: payload.artifactId,
              code,
              address: String(outcome.execution.elicitationContext.address),
            });
          }

          const formatted = formatPausedExecution(outcome.execution);
          return {
            status: "paused" as const,
            text: formatted.text,
            structured: formatted.structured,
          };
        }),
      ),
    )
    .handle("resume", ({ params: path, payload }) =>
      capture(
        Effect.gen(function* () {
          const engine = yield* ExecutionEngineService;
          const result = yield* captureEngineError(
            engine.resume(path.executionId, {
              action: payload.action,
              content: payload.content as Record<string, unknown> | undefined,
              ...(payload.persist === undefined ? {} : { meta: { persist: payload.persist } }),
            }),
          );

          // No live pause: either this resume landed on a different engine
          // instance than the pause did (the normal case on a host that builds
          // an engine per request), or the window really has closed.
          if (!result) {
            const honoured = yield* resumeFromPendingApproval(path.executionId, payload.action);
            if (honoured) return honoured;
            return yield* new ApprovalExpiredError({ executionId: path.executionId });
          }

          if (result.status === "completed") {
            const formatted = formatExecuteResult(result.result);
            return {
              status: "completed" as const,
              text: formatted.text,
              structured: formatted.structured,
              isError: formatted.isError,
            };
          }

          const formatted = formatPausedExecution(result.execution);
          return {
            status: "paused" as const,
            text: formatted.text,
            structured: formatted.structured,
          };
        }),
      ),
    ),
);