import {
  PROJECT_SCRIPT_MCP_DEFAULT_LIST_LIMIT,
  PROJECT_SCRIPT_MCP_DEFAULT_PREVIEW_CHARS,
  type ProjectScript,
  ProjectScriptMcpFailure,
  type ProjectScriptMcpListInput,
  type ProjectScriptMcpListResult,
  type ProjectScriptMcpRunInput,
  type ProjectScriptMcpRunResult,
  type ProjectScriptMcpStopInput,
  type ProjectScriptMcpStopResult,
  type TerminalMcpFailure,
  ThreadId,
} from "@t3tools/contracts";
import * as Context from "effect/Context";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Result from "effect/Result";

import type { McpInvocationScope } from "./McpInvocationContext.ts";
import { TerminalMcpService } from "./TerminalMcpService.ts";
import * as TerminalManager from "../terminal/Manager.ts";

const MAX_SCRIPT_INPUT_CHARS = 65_535;

interface ScriptRunOwnership {
  readonly projectId: string;
  readonly scriptId: string;
  readonly handle: TerminalManager.TerminalSessionHandle;
}

type ScriptRuns = Map<ThreadId, Map<string, ScriptRunOwnership>>;

function terminalFailure(error: TerminalMcpFailure): ProjectScriptMcpFailure {
  return new ProjectScriptMcpFailure({
    code: error.code,
    message:
      error.code === "operation_failed" ? "The saved script operation failed." : error.message,
  });
}

function terminalInputFailureMessage(error: TerminalMcpFailure): string {
  return error.code === "operation_failed"
    ? "The terminal was opened, but its saved script input was not accepted."
    : error.message;
}

export class ProjectScriptMcpService extends Context.Service<
  ProjectScriptMcpService,
  {
    readonly list: (
      scope: McpInvocationScope,
      input: ProjectScriptMcpListInput,
    ) => Effect.Effect<ProjectScriptMcpListResult, ProjectScriptMcpFailure>;
    readonly run: (
      scope: McpInvocationScope,
      input: ProjectScriptMcpRunInput,
    ) => Effect.Effect<ProjectScriptMcpRunResult, ProjectScriptMcpFailure>;
    readonly stop: (
      scope: McpInvocationScope,
      input: ProjectScriptMcpStopInput,
    ) => Effect.Effect<ProjectScriptMcpStopResult, ProjectScriptMcpFailure>;
  }
>()("t3/mcp/ProjectScriptMcpService") {}

function scriptForId(scripts: ReadonlyArray<ProjectScript>, scriptId: string) {
  return scripts.find((candidate) => candidate.id === scriptId);
}

function preview(script: ProjectScript, maxChars: number) {
  const characters = Array.from(script.command);
  return {
    scriptId: script.id,
    name: script.name,
    icon: script.icon,
    runOnWorktreeCreate: script.runOnWorktreeCreate,
    previewUrl: script.previewUrl ?? null,
    autoOpenPreview: script.autoOpenPreview ?? false,
    commandPreview: characters.slice(0, maxChars).join(""),
    commandCharacters: characters.length,
    commandTruncated: characters.length > maxChars,
  } as const;
}

export const make = Effect.gen(function* () {
  const terminals = yield* TerminalMcpService;
  const terminalManager = yield* TerminalManager.TerminalManager;
  const runs: ScriptRuns = new Map();

  const recordRun = (threadId: ThreadId, terminalId: string, ownership: ScriptRunOwnership) => {
    const forThread = runs.get(threadId) ?? new Map();
    forThread.set(terminalId, ownership);
    runs.set(threadId, forThread);
  };

  const removeRun = (
    threadId: ThreadId,
    terminalId: string,
    handle: TerminalManager.TerminalSessionHandle,
  ) => {
    const forThread = runs.get(threadId);
    if (forThread?.get(terminalId)?.handle.incarnation !== handle.incarnation) return;
    forThread.delete(terminalId);
    if (forThread.size === 0) runs.delete(threadId);
  };

  const load = Effect.fn("ProjectScriptMcpService.load")(function* (
    scope: McpInvocationScope,
    threadId: ThreadId | undefined,
  ) {
    return yield* terminals.resolveTarget(scope, threadId).pipe(Effect.mapError(terminalFailure));
  });

  const unsubscribe = yield* terminalManager.subscribeSessionInvalidation((handle) =>
    Effect.sync(() => removeRun(ThreadId.make(handle.threadId), handle.terminalId, handle)),
  );
  yield* Effect.addFinalizer(() => Effect.sync(unsubscribe));

  return ProjectScriptMcpService.of({
    list: (scope, input) =>
      Effect.gen(function* () {
        const resolved = yield* load(scope, input.threadId);
        const cursor = input.cursor ?? 0;
        const limit = input.limit ?? PROJECT_SCRIPT_MCP_DEFAULT_LIST_LIMIT;
        const maxChars = input.commandPreviewChars ?? PROJECT_SCRIPT_MCP_DEFAULT_PREVIEW_CHARS;
        const page = resolved.project.scripts.slice(cursor, cursor + limit);
        return {
          threadId: resolved.target.thread.id,
          projectId: resolved.project.id,
          scripts: page.map((script) => preview(script, maxChars)),
          nextCursor:
            cursor + page.length < resolved.project.scripts.length ? cursor + page.length : null,
          total: resolved.project.scripts.length,
        };
      }),
    run: (scope, input) =>
      Effect.gen(function* () {
        const resolved = yield* load(scope, input.threadId);
        const script = scriptForId(resolved.project.scripts, input.scriptId);
        if (script === undefined) {
          return yield* new ProjectScriptMcpFailure({
            code: "script_not_found",
            message: `Saved script '${input.scriptId}' was not found in project '${resolved.project.id}'.`,
          });
        }
        if (script.command.length > MAX_SCRIPT_INPUT_CHARS) {
          return yield* new ProjectScriptMcpFailure({
            code: "script_command_too_large",
            message: `Saved script '${script.id}' exceeds the managed terminal input limit.`,
          });
        }

        const opened = yield* Effect.uninterruptible(
          Effect.gen(function* () {
            const opened = yield* terminals
              .openFreshOwned(scope, {
                threadId: resolved.target.thread.id,
                terminalId: input.terminalId,
              })
              .pipe(Effect.mapError(terminalFailure));
            const ownership = {
              projectId: resolved.project.id,
              scriptId: script.id,
              handle: opened.handle,
            } satisfies ScriptRunOwnership;
            const admitted = yield* terminalManager.admitRunningSessionHandle(
              {
                threadId: resolved.target.thread.id,
                terminalId: input.terminalId,
                handle: opened.handle,
              },
              () => recordRun(resolved.target.thread.id, input.terminalId, ownership),
            );
            if (!admitted) {
              return yield* new ProjectScriptMcpFailure({
                code: "terminal_not_found",
                message: `Terminal '${input.terminalId}' changed before script ownership could be recorded.`,
              });
            }
            return opened;
          }),
        );

        const write = yield* Effect.result(
          terminals.writeOwned(scope, {
            threadId: resolved.target.thread.id,
            terminalId: input.terminalId,
            data: `${script.command}\r`,
            handle: opened.handle,
          }),
        );
        return Result.match(write, {
          onFailure: (error) => ({
            threadId: resolved.target.thread.id,
            projectId: resolved.project.id,
            scriptId: script.id,
            terminalId: input.terminalId,
            outcome: "terminal_opened_input_failed" as const,
            terminal: opened.terminal,
            inputAcceptance: null,
            error: terminalInputFailureMessage(error),
            previewUrl: script.previewUrl ?? null,
            previewAutoOpened: false as const,
          }),
          onSuccess: (inputAcceptance) => ({
            threadId: resolved.target.thread.id,
            projectId: resolved.project.id,
            scriptId: script.id,
            terminalId: input.terminalId,
            outcome: "input_accepted" as const,
            terminal: opened.terminal,
            inputAcceptance,
            error: null,
            previewUrl: script.previewUrl ?? null,
            previewAutoOpened: false as const,
          }),
        });
      }),
    stop: (scope, input) =>
      Effect.gen(function* () {
        const resolved = yield* load(scope, input.threadId);
        const ownership = runs.get(resolved.target.thread.id)?.get(input.terminalId);
        if (
          ownership === undefined ||
          ownership.projectId !== resolved.project.id ||
          ownership.scriptId !== input.scriptId
        ) {
          return yield* new ProjectScriptMcpFailure({
            code: "script_run_not_found",
            message: `Terminal '${input.terminalId}' is not a managed run of saved script '${input.scriptId}' for thread '${resolved.target.thread.id}'.`,
          });
        }
        const closed = yield* terminals
          .closeOwned(scope, {
            threadId: resolved.target.thread.id,
            terminalId: input.terminalId,
            handle: ownership.handle,
          })
          .pipe(Effect.mapError(terminalFailure));
        if (!closed) {
          removeRun(resolved.target.thread.id, input.terminalId, ownership.handle);
          return yield* new ProjectScriptMcpFailure({
            code: "script_run_not_found",
            message: `Terminal '${input.terminalId}' no longer names the managed run of saved script '${input.scriptId}'.`,
          });
        }
        removeRun(resolved.target.thread.id, input.terminalId, ownership.handle);
        return {
          threadId: resolved.target.thread.id,
          projectId: resolved.project.id,
          scriptId: input.scriptId,
          terminalId: input.terminalId,
          stopped: true,
        };
      }),
  });
});

export const layer = Layer.effect(ProjectScriptMcpService, make);