import {
  CommandId,
  EnvironmentId,
  MessageId,
  ProjectId,
  ProviderInstanceId,
  ThreadId,
} from "@t3tools/contracts";
import { describe, expect, it } from "vite-plus/test";

import {
  isPendingThreadCreationVisible,
  pendingThreadCreationMessage,
  pendingThreadCreationShell,
  resolvePendingThreadCreation,
  type PendingThreadCreation,
} from "./pending-thread-creation";
import type { QueuedThreadMessage } from "./thread-outbox-model";

const creation: QueuedThreadMessage = {
  environmentId: EnvironmentId.make("environment-1"),
  threadId: ThreadId.make("thread-1"),
  messageId: MessageId.make("message-1"),
  commandId: CommandId.make("command-1"),
  text: "Fix the flaky login test",
  attachments: [
    {
      id: "draft-image",
      type: "image",
      name: "screen.png",
      mimeType: "image/png",
      sizeBytes: 10,
      previewUri: "data:image/png;base64,AAAA",
    },
  ],
  modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.6-sol" },
  runtimeMode: "full-access",
  creation: {
    projectId: ProjectId.make("project-1"),
    workspaceMode: "worktree",
    branch: "main",
    worktreePath: null,
  },
  createdAt: "2026-08-24T12:00:00.000Z",
};

describe("resolvePendingThreadCreation", () => {
  const threadKey = `${creation.environmentId}:${creation.threadId}`;
  const pending: PendingThreadCreation = { message: creation, outcome: null };
  const prompt = { id: creation.messageId };

  it("keeps setup visible through the prompt echo and shell cleanup until detail has a turn", () => {
    let previous = resolvePendingThreadCreation({
      threadKey,
      pending,
      previous: null,
      detail: null,
    });
    expect(previous).toBe(pending);

    previous = resolvePendingThreadCreation({
      threadKey,
      pending,
      previous,
      detail: { messages: [], latestTurn: null, session: null },
    });
    expect(previous).toBe(pending);

    // The user message arrives before the provider publishes a timed turn.
    previous = resolvePendingThreadCreation({
      threadKey,
      pending,
      previous,
      detail: { messages: [prompt], latestTurn: null, session: { status: "starting" } },
    });
    expect(previous).toBe(pending);

    // The shell stream may observe the turn and collect the global outcome
    // before this screen's detail stream catches up.
    previous = resolvePendingThreadCreation({
      threadKey,
      pending: null,
      previous,
      detail: { messages: [prompt], latestTurn: null, session: { status: "starting" } },
    });
    expect(previous).toBe(pending);

    expect(
      resolvePendingThreadCreation({
        threadKey,
        pending: null,
        previous,
        detail: {
          messages: [prompt],
          latestTurn: { turnId: "turn-1" },
          session: { status: "running" },
        },
      }),
    ).toBeNull();
  });

  it("keeps the prompt until both the turn and its message have arrived", () => {
    expect(
      resolvePendingThreadCreation({
        threadKey,
        pending,
        previous: null,
        detail: { messages: [], latestTurn: { turnId: "turn-1" }, session: { status: "running" } },
      }),
    ).toBe(pending);
  });

  it.each(["error", "stopped", "interrupted"])("ends setup when startup is %s", (status) => {
    expect(
      resolvePendingThreadCreation({
        threadKey,
        pending: null,
        previous: pending,
        detail: { messages: [prompt], latestTurn: null, session: { status } },
      }),
    ).toBeNull();
  });

  it("preserves rejected task recovery", () => {
    const failed: PendingThreadCreation = {
      message: creation,
      outcome: { kind: "failed", message: creation, reason: "Checkout failed" },
    };
    expect(
      resolvePendingThreadCreation({
        threadKey,
        pending: failed,
        previous: pending,
        detail: { messages: [], latestTurn: null, session: { status: "error" } },
      }),
    ).toBe(failed);
  });

  it("does not carry setup into another thread or invent it for existing threads", () => {
    expect(
      resolvePendingThreadCreation({
        threadKey: "another-thread",
        pending: null,
        previous: pending,
        detail: null,
      }),
    ).toBeNull();
    expect(
      resolvePendingThreadCreation({
        threadKey,
        pending: null,
        previous: null,
        detail: null,
      }),
    ).toBeNull();
  });
});

describe("pendingThreadCreationShell", () => {
  it("shapes a queued creation as the thread shell the screen renders before creation", () => {
    expect(pendingThreadCreationShell(creation)).toMatchObject({
      environmentId: creation.environmentId,
      id: creation.threadId,
      projectId: creation.creation!.projectId,
      title: "Fix the flaky login test",
      modelSelection: creation.modelSelection,
      runtimeMode: "full-access",
      interactionMode: "default",
      branch: "main",
      worktreePath: null,
      latestTurn: null,
      session: null,
      latestUserMessageAt: creation.createdAt,
    });
  });

  it("keeps a local task's explicit worktree path", () => {
    expect(
      pendingThreadCreationShell({
        ...creation,
        creation: {
          ...creation.creation!,
          workspaceMode: "local",
          worktreePath: "/repo/.worktrees/feature",
        },
      })?.worktreePath,
    ).toBe("/repo/.worktrees/feature");
  });

  it("returns null for a follow-up message or a creation without a model", () => {
    expect(pendingThreadCreationShell({ ...creation, creation: undefined })).toBeNull();
    expect(pendingThreadCreationShell({ ...creation, modelSelection: undefined })).toBeNull();
  });
});

describe("isPendingThreadCreationVisible", () => {
  const creationMessageId = String(creation.messageId);

  it("stands in before any detail has loaded", () => {
    expect(isPendingThreadCreationVisible({ creationMessageId, loadedMessageIds: null })).toBe(
      true,
    );
  });

  // The regression: the server creates the thread, THEN builds the worktree,
  // then starts the turn. The shell and an empty detail arrive seconds before
  // the prompt, and keying on the shell left the thread empty for that whole
  // window.
  it("keeps standing in while the created thread has no messages yet", () => {
    expect(isPendingThreadCreationVisible({ creationMessageId, loadedMessageIds: [] })).toBe(true);
  });

  it("keeps standing in when the thread holds only unrelated messages", () => {
    expect(
      isPendingThreadCreationVisible({ creationMessageId, loadedMessageIds: ["someone-else"] }),
    ).toBe(true);
  });

  it("stands down once the delivered prompt lands under the same id", () => {
    expect(
      isPendingThreadCreationVisible({
        creationMessageId,
        loadedMessageIds: ["someone-else", creationMessageId],
      }),
    ).toBe(false);
  });
});

describe("pendingThreadCreationMessage", () => {
  it("renders the queued prompt as the first user message", () => {
    expect(pendingThreadCreationMessage(creation)).toEqual({
      id: creation.messageId,
      role: "user",
      text: creation.text,
      turnId: null,
      streaming: false,
      createdAt: creation.createdAt,
      updatedAt: creation.createdAt,
    });
  });

  // Draft attachment ids are local; the feed resolves attachment rows against
  // the server and would spin forever on them.
  it("omits the queued attachments rather than passing local draft ids to the feed", () => {
    expect(pendingThreadCreationMessage(creation)).not.toHaveProperty("attachments");
  });
});