import * as NodeServices from "@effect/platform-node/NodeServices";
import { assert, describe, it } from "@effect/vitest";
import {
  EnvironmentId,
  MessageId,
  ProjectId,
  ProviderInstanceId,
  RunId,
  ThreadId,
  type OrchestrationV2ThreadProjection,
} from "@t3tools/contracts";
import * as DateTime from "effect/DateTime";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import * as Ref from "effect/Ref";

import { OrchestratorProjectionError } from "../orchestration-v2/Orchestrator.ts";
import { ProjectionStoreThreadNotFoundError } from "../orchestration-v2/ProjectionStore.ts";
import {
  ThreadManagementProjectionLoadError,
  ThreadManagementService,
  ThreadManagementThreadNotFoundError,
} from "../orchestration-v2/ThreadManagementService.ts";
import type { McpInvocationScope } from "./McpInvocationContext.ts";
import { layer, QueueMcpService } from "./QueueMcpService.ts";

const projectId = ProjectId.make("project:queue-mcp-service");
const callerThreadId = ThreadId.make("thread:queue-mcp-caller");
const targetThreadId = ThreadId.make("thread:queue-mcp-target");
const queuedRunId = RunId.make("run:queue-mcp-target");
const queuedMessageId = MessageId.make("message:queue-mcp-target");

const scope: McpInvocationScope = {
  environmentId: EnvironmentId.make("environment:queue-mcp-service"),
  threadId: callerThreadId,
  providerSessionId: "provider-session:queue-mcp-service",
  providerInstanceId: ProviderInstanceId.make("codex"),
  capabilities: new Set(["orchestration"]),
  issuedAt: 1,
};

function projection(input: {
  readonly threadId: ThreadId;
  readonly runtimeMode: "approval-required" | "full-access";
  readonly interactionMode: "plan" | "default";
  readonly queued?: boolean;
}): OrchestrationV2ThreadProjection {
  return {
    thread: {
      id: input.threadId,
      projectId,
      runtimeMode: input.runtimeMode,
      interactionMode: input.interactionMode,
      deletedAt: null,
    },
    runs:
      input.queued === true
        ? [
            {
              id: queuedRunId,
              ordinal: 1,
              status: "queued",
              queuePosition: 1,
              userMessageId: queuedMessageId,
              requestedAt: DateTime.makeUnsafe("2026-09-04T00:00:00.000Z"),
              modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-test" },
            },
          ]
        : [],
    messages:
      input.queued === true
        ? [
            {
              id: queuedMessageId,
              text: "Queued text",
              attachments: [],
            },
          ]
        : [],
  } as unknown as OrchestrationV2ThreadProjection;
}

function serviceLayer(input: {
  readonly caller: OrchestrationV2ThreadProjection;
  readonly target: OrchestrationV2ThreadProjection;
  readonly dispatchCount: Ref.Ref<number>;
}) {
  return layer.pipe(
    Layer.provide(
      Layer.merge(
        NodeServices.layer,
        Layer.mock(ThreadManagementService)({
          getThreadProjection: () => Effect.succeed(input.caller),
          getProjectThread: () => Effect.succeed(input.target),
          getCommandReceipt: () => Effect.succeed(Option.none()),
          dispatch: () =>
            Ref.update(input.dispatchCount, (count) => count + 1).pipe(
              Effect.as({ sequence: 1, storedEvents: [] }),
            ),
        }),
      ),
    ),
  );
}

describe("QueueMcpService", () => {
  it.effect("applies the shared runtime and interaction ceilings to edit and promote", () =>
    Effect.gen(function* () {
      const dispatchCount = yield* Ref.make(0);
      const caller = projection({
        threadId: callerThreadId,
        runtimeMode: "approval-required",
        interactionMode: "plan",
      });
      const assertDenied = (target: OrchestrationV2ThreadProjection, expectedCode: string) =>
        Effect.gen(function* () {
          const service = yield* QueueMcpService;
          const editError = yield* service
            .edit(scope, {
              threadId: targetThreadId,
              queuedRunId,
              text: "Edited text",
              clientRequestId: `edit-${expectedCode}`,
            })
            .pipe(Effect.flip);
          assert.equal(editError.code, expectedCode);
          const promoteError = yield* service
            .promote(scope, {
              threadId: targetThreadId,
              queuedRunId,
              targetRunId: RunId.make("run:active-target"),
              clientRequestId: `promote-${expectedCode}`,
            })
            .pipe(Effect.flip);
          assert.equal(promoteError.code, expectedCode);
        }).pipe(Effect.provide(serviceLayer({ caller, target, dispatchCount })));

      yield* assertDenied(
        projection({
          threadId: targetThreadId,
          runtimeMode: "full-access",
          interactionMode: "plan",
          queued: true,
        }),
        "runtime_mode_escalation_denied",
      );
      yield* assertDenied(
        projection({
          threadId: targetThreadId,
          runtimeMode: "approval-required",
          interactionMode: "default",
          queued: true,
        }),
        "interaction_mode_escalation_denied",
      );
      assert.equal(yield* Ref.get(dispatchCount), 0);
    }),
  );

  it.effect("allows edit and promote when the target stays within both ceilings", () =>
    Effect.gen(function* () {
      const dispatchCount = yield* Ref.make(0);
      const caller = projection({
        threadId: callerThreadId,
        runtimeMode: "full-access",
        interactionMode: "default",
      });
      const target = projection({
        threadId: targetThreadId,
        runtimeMode: "approval-required",
        interactionMode: "plan",
        queued: true,
      });
      yield* Effect.gen(function* () {
        const service = yield* QueueMcpService;
        yield* service.edit(scope, {
          threadId: targetThreadId,
          queuedRunId,
          text: "Edited text",
          clientRequestId: "edit-allowed",
        });
        yield* service.promote(scope, {
          threadId: targetThreadId,
          queuedRunId,
          targetRunId: RunId.make("run:active-target"),
          clientRequestId: "promote-allowed",
        });
      }).pipe(Effect.provide(serviceLayer({ caller, target, dispatchCount })));
      assert.equal(yield* Ref.get(dispatchCount), 2);
    }),
  );

  it.effect("does not split a surrogate pair at the queue preview boundary", () =>
    Effect.gen(function* () {
      const dispatchCount = yield* Ref.make(0);
      const caller = projection({
        threadId: callerThreadId,
        runtimeMode: "full-access",
        interactionMode: "default",
      });
      const queued = projection({
        threadId: targetThreadId,
        runtimeMode: "full-access",
        interactionMode: "default",
        queued: true,
      });
      const target = {
        ...queued,
        messages: queued.messages.map((message) => ({ ...message, text: "😀 after emoji" })),
      };
      const result = yield* Effect.gen(function* () {
        const service = yield* QueueMcpService;
        return yield* service.list(scope, {
          threadId: targetThreadId,
          limit: 1,
          maxCharsPerMessage: 1,
        });
      }).pipe(Effect.provide(serviceLayer({ caller, target, dispatchCount })));
      assert.equal(result.runs[0]?.text, "\n…[truncated]");
      assert.isTrue(result.runs[0]?.textTruncated);
    }),
  );

  it.effect("distinguishes missing threads from projection failures", () =>
    Effect.gen(function* () {
      const caller = projection({
        threadId: callerThreadId,
        runtimeMode: "full-access",
        interactionMode: "default",
      });
      const invokeListWith = (
        getProjectThread: ThreadManagementService["Service"]["getProjectThread"],
      ) =>
        Effect.gen(function* () {
          const service = yield* QueueMcpService;
          return yield* service.list(scope, { threadId: targetThreadId }).pipe(Effect.flip);
        }).pipe(
          Effect.provide(
            layer.pipe(
              Layer.provide(
                Layer.merge(
                  NodeServices.layer,
                  Layer.mock(ThreadManagementService)({
                    getThreadProjection: () => Effect.succeed(caller),
                    getProjectThread,
                  }),
                ),
              ),
            ),
          ),
        );

      const missing = yield* invokeListWith(() =>
        Effect.fail(
          new ThreadManagementThreadNotFoundError({ projectId, threadId: targetThreadId }),
        ),
      );
      assert.equal(missing.code, "thread_not_found");
      const broken = yield* invokeListWith(() =>
        Effect.fail(
          new ThreadManagementProjectionLoadError({
            projectId,
            threadId: targetThreadId,
            cause: new Error("database unavailable"),
          }),
        ),
      );
      assert.equal(broken.code, "orchestration_error");
      assert.include(
        broken.message,
        `Unable to load thread ${targetThreadId} in project ${projectId}.`,
      );
      assert.notInclude(broken.message, "database unavailable");
    }),
  );

  it.effect("does not disguise caller projection failures as scoped not-found results", () =>
    Effect.gen(function* () {
      const invokeListWith = (cause: unknown) =>
        Effect.gen(function* () {
          const service = yield* QueueMcpService;
          return yield* service.list(scope, {}).pipe(Effect.flip);
        }).pipe(
          Effect.provide(
            layer.pipe(
              Layer.provide(
                Layer.merge(
                  NodeServices.layer,
                  Layer.mock(ThreadManagementService)({
                    getThreadProjection: () =>
                      Effect.fail(
                        new OrchestratorProjectionError({ threadId: callerThreadId, cause }),
                      ),
                  }),
                ),
              ),
            ),
          ),
        );

      const projectionFailure = yield* invokeListWith(
        new ProjectionStoreThreadNotFoundError({ threadId: callerThreadId }),
      );
      assert.equal(projectionFailure.code, "orchestration_error");
    }),
  );
});