import { Schema } from "effect";
import type {
  NodeSpecCapabilitySummary,
  StepInputBinding,
  WorkflowOperationName,
  WrapperArtifactCapabilitySummary,
} from "./generated/workflow-contract.js";
import {
  WorkflowHealthResultSchema,
  WorkflowSourcesListPayloadSchema,
  WorkflowSourcesListResultSchema,
  WorkflowCapabilitiesListPayloadSchema,
  WorkflowCapabilitiesListResultSchema,
  WorkflowCapabilitiesInspectPayloadSchema,
  WorkflowCapabilitiesInspectResultSchema,
  WorkflowCapabilitiesCallPayloadSchema,
  WorkflowCapabilitiesCallResultSchema,
  WorkflowDraftWorkspacesListResultSchema,
  WorkflowDraftWorkspacesGetPayloadSchema,
  WorkflowDraftWorkspacesGetResultSchema,
  WorkflowDraftWorkspacesCreateEmptyPayloadSchema,
  WorkflowDraftWorkspacesCreateEmptyResultSchema,
  WorkflowDraftWorkspacesCreateFromCapabilityPayloadSchema,
  WorkflowDraftWorkspacesCreateFromCapabilityResultSchema,
  WorkflowDraftWorkspacesAddStepFromCapabilityPayloadSchema,
  WorkflowDraftWorkspacesAddStepFromCapabilityResultSchema,
  WorkflowDraftWorkspacesUpdateCapabilityStepPayloadSchema,
  WorkflowDraftWorkspacesUpdateCapabilityStepResultSchema,
  WorkflowDraftWorkspacesSetRoutePayloadSchema,
  WorkflowDraftWorkspacesSetRouteResultSchema,
  WorkflowDraftWorkspacesSetStepInputBindingsPayloadSchema,
  WorkflowDraftWorkspacesSetStepInputBindingsResultSchema,
  WorkflowDraftWorkspacesSetStepOutputBindingsPayloadSchema,
  WorkflowDraftWorkspacesSetStepOutputBindingsResultSchema,
  WorkflowDraftWorkspacesValidatePayloadSchema,
  WorkflowDraftWorkspacesValidateResultSchema,
  WorkflowArtifactsListPayloadSchema,
  WorkflowArtifactsListResultSchema,
  WorkflowArtifactsInspectPayloadSchema,
  WorkflowArtifactsInspectResultSchema,
  WorkflowDeploymentsListResultSchema,
  WorkflowDeploymentsInspectPayloadSchema,
  WorkflowDeploymentsInspectResultSchema,
  WorkflowDeploymentsValidatePayloadSchema,
  WorkflowDeploymentsValidateResultSchema,
  WorkflowRunsListPayloadSchema,
  WorkflowRunsListResultSchema,
  WorkflowRunsInspectPayloadSchema,
  WorkflowRunsInspectResultSchema,
  WorkflowRunsStartPayloadSchema,
  WorkflowRunsStartResultSchema,
  WorkflowRunsResumePayloadSchema,
  WorkflowRunsResumeResultSchema,
  WorkflowRunsTracePayloadSchema,
  WorkflowRunsTraceResultSchema,
} from "./rpcs.js";

export type OperationMeta = {
  readonly method: WorkflowOperationName;
  readonly label: string;
  readonly explanation: string;
  readonly idempotency: "read" | "write";
  readonly equivalentCli: (params: unknown) => string;
  readonly interpret: (result: unknown) => unknown;
};

export type WorkflowHealthInterpreted = {
  readonly status: "ok";
  readonly storeRoot: string;
};

export type WorkflowSourcesListInterpreted = {
  readonly sources: ReadonlyArray<{
    readonly id: string;
    readonly kind: string;
    readonly enabled: boolean;
    readonly description: string | null;
    readonly counts: {
      readonly tools: number;
      readonly nodeSpecs: number;
      readonly reducers: number;
      readonly prompts: number;
      readonly resources: number;
    };
  }>;
  readonly nextCursor: string | null;
  readonly total: number;
};

export type CapabilitySummaryInterpreted = {
  readonly kind: "node_spec" | "wrapper_artifact";
  readonly name: string;
  readonly sourceId: string;
  readonly description: string | null;
  readonly outcomes: ReadonlyArray<string>;
  readonly isAsync: boolean;
  readonly inputFields: ReadonlyArray<string>;
  readonly outputFields: ReadonlyArray<string>;
  readonly artifactId?: string;
  readonly version?: number;
  readonly title?: string;
};

export type CapabilityCallInterpreted = {
  readonly qualifiedName: string;
  readonly sourceId: string;
  readonly kind: "node_spec" | "wrapper_artifact";
  readonly deploymentId: string | null;
  readonly outcome: string;
  readonly output: Record<string, unknown> | null;
  readonly diagnostics: ReadonlyArray<{
    readonly boundSource: string | null;
    readonly code: string;
    readonly logicalRef: string;
    readonly message: string;
    readonly repairHint: string | null;
    readonly severity: string;
  }>;
};

export type DraftWorkspaceInterpreted = {
  readonly workspaceId: string;
  readonly revision: number;
  readonly title: string | null;
  readonly status: "valid" | "invalid" | "conflict";
  readonly diagnostics: ReadonlyArray<{
    readonly code: string;
    readonly path: string;
    readonly message: string;
    readonly stepId: string | null;
    readonly repairHint: string | null;
    readonly details: Readonly<Record<string, unknown>>;
  }>;
  readonly summary: {
    readonly name: unknown;
    readonly start: unknown;
    readonly stepCount: number;
    readonly routeCount: number;
    readonly steps: ReadonlyArray<string>;
  };
  readonly draft: Readonly<Record<string, unknown>> | null;
};

const interpretNextActions = (nextActions: {
  readonly can_continue: boolean;
  readonly can_save_now: boolean | null;
  readonly recommended_next_tool: string | null;
  readonly reason: string;
  readonly patch_examples: ReadonlyArray<unknown>;
  readonly warnings: ReadonlyArray<string>;
}) => ({
  canContinue: nextActions.can_continue,
  canSaveNow: nextActions.can_save_now,
  recommendedNextTool: nextActions.recommended_next_tool,
  reason: nextActions.reason,
  patchExamples: nextActions.patch_examples,
  warnings: nextActions.warnings,
});

const shellArg = (value: string | number): string => {
  const text = String(value);
  return /^[A-Za-z0-9._/@=:-]+$/.test(text)
    ? text
    : `'${text.replace(/'/g, "'\\''")}'`;
};
const nonEquivalentCli = (
  command: string,
  fields: readonly string[],
): string =>
  fields.length === 0
    ? command
    : `${command} [non-equivalent: unavailable CLI representation for ${fields.join(", ")}]`;

const isRecord = (value: unknown): value is Record<string, unknown> =>
  typeof value === "object" && value !== null && !Array.isArray(value);

const inputBindingCliArgs = (
  bindings: readonly StepInputBinding[],
  pathFlag: "--input" | "--map" = "--input",
): { readonly args: readonly string[]; readonly unavailable: readonly string[] } => {
  const args: string[] = [];
  const unavailable: string[] = [];
  for (const binding of bindings) {
    if (typeof binding.target !== "string") {
      unavailable.push("input_bindings (use --bindings-file)");
      continue;
    }
    if ("path" in binding) {
      if (typeof binding.path !== "string") {
        unavailable.push("input_bindings (use --bindings-file)");
        continue;
      }
      args.push(pathFlag, shellArg(`${binding.path}=${binding.target}`));
      continue;
    }
    if ("value" in binding) {
      const serialized = JSON.stringify(binding.value);
      if (serialized !== undefined) {
        args.push("--value", shellArg(`${binding.target}=${serialized}`));
      } else {
        unavailable.push("input_bindings (use --bindings-file)");
      }
      continue;
    }
    if ("expression" in binding) {
      // Composite expressions have no lossless inline CLI equivalent.
      unavailable.push("input_bindings (use --bindings-file)");
      continue;
    }
    const exhaustive: never = binding;
    void exhaustive;
    unavailable.push("input_bindings (use --bindings-file)");
  }
  return { args, unavailable };
};

const outputBindingCliArgs = (
  bindings: readonly unknown[],
): { readonly args: readonly string[]; readonly unavailable: readonly string[] } => {
  const args: string[] = [];
  const unavailable: string[] = [];
  for (const binding of bindings) {
    if (
      !isRecord(binding) ||
      typeof binding.source !== "string" ||
      typeof binding.target !== "string"
    ) {
      unavailable.push("output_bindings (use --bindings-file)");
      continue;
    }
    args.push("--map", shellArg(`${binding.source}=${binding.target}`));
  }
  return { args, unavailable };
};

const interpretCapabilitySummary = (
  capability: NodeSpecCapabilitySummary | WrapperArtifactCapabilitySummary,
): CapabilitySummaryInterpreted => {
  const interpreted = {
    kind: capability.kind,
    name: capability.name,
    sourceId: capability.source_id,
    description: capability.description,
    outcomes: capability.outcomes,
    isAsync: capability.is_async,
    inputFields: capability.input_fields,
    outputFields: capability.output_fields,
  };
  if (capability.kind === "wrapper_artifact") {
    return {
      ...interpreted,
      artifactId: capability.artifact_id,
      version: capability.version,
      title: capability.title,
    };
  }
  return interpreted;
};

const interpretDraftWorkspace = (decoded: {
  readonly diagnostics: ReadonlyArray<{
    readonly code: string;
    readonly details?: Record<string, unknown>;
    readonly message: string;
    readonly path: string;
    readonly repair_hint?: string | null;
    readonly step_id?: string | null;
  }>;
  readonly draft?: Record<string, unknown>;
  readonly revision: number;
  readonly status: "valid" | "invalid" | "conflict";
  readonly summary: {
    readonly name: unknown;
    readonly route_count: number;
    readonly start: unknown;
    readonly step_count: number;
    readonly steps: ReadonlyArray<string>;
  };
  readonly title: string | null;
  readonly workspace_id: string;
}): DraftWorkspaceInterpreted => ({
  workspaceId: decoded.workspace_id,
  revision: decoded.revision,
  title: decoded.title,
  status: decoded.status,
  diagnostics: decoded.diagnostics.map((diagnostic) => ({
    code: diagnostic.code,
    path: diagnostic.path,
    message: diagnostic.message,
    stepId: diagnostic.step_id ?? null,
    repairHint: diagnostic.repair_hint ?? null,
    details: diagnostic.details ?? {},
  })),
  summary: {
    name: decoded.summary.name,
    start: decoded.summary.start,
    stepCount: decoded.summary.step_count,
    routeCount: decoded.summary.route_count,
    steps: decoded.summary.steps,
  },
  draft: decoded.draft ?? null,
});

/** Adapts a snake_case run detail from the server into camelCase for the browser. */
const interpretRunDetail = (decoded: {
  readonly run_id: string | null;
  readonly deployment_id: string;
  readonly artifact_id: string;
  readonly artifact_version: number;
  readonly status: string;
  readonly resume_readiness: string | null;
  readonly interrupt: unknown;
  readonly outcome: string | null;
  readonly error: string | null;
  readonly output: Record<string, unknown> | null;
  readonly diagnostics: ReadonlyArray<unknown>;
  readonly trace_count: number;
  readonly next_actions: Parameters<typeof interpretNextActions>[0];
}) => ({
  runId: decoded.run_id,
  deploymentId: decoded.deployment_id,
  artifactId: decoded.artifact_id,
  artifactVersion: decoded.artifact_version,
  status: decoded.status,
  resumeReadiness: decoded.resume_readiness,
  interrupt: decoded.interrupt,
  outcome: decoded.outcome,
  error: decoded.error,
  output: decoded.output,
  diagnostics: decoded.diagnostics,
  traceCount: decoded.trace_count,
  nextActions: interpretNextActions(decoded.next_actions),
});

const defineOperationEntries = <
  const Entries extends ReadonlyArray<OperationMeta>,
>(entries: Entries): Entries => entries;

const operationEntries = defineOperationEntries([
  {
    method: "workflow.health",
    label: "Health check",
    explanation: "Check if the workflow server is running",
    idempotency: "read",
    equivalentCli: () => "uv run wf status",
    interpret: (result): WorkflowHealthInterpreted => {
      const decoded = Schema.decodeUnknownSync(WorkflowHealthResultSchema)(result);
      return { status: decoded.status, storeRoot: decoded.store_root };
    },
  },
  {
    method: "workflow.sources.list",
    label: "List sources",
    explanation: "List registered data sources with pagination",
    idempotency: "read",
    equivalentCli: (params) => {
      const p = Schema.decodeUnknownSync(WorkflowSourcesListPayloadSchema)(
        params,
        { onExcessProperty: "error" },
      );
      const parts = ["uv run wf source list"];
      if (p.limit != null) parts.push(`--limit ${p.limit}`);
      if (p.cursor != null) parts.push(`--cursor ${shellArg(p.cursor)}`);
      return parts.join(" ");
    },
    interpret: (result): WorkflowSourcesListInterpreted => {
      const decoded = Schema.decodeUnknownSync(
        WorkflowSourcesListResultSchema,
      )(result);
      return {
        sources: decoded.sources.map((source) => ({
          id: source.id,
          kind: source.kind,
          enabled: source.enabled,
          description: source.description,
          counts: {
            tools: source.tool_count,
            nodeSpecs: source.node_spec_count,
            reducers: source.reducer_count,
            prompts: source.prompt_count,
            resources: source.resource_count,
          },
        })),
        nextCursor: decoded.next_cursor,
        total: decoded.total,
      };
    },
  },
  {
    method: "workflow.capabilities.list",
    label: "List capabilities",
    explanation: "List workflow-authorable capabilities with pagination",
    idempotency: "read",
    equivalentCli: (params) => {
      const p = Schema.decodeUnknownSync(WorkflowCapabilitiesListPayloadSchema)(
        params,
        { onExcessProperty: "error" },
      );
      const parts = ["uv run wf cap list"];
      if (p.query != null) parts.push(`--query ${shellArg(p.query)}`);
      if (p.source_id != null) parts.push(`--source ${shellArg(p.source_id)}`);
      if (p.cursor != null) parts.push(`--cursor ${shellArg(p.cursor)}`);
      if (p.limit != null) parts.push(`--limit ${p.limit}`);
      return parts.join(" ");
    },
    interpret: (result) => {
      const decoded = Schema.decodeUnknownSync(
        WorkflowCapabilitiesListResultSchema,
      )(result);
      return {
        capabilities: decoded.capabilities.map(interpretCapabilitySummary),
        nextCursor: decoded.next_cursor,
        total: decoded.total,
      };
    },
  },
  {
    method: "workflow.capabilities.inspect",
    label: "Inspect capability",
    explanation: "Inspect one workflow-authorable capability",
    idempotency: "read",
    equivalentCli: (params) => {
      const p = Schema.decodeUnknownSync(
        WorkflowCapabilitiesInspectPayloadSchema,
      )(params, { onExcessProperty: "error" });
      return `uv run wf cap inspect ${shellArg(p.qualified_name)}`;
    },
    interpret: (result) => {
      const decoded = Schema.decodeUnknownSync(
        WorkflowCapabilitiesInspectResultSchema,
      )(result);
      const base = {
        kind: decoded.kind,
        name: decoded.name,
        sourceId: decoded.source_id,
        description: decoded.description,
        isAsync: decoded.is_async,
        outcomes: decoded.outcomes,
        inputSchema: decoded.input_schema,
        outputSchema: decoded.output_schema,
        wrapperHints: decoded.wrapper_hints,
      };
      if (decoded.kind === "wrapper_artifact") {
        return {
          ...base,
          artifactId: decoded.artifact_id,
          title: decoded.title,
          version: decoded.version,
          requiredCapabilities: decoded.required_capabilities,
        };
      }
      return {
        ...base,
        acceptsContext: decoded.accepts_context,
      };
    },
  },
  {
    method: "workflow.capabilities.call",
    label: "Call capability",
    explanation: "Call one workflow-authorable capability directly",
    idempotency: "write",
    equivalentCli: (params) => {
      const p = Schema.decodeUnknownSync(WorkflowCapabilitiesCallPayloadSchema)(
        params,
        { onExcessProperty: "error" },
      );
      const parts = [
        "uv run wf cap call",
        shellArg(p.qualified_name),
        "--input",
        shellArg(JSON.stringify(p.payload ?? {})),
      ];
      if (p.deployment_id != null) {
        parts.push("--deployment", shellArg(p.deployment_id));
      }
      return parts.join(" ");
    },
    interpret: (result): CapabilityCallInterpreted => {
      const decoded = Schema.decodeUnknownSync(
        WorkflowCapabilitiesCallResultSchema,
      )(result);
      return {
        qualifiedName: decoded.qualified_name,
        sourceId: decoded.source_id,
        kind: decoded.kind,
        deploymentId: decoded.deployment_id,
        outcome: decoded.outcome,
        output: decoded.output,
        diagnostics: decoded.diagnostics.map((diagnostic) => ({
          boundSource: diagnostic.bound_source,
          code: diagnostic.code,
          logicalRef: diagnostic.logical_ref,
          message: diagnostic.message,
          repairHint: diagnostic.repair_hint,
          severity: diagnostic.severity,
        })),
      };
    },
  },
  {
    method: "workflow.draft_workspaces.list",
    label: "List draft workspaces",
    explanation: "List persisted workflow draft workspaces",
    idempotency: "read",
    equivalentCli: () => "uv run wf draft list",
    interpret: (result) => {
      const decoded = Schema.decodeUnknownSync(
        WorkflowDraftWorkspacesListResultSchema,
      )(result);
      return {
        items: decoded.workspaces.map(interpretDraftWorkspace),
      };
    },
  },
  {
    method: "workflow.draft_workspaces.get",
    label: "Inspect draft workspace",
    explanation: "Inspect one persisted workflow draft workspace",
    idempotency: "read",
    equivalentCli: (params) => {
      const p = Schema.decodeUnknownSync(
        WorkflowDraftWorkspacesGetPayloadSchema,
      )(params, { onExcessProperty: "error" });
      const parts = ["uv run wf draft inspect", shellArg(p.workspace_id)];
      if (p.include_draft === true) parts.push("--include-draft");
      return parts.join(" ");
    },
    interpret: (result) => {
      const decoded = Schema.decodeUnknownSync(
        WorkflowDraftWorkspacesGetResultSchema,
      )(result);
      return interpretDraftWorkspace(decoded);
    },
  },
  {
    method: "workflow.draft_workspaces.create_empty",
    label: "Create empty draft workspace",
    explanation: "Create an empty persisted workflow draft workspace",
    idempotency: "write",
    equivalentCli: (params) => {
      const p = Schema.decodeUnknownSync(
        WorkflowDraftWorkspacesCreateEmptyPayloadSchema,
      )(params, { onExcessProperty: "error" });
      const parts = ["uv run wf draft create", shellArg(p.workspace_id), "--name", shellArg(p.name)];
      if (p.title != null) parts.push("--title", shellArg(p.title));
      for (const outcome of p.outcomes ?? []) {
        parts.push("--outcome", shellArg(outcome));
      }
      const unavailable = [
        ...(p.input_schema != null ? ["input_schema (use --input-schema-file)"] : []),
        ...(p.state_schema != null ? ["state_schema (use --state-schema-file)"] : []),
        ...(p.output_schema != null ? ["output_schema (use --output-schema-file)"] : []),
      ];
      return nonEquivalentCli(parts.join(" "), unavailable);
    },
    interpret: (result) => {
      const decoded = Schema.decodeUnknownSync(
        WorkflowDraftWorkspacesCreateEmptyResultSchema,
      )(result);
      return interpretDraftWorkspace(decoded);
    },
  },
  {
    method: "workflow.draft_workspaces.create_from_capability",
    label: "Create draft from capability",
    explanation: "Create a capability-backed persisted workflow draft workspace",
    idempotency: "write",
    equivalentCli: (params) => {
      const p = Schema.decodeUnknownSync(
        WorkflowDraftWorkspacesCreateFromCapabilityPayloadSchema,
      )(params, { onExcessProperty: "error" });
      const parts = [
        "uv run wf draft create",
        shellArg(p.workspace_id),
        "--capability",
        shellArg(p.capability_name),
      ];
      if (p.name != null) parts.push("--name", shellArg(p.name));
      if (p.title != null) parts.push("--title", shellArg(p.title));
      const unavailable = [
        ...(p.input_schema != null ? ["input_schema"] : []),
        ...(p.state_schema != null ? ["state_schema"] : []),
        ...(p.output_schema != null ? ["output_schema"] : []),
        ...(p.input != null ? ["input"] : []),
        ...(p.output != null ? ["output"] : []),
        ...(p.input_map != null ? ["input_map"] : []),
        ...(p.output_map != null ? ["output_map"] : []),
        ...(p.error_message_source !== undefined ? ["error_message_source"] : []),
      ];
      return nonEquivalentCli(parts.join(" "), unavailable);
    },
    interpret: (result) => {
      const decoded = Schema.decodeUnknownSync(
        WorkflowDraftWorkspacesCreateFromCapabilityResultSchema,
      )(result);
      return interpretDraftWorkspace(decoded);
    },
  },
  {
    method: "workflow.draft_workspaces.add_step_from_capability",
    label: "Add capability draft step",
    explanation: "Add a capability-backed step to a persisted workflow draft",
    idempotency: "write",
    equivalentCli: (params) => {
      const p = Schema.decodeUnknownSync(
        WorkflowDraftWorkspacesAddStepFromCapabilityPayloadSchema,
      )(params, { onExcessProperty: "error" });
      const parts = [
        "uv run wf draft add capability",
        shellArg(p.workspace_id),
        "--revision",
        String(p.revision),
        "--step",
        shellArg(p.step_id),
        "--capability",
        shellArg(p.capability_name),
      ];
      if (p.route_from_step != null) {
        parts.push("--from-step", shellArg(p.route_from_step));
        if (p.route_from_outcome != null) {
          parts.push("--from-outcome", shellArg(p.route_from_outcome));
        }
      }
      for (const [outcome, target] of Object.entries(p.routes ?? {})) {
        parts.push("--route", shellArg(`${outcome}=${target}`));
      }
      for (const [source, target] of Object.entries(p.input_map ?? {})) {
        parts.push("--input", shellArg(`${source}=${target}`));
      }
      for (const [source, target] of Object.entries(p.bind_outputs ?? {})) {
        parts.push("--bind-output", shellArg(`${source}=${target}`));
      }
      if (p.desc != null) parts.push("--description", shellArg(p.desc));
      if (p.retry != null) parts.push("--retry", String(p.retry));
      if (p.timeout_seconds != null) {
        parts.push("--timeout-seconds", String(p.timeout_seconds));
      }
      const unavailable: string[] = [];
      if (p.input_bindings != null) {
        if (p.input_map != null) {
          unavailable.push("input_map and input_bindings (mutually exclusive)");
        }
        const rendered = inputBindingCliArgs(p.input_bindings);
        parts.push(...rendered.args);
        unavailable.push(...rendered.unavailable);
      }
      return nonEquivalentCli(parts.join(" "), unavailable);
    },
    interpret: (result) => {
      const decoded = Schema.decodeUnknownSync(
        WorkflowDraftWorkspacesAddStepFromCapabilityResultSchema,
      )(result);
      return interpretDraftWorkspace(decoded);
    },
  },
  {
    method: "workflow.draft_workspaces.update_capability_step",
    label: "Update capability draft step",
    explanation: "Update metadata or input bindings on a capability-backed draft step",
    idempotency: "write",
    equivalentCli: (params) => {
      const p = Schema.decodeUnknownSync(
        WorkflowDraftWorkspacesUpdateCapabilityStepPayloadSchema,
      )(params, { onExcessProperty: "error" });
      const parts = [
        "uv run wf draft update capability",
        shellArg(p.workspace_id),
        "--revision",
        String(p.revision),
        "--step",
        shellArg(p.step_id),
      ];
      if (p.update.desc != null) parts.push("--description", shellArg(p.update.desc));
      else if (p.update.desc === null) parts.push("--clear-description");
      if (p.update.retry != null) {
        if (p.update.retry === 0) parts.push("--retry", "0");
        else parts.push("--retry", String(p.update.retry));
      } else if (p.update.retry === null) parts.push("--clear-retry");
      if (p.update.timeout_seconds != null) {
        parts.push("--timeout-seconds", String(p.update.timeout_seconds));
      } else if (p.update.timeout_seconds === null) {
        parts.push("--clear-timeout");
      }
      const unavailable: string[] = [];
      const updateInput = p.update.input;
      if (Array.isArray(updateInput)) {
        if (updateInput.length === 0) {
          parts.push("--clear-input");
        } else {
          const rendered = inputBindingCliArgs(updateInput);
          parts.push(...rendered.args);
          unavailable.push(...rendered.unavailable);
        }
      } else if (updateInput === null) {
        unavailable.push("input: null (the service rejects null input updates)");
      }
      return nonEquivalentCli(parts.join(" "), unavailable);
    },
    interpret: (result) => {
      const decoded = Schema.decodeUnknownSync(
        WorkflowDraftWorkspacesUpdateCapabilityStepResultSchema,
      )(result);
      return interpretDraftWorkspace(decoded);
    },
  },
  {
    method: "workflow.draft_workspaces.set_route",
    label: "Set draft route",
    explanation: "Set one outcome route on a persisted workflow draft",
    idempotency: "write",
    equivalentCli: (params) => {
      const p = Schema.decodeUnknownSync(
        WorkflowDraftWorkspacesSetRoutePayloadSchema,
      )(params, { onExcessProperty: "error" });
      return `uv run wf draft set-route ${shellArg(p.workspace_id)} --revision ${p.revision} --step ${shellArg(p.step_id)} --outcome ${shellArg(p.outcome)} --to ${shellArg(p.target)}`;
    },
    interpret: (result) => {
      const decoded = Schema.decodeUnknownSync(
        WorkflowDraftWorkspacesSetRouteResultSchema,
      )(result);
      return interpretDraftWorkspace(decoded);
    },
  },
  {
    method: "workflow.draft_workspaces.set_step_input_bindings",
    label: "Set step input bindings",
    explanation: "Replace one capability-backed step's ordered input bindings",
    idempotency: "write",
    equivalentCli: (params) => {
      const p = Schema.decodeUnknownSync(
        WorkflowDraftWorkspacesSetStepInputBindingsPayloadSchema,
      )(params, { onExcessProperty: "error" });
      const parts = [
        "uv run wf draft set-input",
        shellArg(p.workspace_id),
        "--revision",
        String(p.revision),
        "--step",
        shellArg(p.step_id),
      ];
      if (p.bindings.length === 0) {
        parts.push("--clear");
      } else {
        const rendered = inputBindingCliArgs(p.bindings, "--map");
        parts.push(...rendered.args);
        return nonEquivalentCli(parts.join(" "), rendered.unavailable);
      }
      return parts.join(" ");
    },
    interpret: (result) => {
      const decoded = Schema.decodeUnknownSync(
        WorkflowDraftWorkspacesSetStepInputBindingsResultSchema,
      )(result);
      return interpretDraftWorkspace(decoded);
    },
  },
  {
    method: "workflow.draft_workspaces.set_step_output_bindings",
    label: "Set step output bindings",
    explanation: "Replace one capability-backed step's ordered output bindings",
    idempotency: "write",
    equivalentCli: (params) => {
      const p = Schema.decodeUnknownSync(
        WorkflowDraftWorkspacesSetStepOutputBindingsPayloadSchema,
      )(params, { onExcessProperty: "error" });
      const parts = [
        "uv run wf draft set-output",
        shellArg(p.workspace_id),
        "--revision",
        String(p.revision),
        "--step",
        shellArg(p.step_id),
      ];
      if (p.bindings.length === 0) {
        parts.push("--clear");
      } else {
        const rendered = outputBindingCliArgs(p.bindings);
        parts.push(...rendered.args);
        return nonEquivalentCli(parts.join(" "), rendered.unavailable);
      }
      return parts.join(" ");
    },
    interpret: (result) => {
      const decoded = Schema.decodeUnknownSync(
        WorkflowDraftWorkspacesSetStepOutputBindingsResultSchema,
      )(result);
      return interpretDraftWorkspace(decoded);
    },
  },
  {
    method: "workflow.draft_workspaces.validate",
    label: "Validate draft workspace",
    explanation: "Validate a persisted workflow draft workspace",
    idempotency: "read",
    equivalentCli: (params) => {
      const p = Schema.decodeUnknownSync(
        WorkflowDraftWorkspacesValidatePayloadSchema,
      )(params, { onExcessProperty: "error" });
      return `uv run wf draft validate ${shellArg(p.workspace_id)}`;
    },
    interpret: (result) => {
      const decoded = Schema.decodeUnknownSync(
        WorkflowDraftWorkspacesValidateResultSchema,
      )(result);
      return interpretDraftWorkspace(decoded);
    },
  },
  {
    method: "workflow.artifacts.list",
    label: "List artifacts",
    explanation: "List workflow artifacts with pagination",
    idempotency: "read",
    equivalentCli: (params) => {
      const p = Schema.decodeUnknownSync(WorkflowArtifactsListPayloadSchema)(
        params,
        { onExcessProperty: "error" },
      );
      const parts = ["uv run wf artifact list"];
      if (p.query != null) parts.push(`--query ${shellArg(p.query)}`);
      if (p.kind != null) parts.push(`--kind ${shellArg(p.kind)}`);
      if (p.cursor != null) parts.push(`--cursor ${shellArg(p.cursor)}`);
      if (p.limit != null) parts.push(`--limit ${p.limit}`);
      return parts.join(" ");
    },
    interpret: (result) => {
      const decoded = Schema.decodeUnknownSync(
        WorkflowArtifactsListResultSchema,
      )(result);
      return {
        items: decoded.nodes.map((node) => ({
          key: `${node.artifact_id}@${node.version}`,
          artifactId: node.artifact_id,
          version: node.version,
          kind: node.kind,
          displayName: node.display_name,
          description: node.description,
          outcomes: node.outcomes,
          requiredSources: node.required_sources,
          diagnosticCount: node.diagnostics.length,
        })),
        nextCursor: decoded.next_cursor,
        total: decoded.total,
      };
    },
  },
  {
    method: "workflow.artifacts.inspect",
    label: "Inspect artifact",
    explanation: "Inspect a workflow artifact by id and version",
    idempotency: "read",
    equivalentCli: (params) => {
      const p = Schema.decodeUnknownSync(WorkflowArtifactsInspectPayloadSchema)(
        params,
        { onExcessProperty: "error" },
      );
      return `uv run wf artifact inspect ${shellArg(p.artifact_id)} --version ${p.version}`;
    },
    interpret: (result) => {
      const decoded = Schema.decodeUnknownSync(
        WorkflowArtifactsInspectResultSchema,
      )(result);
      return {
        artifactId: decoded.id,
        version: decoded.version,
        title: decoded.title,
        kind: decoded.kind,
        description: decoded.description,
        outcomes: decoded.outcomes,
        plan: decoded.plan,
        requiredCapabilities: decoded.required_capabilities,
        workflowDependencies: decoded.workflow_dependencies,
        createdFromCatalogVersion: decoded.created_from_catalog_version,
      };
    },
  },
  {
    method: "workflow.deployments.list",
    label: "List deployments",
    explanation: "List workflow deployments",
    idempotency: "read",
    equivalentCli: () => "uv run wf deploy list",
    interpret: (result) => {
      const decoded = Schema.decodeUnknownSync(
        WorkflowDeploymentsListResultSchema,
      )(result);
      return {
        items: decoded.deployments.map((d) => ({
          id: d.id,
          artifactId: d.artifact_id,
          artifactVersion: d.artifact_version,
          bindingCount: d.binding_count,
          driftPolicy: d.drift_policy,
        })),
      };
    },
  },
  {
    method: "workflow.deployments.inspect",
    label: "Inspect deployment",
    explanation: "Inspect a workflow deployment by id",
    idempotency: "read",
    equivalentCli: (params) => {
      const p = Schema.decodeUnknownSync(
        WorkflowDeploymentsInspectPayloadSchema,
      )(params, { onExcessProperty: "error" });
      return `uv run wf deploy inspect ${shellArg(p.deployment_id)}`;
    },
    interpret: (result) => {
      const decoded = Schema.decodeUnknownSync(
        WorkflowDeploymentsInspectResultSchema,
      )(result);
      return {
        id: decoded.id,
        artifactId: decoded.artifact_id,
        artifactVersion: decoded.artifact_version,
        bindings: decoded.bindings.map((b) => ({
          logicalSource: b.logical_source,
          concreteSource: b.concrete_source,
        })),
        driftPolicy: decoded.drift_policy,
      };
    },
  },
  {
    method: "workflow.deployments.validate",
    label: "Validate deployment",
    explanation: "Validate a workflow deployment",
    idempotency: "read",
    equivalentCli: (params) => {
      const p = Schema.decodeUnknownSync(
        WorkflowDeploymentsValidatePayloadSchema,
      )(params, { onExcessProperty: "error" });
      return `uv run wf deploy validate ${shellArg(p.deployment_id)}`;
    },
    interpret: (result) => {
      const decoded = Schema.decodeUnknownSync(
        WorkflowDeploymentsValidateResultSchema,
      )(result);
      return {
        deploymentId: decoded.deployment_id,
        artifactId: decoded.artifact_id,
        artifactVersion: decoded.artifact_version,
        status: decoded.status,
        diagnostics: decoded.diagnostics,
        nextActions: interpretNextActions(decoded.next_actions),
      };
    },
  },
  {
    method: "workflow.runs.list",
    label: "List runs",
    explanation: "List workflow runs with pagination",
    idempotency: "read",
    equivalentCli: (params) => {
      const p = Schema.decodeUnknownSync(WorkflowRunsListPayloadSchema)(
        params,
        { onExcessProperty: "error" },
      );
      const parts = ["uv run wf run list"];
      if (p.status != null) parts.push(`--status ${shellArg(p.status)}`);
      if (p.cursor != null) parts.push(`--cursor ${shellArg(p.cursor)}`);
      if (p.limit != null) parts.push(`--limit ${p.limit}`);
      return parts.join(" ");
    },
    interpret: (result) => {
      const decoded = Schema.decodeUnknownSync(WorkflowRunsListResultSchema)(
        result,
      );
      return {
        items: decoded.runs.map((run) => ({
          runId: run.run_id,
          deploymentId: run.deployment_id,
          artifactId: run.artifact_id,
          artifactVersion: run.artifact_version,
          status: run.status,
          resumeReadiness: run.resume_readiness,
          diagnosticCount: run.diagnostic_count,
          createdAt: run.created_at,
          updatedAt: run.updated_at,
        })),
        nextCursor: decoded.next_cursor,
        total: decoded.total,
      };
    },
  },
  {
    method: "workflow.runs.inspect",
    label: "Inspect run",
    explanation: "Inspect a workflow run by id",
    idempotency: "read",
    equivalentCli: (params) => {
      const p = Schema.decodeUnknownSync(WorkflowRunsInspectPayloadSchema)(
        params,
        { onExcessProperty: "error" },
      );
      return `uv run wf run inspect ${shellArg(p.run_id)}`;
    },
    interpret: (result) => {
      const decoded = Schema.decodeUnknownSync(WorkflowRunsInspectResultSchema)(
        result,
      );
      return interpretRunDetail(decoded);
    },
  },
  {
    method: "workflow.runs.start",
    label: "Start run",
    explanation: "Start a workflow deployment run",
    idempotency: "write",
    equivalentCli: (params) => {
      const p = Schema.decodeUnknownSync(WorkflowRunsStartPayloadSchema)(
        params,
        { onExcessProperty: "error" },
      );
      return `uv run wf run start ${shellArg(p.deployment_id)} --input '<json>'`;
    },
    interpret: (result) => {
      const decoded = Schema.decodeUnknownSync(WorkflowRunsStartResultSchema)(
        result,
        { onExcessProperty: "ignore" },
      );
      return interpretRunDetail(decoded);
    },
  },
  {
    method: "workflow.runs.resume",
    label: "Resume run",
    explanation: "Resume an interrupted workflow run",
    idempotency: "write",
    equivalentCli: (params) => {
      const p = Schema.decodeUnknownSync(WorkflowRunsResumePayloadSchema)(
        params,
        { onExcessProperty: "error" },
      );
      return `uv run wf run resume ${shellArg(p.run_id)} --payload '<json>'`;
    },
    interpret: (result) => {
      const decoded = Schema.decodeUnknownSync(WorkflowRunsResumeResultSchema)(
        result,
        { onExcessProperty: "ignore" },
      );
      return interpretRunDetail(decoded);
    },
  },
  {
    method: "workflow.runs.trace",
    label: "Read run trace",
    explanation: "Read trace frames for a workflow run",
    idempotency: "read",
    equivalentCli: (params) => {
      const p = Schema.decodeUnknownSync(WorkflowRunsTracePayloadSchema)(
        params,
        { onExcessProperty: "error" },
      );
      const parts = ["uv run wf run trace", shellArg(p.run_id)];
      if (p.trace_range.start != null) {
        parts.push(`--from ${p.trace_range.start}`);
      }
      if (p.trace_range.limit != null) {
        parts.push(`--limit ${p.trace_range.limit}`);
      }
      return parts.join(" ");
    },
    interpret: (result) => {
      const decoded = Schema.decodeUnknownSync(WorkflowRunsTraceResultSchema)(result);
      const trace = decoded.trace.map((entry) => ({
        frameId: entry.frame_id,
        nodeId: entry.node_id,
        stepType: entry.step_type,
        outcome: entry.outcome,
        nextNodeId: entry.next_node_id,
        resolvedInput: entry.resolved_input,
        output: entry.output,
        stateChanges: entry.state_changes,
      }));
      return {
        runId: decoded.run_id,
        status: decoded.status,
        frames: trace,
        traceStart: decoded.trace_start,
        traceLimit: decoded.trace_limit,
        traceTruncated: decoded.trace_truncated,
      };
    },
  },
]);

export type OperationName = (typeof operationEntries)[number]["method"];

export const workflowRpcOperationNames: ReadonlyArray<OperationName> =
  Object.freeze(operationEntries.map(({ method }) => method));

const operationNameSet: ReadonlySet<string> = new Set(workflowRpcOperationNames);

export const isOperationName = (value: string): value is OperationName =>
  operationNameSet.has(value);

const registry: ReadonlyMap<string, OperationMeta> = new Map(
  operationEntries.map((entry) => [entry.method, entry]),
);

export const getOperationMeta = (method: string): OperationMeta | undefined =>
  registry.get(method);

export const listOperations = (): ReadonlyArray<OperationMeta> =>
  operationEntries;