import { Effect, Layer } from "effect";

import {
  McpErrorReporter,
  type McpModernServerBuilder,
  type McpModernServerBuildOptions,
  type Principal,
} from "@executor-js/host-mcp";
import {
  McpEngineBuildError,
  type McpBuildServer as McpSessionBuildServer,
  type McpBuildServerOptions as McpSessionBuildOptions,
} from "@executor-js/host-mcp/in-memory-session-store";
import { buildMcpServer } from "@executor-js/host-mcp/tool-server";
import {
  artifactUrlFor,
  type ArtifactSmokeRenderResult,
} from "@executor-js/host-mcp/create-artifact";

import { ErrorCapture } from "../observability";
import { CodeExecutorProvider, EngineDecorator, makeExecutionStack } from "./execution-stack";
import { DbProvider } from "./executor-fuma-db";
import { HostConfig, PluginsProvider, RequestOrgSlug } from "./scoped-executor";

// ---------------------------------------------------------------------------
// Shared in-process MCP host helpers.
//
// Neutral hosts build both sessionful legacy-wire connections and stateless
// modern requests from the same assembly over a scoped execution stack.
// ---------------------------------------------------------------------------

/** The five execution-stack seams a host fully provides (no residual). */
export type McpExecutionStackLayer = Layer.Layer<
  DbProvider | PluginsProvider | HostConfig | CodeExecutorProvider | EngineDecorator
>;

type McpSessionBuildEffect = ReturnType<McpSessionBuildServer>;
type McpModernBuildEffect = ReturnType<McpModernServerBuilder["Service"]["build"]>;

/** A single build seam accepted by both the session store and modern envelope. */
export interface McpBuildServer {
  /** Build a connection-lifetime server and retain its engine for session-owned approvals. */
  (principal: Principal, options: McpSessionBuildOptions): McpSessionBuildEffect;
  /** Build a stateless server for one modern request. */
  (principal: Principal, options: McpModernServerBuildOptions): McpModernBuildEffect;
}

/**
 * Build the unified MCP server factory over a host's execution stack.
 * Session callers receive the server plus its approval-owning engine; modern
 * request callers receive the server directly.
 */
export const makeMcpBuildServer = (
  executionStack: McpExecutionStackLayer,
  hostOptions?: McpBuildHostOptions,
): McpBuildServer => {
  function build(principal: Principal, options: McpSessionBuildOptions): McpSessionBuildEffect;
  function build(principal: Principal, options: McpModernServerBuildOptions): McpModernBuildEffect;
  function build(
    principal: Principal,
    options: McpSessionBuildOptions | McpModernServerBuildOptions,
  ): Effect.Effect<
    Effect.Success<McpSessionBuildEffect> | Effect.Success<McpModernBuildEffect>,
    Effect.Error<McpSessionBuildEffect> | Effect.Error<McpModernBuildEffect>
  > {
    const { resource, ...serverOptions } = options;
    return Effect.gen(function* () {
      const { engine, executor } = yield* makeExecutionStack(
        principal.accountId,
        principal.organizationId,
        principal.organizationName,
        { mcpResource: resource },
      ).pipe(Effect.withSpan("mcp.execution_stack.build"));
      // Read inside the provided boundary: `webBaseUrl` is a host seam, and
      // hosts that cannot know their public URL at boot leave it unset.
      const hostConfig = yield* HostConfig;
      return { engine, executor, webBaseUrl: hostConfig.webBaseUrl };
    }).pipe(
      principal.organizationSlug !== undefined
        ? Effect.provideService(RequestOrgSlug, { slug: principal.organizationSlug })
        : (effect) => effect,
      Effect.provide(executionStack),
      Effect.mapError((cause) => new McpEngineBuildError({ cause })),
      Effect.flatMap(({ engine, executor, webBaseUrl }) =>
        buildMcpServer({
          engine,
          artifacts: executor.artifacts,
          connections: executor.connections,
          ...(hostOptions?.loadAppShellHtml
            ? { loadAppShellHtml: hostOptions.loadAppShellHtml }
            : {}),
          ...(hostOptions?.smokeRenderArtifact
            ? { smokeRenderArtifact: hostOptions.smokeRenderArtifact }
            : {}),
          ...(hostOptions?.onArtifactUsage ? { onArtifactUsage: hostOptions.onArtifactUsage } : {}),
          ...(webBaseUrl
            ? { artifactUrl: artifactUrlFor(webBaseUrl, principal.organizationSlug) }
            : {}),
          ...serverOptions,
        }).pipe(
          Effect.withSpan("mcp.server.create"),
          Effect.map((mcpServer) => ("sessionful" in options ? { mcpServer, engine } : mcpServer)),
        ),
      ),
    );
  }

  return build;
};

/** Per-host (not per-session) MCP wiring. Kept separate from
 *  `McpBuildServerOptions`, which the session store fills in per request. */
export interface McpBuildHostOptions {
  /** Serves the MCP-Apps shell resource. Hosts that can render generative UI
   *  pass `loadMcpAppsShellHtml` from `@executor-js/mcp-apps-shell`; omitting it
   *  leaves the ui-bearing tools unregistered. */
  readonly loadAppShellHtml?: () => Promise<string>;
  /** Trial-renders an artifact before it is saved, so a component that throws
   *  on first render is refused at create time. Hosts that can afford React on
   *  the server pass `smokeRenderArtifact` from `@executor-js/mcp-apps-shell`,
   *  which loads it behind a dynamic import; omitting it skips the check. */
  readonly smokeRenderArtifact?: (code: string) => Promise<ArtifactSmokeRenderResult>;
  /** Forwarded to the tool server's `onArtifactUsage`: best-effort observation
   *  of agent-driven artifact operations, for hosts recording product
   *  analytics. */
  readonly onArtifactUsage?: (action: "created" | "viewed" | "updated") => Effect.Effect<void>;
}

/**
 * The standard console `McpErrorReporter` seam: route an orchestration defect
 * the MCP envelope would otherwise swallow into a 500 through the host's
 * `ErrorCapture`, so operators still see it. Hosts differ only in the capture
 * layer (self-host/Cloudflare console; cloud overrides with Sentry separately).
 */
export const makeConsoleMcpErrorReporter = (
  errorCapture: Layer.Layer<ErrorCapture>,
): Layer.Layer<McpErrorReporter> =>
  Layer.effect(
    McpErrorReporter,
    Effect.gen(function* () {
      const capture = yield* ErrorCapture;
      return { report: (cause) => Effect.asVoid(capture.captureException(cause)) };
    }),
  ).pipe(Layer.provide(errorCapture));