import {
  CommandId,
  EventId,
  MessageId,
  ProjectId,
  ProviderInstanceId,
  ThreadId,
  type OrchestrationReadModel,
  type OrchestrationThread,
} from "@t3tools/contracts";
import * as NodeServices from "@effect/platform-node/NodeServices";
import { expect, it } from "@effect/vitest";
import * as Effect from "effect/Effect";

import { decideOrchestrationCommand } from "./decider.ts";

const NOW = "2026-01-01T00:00:00.000Z";
// The decider's clock is the Effect test clock, pinned to the epoch, so
// "future" wake times are relative to 1970-01-01T00:00:00.000Z.
const FUTURE_WAKE = "1970-01-02T09:00:00.000Z";
const PAST_WAKE = "1969-12-31T09:00:00.000Z";
const SNOOZED_AT = "1969-12-30T00:00:00.000Z";

function makeReadModel(input: {
  readonly snoozedUntil?: string | null;
  readonly snoozedAt?: string | null;
  readonly archivedAt?: string | null;
  readonly activities?: OrchestrationThread["activities"];
  readonly messages?: OrchestrationThread["messages"];
}): OrchestrationReadModel {
  return {
    snapshotSequence: 0,
    projects: [],
    threads: [
      {
        id: ThreadId.make("thread-1"),
        projectId: ProjectId.make("project-1"),
        title: "Thread",
        modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" },
        runtimeMode: "full-access",
        interactionMode: "default",
        branch: null,
        worktreePath: null,
        latestTurn: null,
        createdAt: NOW,
        updatedAt: NOW,
        archivedAt: input.archivedAt ?? null,
        settledOverride: null,
        settledAt: null,
        snoozedUntil: input.snoozedUntil ?? null,
        snoozedAt: input.snoozedAt ?? (input.snoozedUntil != null ? SNOOZED_AT : null),
        deletedAt: null,
        messages: input.messages ?? [],
        proposedPlans: [],
        activities: input.activities ?? [],
        checkpoints: [],
        session: null,
      },
    ],
    updatedAt: NOW,
  };
}

it.layer(NodeServices.layer)("snoozed thread decider", (it) => {
  it.effect("snoozes a thread to a future wake time", () =>
    Effect.gen(function* () {
      const event = yield* decideOrchestrationCommand({
        command: {
          type: "thread.snooze",
          commandId: CommandId.make("cmd-snooze"),
          threadId: ThreadId.make("thread-1"),
          snoozedUntil: FUTURE_WAKE,
        },
        readModel: makeReadModel({}),
      });
      const events = Array.isArray(event) ? event : [event];
      expect(events).toHaveLength(1);
      expect(events[0]?.type).toBe("thread.snoozed");
      if (events[0]?.type === "thread.snoozed") {
        expect(events[0].payload.snoozedUntil).toBe(FUTURE_WAKE);
        expect(events[0].payload.snoozedAt).toBe(events[0].payload.updatedAt);
      }
    }),
  );

  it.effect("rejects a wake time that is not in the future", () =>
    Effect.gen(function* () {
      const error = yield* decideOrchestrationCommand({
        command: {
          type: "thread.snooze",
          commandId: CommandId.make("cmd-snooze-past"),
          threadId: ThreadId.make("thread-1"),
          snoozedUntil: PAST_WAKE,
        },
        readModel: makeReadModel({}),
      }).pipe(Effect.flip);
      expect(error._tag).toBe("OrchestrationCommandInvariantError");
    }),
  );

  it.effect("rejects an unparseable wake time", () =>
    Effect.gen(function* () {
      // IsoDateTime is structurally a string, so garbage can reach the
      // decider; a NaN wake time must never persist as snooze state.
      const error = yield* decideOrchestrationCommand({
        command: {
          type: "thread.snooze",
          commandId: CommandId.make("cmd-snooze-garbage"),
          threadId: ThreadId.make("thread-1"),
          snoozedUntil: "not-a-date",
        },
        readModel: makeReadModel({}),
      }).pipe(Effect.flip);
      expect(error._tag).toBe("OrchestrationCommandInvariantError");
    }),
  );

  it.effect("rejects snoozing blocked-on-you work", () =>
    Effect.gen(function* () {
      const requestActivity = {
        id: EventId.make("activity-req-1"),
        tone: "approval" as const,
        kind: "approval.requested",
        summary: "approval.requested",
        payload: { requestId: "req-1" },
        turnId: null,
        createdAt: NOW,
      } as OrchestrationThread["activities"][number];
      const error = yield* decideOrchestrationCommand({
        command: {
          type: "thread.snooze",
          commandId: CommandId.make("cmd-snooze-blocked"),
          threadId: ThreadId.make("thread-1"),
          snoozedUntil: FUTURE_WAKE,
        },
        readModel: makeReadModel({ activities: [requestActivity] }),
      }).pipe(Effect.flip);
      expect(error._tag).toBe("OrchestrationCommandInvariantError");
    }),
  );

  it.effect("re-emits idempotently for a duplicate snooze to the same wake time", () =>
    Effect.gen(function* () {
      const reEmit = yield* decideOrchestrationCommand({
        command: {
          type: "thread.snooze",
          commandId: CommandId.make("cmd-snooze-again"),
          threadId: ThreadId.make("thread-1"),
          snoozedUntil: FUTURE_WAKE,
        },
        readModel: makeReadModel({ snoozedUntil: FUTURE_WAKE }),
      });
      const events = Array.isArray(reEmit) ? reEmit : [reEmit];
      expect(events).toHaveLength(1);
      if (events[0]?.type === "thread.snoozed") {
        // Original snoozedAt preserved; updatedAt must not churn.
        expect(events[0].payload.snoozedAt).toBe(SNOOZED_AT);
        expect(events[0].payload.updatedAt).toBe(NOW);
      }
    }),
  );

  it.effect("re-snoozing to a DIFFERENT wake time stamps fresh", () =>
    Effect.gen(function* () {
      const event = yield* decideOrchestrationCommand({
        command: {
          type: "thread.snooze",
          commandId: CommandId.make("cmd-snooze-extend"),
          threadId: ThreadId.make("thread-1"),
          snoozedUntil: "1970-01-03T09:00:00.000Z",
        },
        readModel: makeReadModel({ snoozedUntil: FUTURE_WAKE }),
      });
      const events = Array.isArray(event) ? event : [event];
      if (events[0]?.type === "thread.snoozed") {
        expect(events[0].payload.snoozedUntil).toBe("1970-01-03T09:00:00.000Z");
        expect(events[0].payload.updatedAt).not.toBe(NOW);
      }
    }),
  );

  it.effect("unsnoozes with reason user and re-emits idempotently when awake", () =>
    Effect.gen(function* () {
      const event = yield* decideOrchestrationCommand({
        command: {
          type: "thread.unsnooze",
          commandId: CommandId.make("cmd-unsnooze"),
          threadId: ThreadId.make("thread-1"),
          reason: "user",
        },
        readModel: makeReadModel({ snoozedUntil: FUTURE_WAKE }),
      });
      const events = Array.isArray(event) ? event : [event];
      expect(events[0]?.type).toBe("thread.unsnoozed");
      if (events[0]?.type === "thread.unsnoozed") {
        expect(events[0].payload.reason).toBe("user");
        expect(events[0].payload.updatedAt).not.toBe(NOW);
      }

      const awake = yield* decideOrchestrationCommand({
        command: {
          type: "thread.unsnooze",
          commandId: CommandId.make("cmd-unsnooze-awake"),
          threadId: ThreadId.make("thread-1"),
          reason: "user",
        },
        readModel: makeReadModel({}),
      });
      const awakeEvents = Array.isArray(awake) ? awake : [awake];
      expect(awakeEvents[0]?.type).toBe("thread.unsnoozed");
      if (awakeEvents[0]?.type === "thread.unsnoozed") {
        // No state change — keep the existing updatedAt.
        expect(awakeEvents[0].payload.updatedAt).toBe(NOW);
      }
    }),
  );

  it.effect("rejects snoozing a thread with a queued turn start", () =>
    Effect.gen(function* () {
      // The decider clock is the Effect test clock pinned to the epoch: a
      // user message 30s before it with no adopting turn is queued work.
      const queuedMessage = {
        id: MessageId.make("message-queued"),
        role: "user",
        text: "Continue",
        turnId: null,
        streaming: false,
        createdAt: "1969-12-31T23:59:30.000Z",
        updatedAt: "1969-12-31T23:59:30.000Z",
      } as OrchestrationThread["messages"][number];
      const error = yield* decideOrchestrationCommand({
        command: {
          type: "thread.snooze",
          commandId: CommandId.make("cmd-snooze-queued"),
          threadId: ThreadId.make("thread-1"),
          snoozedUntil: FUTURE_WAKE,
        },
        readModel: makeReadModel({ messages: [queuedMessage] }),
      }).pipe(Effect.flip);
      expect(error._tag).toBe("OrchestrationCommandInvariantError");
    }),
  );

  it.effect("rejects snoozing an archived thread", () =>
    Effect.gen(function* () {
      const error = yield* decideOrchestrationCommand({
        command: {
          type: "thread.snooze",
          commandId: CommandId.make("cmd-snooze-archived"),
          threadId: ThreadId.make("thread-1"),
          snoozedUntil: FUTURE_WAKE,
        },
        readModel: makeReadModel({ archivedAt: NOW }),
      }).pipe(Effect.flip);
      expect(error._tag).toBe("OrchestrationCommandInvariantError");
    }),
  );

  it.effect("a user message spends the snooze return ticket (activity wake)", () =>
    Effect.gen(function* () {
      const result = yield* decideOrchestrationCommand({
        command: {
          type: "thread.turn.start",
          commandId: CommandId.make("cmd-turn-start"),
          threadId: ThreadId.make("thread-1"),
          message: {
            messageId: MessageId.make("message-1"),
            role: "user",
            text: "Continue",
            attachments: [],
          },
          runtimeMode: "full-access",
          interactionMode: "default",
          createdAt: NOW,
        },
        readModel: makeReadModel({ snoozedUntil: FUTURE_WAKE }),
      });
      const events = Array.isArray(result) ? result : [result];
      const unsnoozed = events.find((entry) => entry.type === "thread.unsnoozed");
      expect(unsnoozed).toBeDefined();
      if (unsnoozed?.type === "thread.unsnoozed") {
        expect(unsnoozed.payload.reason).toBe("activity");
      }
    }),
  );
});