import {
  CommandId,
  ProjectId,
  ProviderInstanceId,
  ThreadId,
  type OrchestrationReadModel,
} 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";
const PINNED_AT = "1969-12-30T00:00:00.000Z";

function makeReadModel(input: {
  readonly pinnedAt?: string | null;
  readonly pinOrderKey?: string | null;
  readonly archivedAt?: string | null;
  readonly settledOverride?: "settled" | "active" | null;
  readonly settledAt?: string | null;
  readonly snoozedUntil?: string | null;
  readonly snoozedAt?: string | null;
}): 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: input.settledOverride ?? null,
        settledAt: input.settledAt ?? (input.settledOverride === "settled" ? NOW : null),
        snoozedUntil: input.snoozedUntil ?? null,
        snoozedAt: input.snoozedAt ?? (input.snoozedUntil != null ? PINNED_AT : null),
        pinnedAt: input.pinnedAt ?? null,
        pinOrderKey: input.pinOrderKey ?? null,
        deletedAt: null,
        messages: [],
        proposedPlans: [],
        activities: [],
        checkpoints: [],
        session: null,
      },
    ],
    updatedAt: NOW,
  };
}

it.layer(NodeServices.layer)("pinned thread decider", (it) => {
  it.effect("pins a thread, stamping pinnedAt and updatedAt together", () =>
    Effect.gen(function* () {
      const event = yield* decideOrchestrationCommand({
        command: {
          type: "thread.pin",
          commandId: CommandId.make("cmd-pin"),
          threadId: ThreadId.make("thread-1"),
        },
        readModel: makeReadModel({}),
      });
      const events = Array.isArray(event) ? event : [event];
      expect(events).toHaveLength(1);
      expect(events[0]?.type).toBe("thread.pinned");
      if (events[0]?.type === "thread.pinned") {
        expect(events[0].payload.pinnedAt).toBe(events[0].payload.updatedAt);
      }
    }),
  );

  it.effect("re-pinning preserves the original pinnedAt and updatedAt", () =>
    Effect.gen(function* () {
      const event = yield* decideOrchestrationCommand({
        command: {
          type: "thread.pin",
          commandId: CommandId.make("cmd-pin-again"),
          threadId: ThreadId.make("thread-1"),
        },
        readModel: makeReadModel({ pinnedAt: PINNED_AT }),
      });
      const events = Array.isArray(event) ? event : [event];
      expect(events[0]?.type).toBe("thread.pinned");
      if (events[0]?.type === "thread.pinned") {
        expect(events[0].payload.pinnedAt).toBe(PINNED_AT);
        expect(events[0].payload.updatedAt).toBe(NOW);
      }
    }),
  );

  it.effect("unpins a pinned thread", () =>
    Effect.gen(function* () {
      const event = yield* decideOrchestrationCommand({
        command: {
          type: "thread.unpin",
          commandId: CommandId.make("cmd-unpin"),
          threadId: ThreadId.make("thread-1"),
        },
        readModel: makeReadModel({ pinnedAt: PINNED_AT }),
      });
      const events = Array.isArray(event) ? event : [event];
      expect(events[0]?.type).toBe("thread.unpinned");
      if (events[0]?.type === "thread.unpinned") {
        expect(events[0].payload.updatedAt).not.toBe(NOW);
      }
    }),
  );

  it.effect("unpinning an unpinned thread preserves updatedAt", () =>
    Effect.gen(function* () {
      const event = yield* decideOrchestrationCommand({
        command: {
          type: "thread.unpin",
          commandId: CommandId.make("cmd-unpin-noop"),
          threadId: ThreadId.make("thread-1"),
        },
        readModel: makeReadModel({}),
      });
      const events = Array.isArray(event) ? event : [event];
      expect(events[0]?.type).toBe("thread.unpinned");
      if (events[0]?.type === "thread.unpinned") {
        expect(events[0].payload.updatedAt).toBe(NOW);
      }
    }),
  );

  it.effect("pinning a settled thread also un-settles it", () =>
    Effect.gen(function* () {
      const event = yield* decideOrchestrationCommand({
        command: {
          type: "thread.pin",
          commandId: CommandId.make("cmd-pin-settled"),
          threadId: ThreadId.make("thread-1"),
        },
        readModel: makeReadModel({ settledOverride: "settled" }),
      });
      const events = Array.isArray(event) ? event : [event];
      expect(events.map((entry) => entry.type)).toEqual(["thread.pinned", "thread.unsettled"]);
      const unsettled = events.find((entry) => entry.type === "thread.unsettled");
      if (unsettled?.type === "thread.unsettled") {
        expect(unsettled.payload.reason).toBe("user");
      }
    }),
  );

  it.effect("pinning a snoozed thread also wakes it", () =>
    Effect.gen(function* () {
      const event = yield* decideOrchestrationCommand({
        command: {
          type: "thread.pin",
          commandId: CommandId.make("cmd-pin-snoozed"),
          threadId: ThreadId.make("thread-1"),
        },
        readModel: makeReadModel({ snoozedUntil: "1970-01-02T09:00:00.000Z" }),
      });
      const events = Array.isArray(event) ? event : [event];
      expect(events.map((entry) => entry.type)).toEqual(["thread.pinned", "thread.unsnoozed"]);
    }),
  );

  it.effect("pinning an unparked thread emits only thread.pinned", () =>
    Effect.gen(function* () {
      const event = yield* decideOrchestrationCommand({
        command: {
          type: "thread.pin",
          commandId: CommandId.make("cmd-pin-plain"),
          threadId: ThreadId.make("thread-1"),
        },
        readModel: makeReadModel({}),
      });
      const events = Array.isArray(event) ? event : [event];
      expect(events.map((entry) => entry.type)).toEqual(["thread.pinned"]);
    }),
  );

  it.effect("settling a pinned thread also unpins it", () =>
    Effect.gen(function* () {
      const event = yield* decideOrchestrationCommand({
        command: {
          type: "thread.settle",
          commandId: CommandId.make("cmd-settle-pinned"),
          threadId: ThreadId.make("thread-1"),
        },
        readModel: makeReadModel({ pinnedAt: PINNED_AT }),
      });
      const events = Array.isArray(event) ? event : [event];
      expect(events.map((entry) => entry.type)).toEqual(["thread.settled", "thread.unpinned"]);
    }),
  );

  it.effect("settling an unpinned thread emits no unpin event", () =>
    Effect.gen(function* () {
      const event = yield* decideOrchestrationCommand({
        command: {
          type: "thread.settle",
          commandId: CommandId.make("cmd-settle-unpinned"),
          threadId: ThreadId.make("thread-1"),
        },
        readModel: makeReadModel({}),
      });
      const events = Array.isArray(event) ? event : [event];
      expect(events.map((entry) => entry.type)).toEqual(["thread.settled"]);
    }),
  );

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

  it.effect("a fresh pin carries the client's order key", () =>
    Effect.gen(function* () {
      const event = yield* decideOrchestrationCommand({
        command: {
          type: "thread.pin",
          commandId: CommandId.make("cmd-pin-keyed"),
          threadId: ThreadId.make("thread-1"),
          orderKey: "g",
        },
        readModel: makeReadModel({}),
      });
      const events = Array.isArray(event) ? event : [event];
      expect(events[0]?.type).toBe("thread.pinned");
      if (events[0]?.type === "thread.pinned") {
        expect(events[0].payload.pinOrderKey).toBe("g");
      }
    }),
  );

  it.effect(
    "re-pinning ignores the incoming order key so raced pins cannot move a placed thread",
    () =>
      Effect.gen(function* () {
        const event = yield* decideOrchestrationCommand({
          command: {
            type: "thread.pin",
            commandId: CommandId.make("cmd-pin-keyed-again"),
            threadId: ThreadId.make("thread-1"),
            orderKey: "t",
          },
          readModel: makeReadModel({ pinnedAt: PINNED_AT, pinOrderKey: "g" }),
        });
        const events = Array.isArray(event) ? event : [event];
        expect(events[0]?.type).toBe("thread.pinned");
        if (events[0]?.type === "thread.pinned") {
          expect(events[0].payload.pinOrderKey).toBeUndefined();
        }
      }),
  );

  it.effect("reorders a pinned thread, stamping the new key", () =>
    Effect.gen(function* () {
      const event = yield* decideOrchestrationCommand({
        command: {
          type: "thread.pin.reorder",
          commandId: CommandId.make("cmd-reorder"),
          threadId: ThreadId.make("thread-1"),
          orderKey: "m",
        },
        readModel: makeReadModel({ pinnedAt: PINNED_AT, pinOrderKey: "g" }),
      });
      const events = Array.isArray(event) ? event : [event];
      expect(events[0]?.type).toBe("thread.pin-reordered");
      if (events[0]?.type === "thread.pin-reordered") {
        expect(events[0].payload.orderKey).toBe("m");
        // A real move stamps the command time (the test clock), not the
        // thread's previous updatedAt.
        expect(events[0].payload.updatedAt).not.toBe(NOW);
      }
    }),
  );

  it.effect("reordering onto the same key preserves updatedAt", () =>
    Effect.gen(function* () {
      const event = yield* decideOrchestrationCommand({
        command: {
          type: "thread.pin.reorder",
          commandId: CommandId.make("cmd-reorder-noop"),
          threadId: ThreadId.make("thread-1"),
          orderKey: "g",
        },
        readModel: makeReadModel({ pinnedAt: PINNED_AT, pinOrderKey: "g" }),
      });
      const events = Array.isArray(event) ? event : [event];
      expect(events[0]?.type).toBe("thread.pin-reordered");
      if (events[0]?.type === "thread.pin-reordered") {
        expect(events[0].payload.updatedAt).toBe(NOW);
      }
    }),
  );

  it.effect("rejects reordering an unpinned thread", () =>
    Effect.gen(function* () {
      const error = yield* decideOrchestrationCommand({
        command: {
          type: "thread.pin.reorder",
          commandId: CommandId.make("cmd-reorder-unpinned"),
          threadId: ThreadId.make("thread-1"),
          orderKey: "m",
        },
        readModel: makeReadModel({}),
      }).pipe(Effect.flip);
      expect(error._tag).toBe("OrchestrationCommandInvariantError");
    }),
  );
});