import { ApprovalRequestId, EnvironmentId, ThreadId } from "@t3tools/contracts";
import { describe, expect, it, vi } from "vite-plus/test";
import {
  questionAttachmentDraftKey,
  questionAttachmentDraftPrefix,
} from "../state/question-attachments";
vi.mock("../state/atom-registry", () => ({ appAtomRegistry: {} }));

import {
  composerAttachmentUploadBlockReason,
  composerAttachmentsStillUploading,
  composerAttachmentUploadKey,
  composerDraftEnvironmentId,
  createComposerAttachmentUploadQueue,
  type ComposerAttachmentUploadRequest,
  type ComposerAttachmentUploadState,
} from "./composerAttachmentUploadQueue";

const environmentId = EnvironmentId.make("environment-1");
function request(id: string, environment = environmentId): ComposerAttachmentUploadRequest {
  return {
    environmentId: environment,
    attachment: {
      id,
      type: "file",
      name: `${id}.pdf`,
      mimeType: "application/pdf",
      sizeBytes: 42,
      fileUri: `file:///documents/${id}.pdf`,
    },
  };
}

describe("composer attachment upload queue", () => {
  it("bounds concurrency, deduplicates updates, and drains all attachments", async () => {
    const gates = new Map<string, ReturnType<typeof Promise.withResolvers<boolean>>>();
    const fourthStarted = Promise.withResolvers<void>();
    const firstThreeStarted = Promise.withResolvers<void>();
    let active = 0;
    let maximum = 0;
    const upload = vi.fn(async (input: ComposerAttachmentUploadRequest) => {
      active += 1;
      maximum = Math.max(maximum, active);
      const gate = Promise.withResolvers<boolean>();
      gates.set(input.attachment.id, gate);
      if (gates.size === 3) firstThreeStarted.resolve();
      if (gates.size === 4) fourthStarted.resolve();
      try {
        return await gate.promise;
      } finally {
        active -= 1;
      }
    });
    const queue = createComposerAttachmentUploadQueue({ upload, onChange: () => {} });
    const requests = [request("one"), request("two"), request("three"), request("four")];
    queue.sync(requests);
    queue.sync(requests);
    await firstThreeStarted.promise;
    expect(upload).toHaveBeenCalledTimes(3);
    gates.get("one")!.resolve(true);
    await fourthStarted.promise;
    for (const gate of gates.values()) gate.resolve(true);
    await queue.settled();
    queue.sync(requests);
    await queue.settled();
    expect(maximum).toBe(3);
    expect(upload).toHaveBeenCalledTimes(4);
    queue.dispose();
  });

  it("cancels on disconnect and resumes from the same local draft on reconnect", async () => {
    const started = Promise.withResolvers<void>();
    let states: Readonly<Record<string, ComposerAttachmentUploadState>> = {};
    let signal: AbortSignal | undefined;
    const upload = vi.fn(
      async (_request: ComposerAttachmentUploadRequest, currentSignal: AbortSignal) => {
        signal = currentSignal;
        started.resolve();
        return new Promise<boolean>((resolve) =>
          currentSignal.addEventListener("abort", () => resolve(false), { once: true }),
        );
      },
    );
    const queue = createComposerAttachmentUploadQueue({
      upload,
      onChange: (next) => {
        states = next;
      },
    });
    const local = request("offline-draft");
    queue.sync([local]);
    await started.promise;
    queue.sync([]);
    await queue.settled();
    expect(signal?.aborted).toBe(true);
    expect(states).toEqual({});
    upload.mockResolvedValueOnce(true);
    queue.sync([local]);
    await queue.settled();
    expect(upload.mock.calls[1]?.[0]).toBe(local);
    expect(states[composerAttachmentUploadKey(environmentId, local.attachment.id)]).toEqual({
      status: "ready",
    });
    expect(local.attachment).toMatchObject({ fileUri: "file:///documents/offline-draft.pdf" });
    queue.dispose();
  });

  it("ignores a late completion after removal or environment switch", async () => {
    const gate = Promise.withResolvers<boolean>();
    const started = Promise.withResolvers<void>();
    let states: Readonly<Record<string, ComposerAttachmentUploadState>> = {};
    const upload = vi.fn(async () => {
      started.resolve();
      return gate.promise;
    });
    const queue = createComposerAttachmentUploadQueue({
      upload,
      onChange: (next) => {
        states = next;
      },
    });
    queue.sync([request("photo")]);
    await started.promise;
    upload.mockResolvedValueOnce(true);
    const other = EnvironmentId.make("environment-2");
    queue.sync([request("photo", other)]);
    gate.resolve(true);
    await queue.settled();
    expect(states).toEqual({ [composerAttachmentUploadKey(other, "photo")]: { status: "ready" } });
    queue.sync([]);
    expect(states).toEqual({});
    queue.dispose();
  });

  it("restarts a re-added attachment after its aborted transfer finishes settling", async () => {
    const firstStarted = Promise.withResolvers<void>();
    const firstSettled = Promise.withResolvers<boolean>();
    const secondStarted = Promise.withResolvers<void>();
    const secondSettled = Promise.withResolvers<boolean>();
    let states: Readonly<Record<string, ComposerAttachmentUploadState>> = {};
    let firstSignal: AbortSignal | undefined;
    const upload = vi.fn(async (_request: ComposerAttachmentUploadRequest, signal: AbortSignal) => {
      if (!firstSignal) {
        firstSignal = signal;
        firstStarted.resolve();
        return firstSettled.promise;
      }
      secondStarted.resolve();
      return secondSettled.promise;
    });
    const queue = createComposerAttachmentUploadQueue({
      upload,
      onChange: (next) => {
        states = next;
      },
    });
    const local = request("re-added");
    queue.sync([local]);
    await firstStarted.promise;
    queue.sync([]);
    queue.sync([local]);
    expect(firstSignal?.aborted).toBe(true);
    expect(upload).toHaveBeenCalledOnce();
    firstSettled.resolve(false);
    await secondStarted.promise;
    expect(upload).toHaveBeenCalledTimes(2);
    secondSettled.resolve(true);
    await queue.settled();
    expect(states[composerAttachmentUploadKey(environmentId, local.attachment.id)]).toEqual({
      status: "ready",
    });
    queue.dispose();
  });

  it("keeps failures stable until retry and reports bounded progress", async () => {
    let states: Readonly<Record<string, ComposerAttachmentUploadState>> = {};
    const progress: number[] = [];
    const upload = vi.fn(
      async (
        _request: ComposerAttachmentUploadRequest,
        _signal: AbortSignal,
        report: (value: number) => void,
      ): Promise<boolean> => {
        report(0.12);
        report(0.13);
        report(1.1);
        throw new Error("Server unavailable");
      },
    );
    const queue = createComposerAttachmentUploadQueue({
      upload,
      onChange: (next) => {
        states = next;
        const state = next[composerAttachmentUploadKey(environmentId, "file")];
        if (state?.status === "uploading") progress.push(state.progress);
      },
    });
    queue.sync([request("file")]);
    await queue.settled();
    queue.sync([request("file")]);
    expect(upload).toHaveBeenCalledOnce();
    expect(states[composerAttachmentUploadKey(environmentId, "file")]).toEqual({
      status: "failed",
      reason: "Server unavailable",
    });
    expect(progress).toEqual([0, 0.1, 1]);
    upload.mockImplementationOnce(async () => true);
    queue.retry(environmentId, "file");
    await queue.settled();
    expect(states[composerAttachmentUploadKey(environmentId, "file")]).toEqual({ status: "ready" });
    queue.dispose();
  });

  it("does not spin when an upload's draft was abandoned before persistence", async () => {
    const upload = vi.fn(async () => false);
    const queue = createComposerAttachmentUploadQueue({ upload, onChange: () => {} });
    queue.sync([request("discarded")]);
    await queue.settled();
    expect(upload).toHaveBeenCalledOnce();
    queue.dispose();
  });
});

describe("draft upload scope and offline submission", () => {
  it("uploads question drafts in their environment without matching other thread prefixes", () => {
    const requestId = ApprovalRequestId.make("request:1");
    for (const environment of [environmentId, EnvironmentId.make("remote:server")]) {
      const threadId = ThreadId.make("thread:1");
      const prefix = questionAttachmentDraftPrefix(environment, threadId);
      const key = questionAttachmentDraftKey(environment, threadId, requestId, "question:1");
      expect(composerDraftEnvironmentId(key, [])).toBe(environment);
      expect(key.startsWith(prefix)).toBe(true);
      for (const suffix of ["-extra", ":extra", "/extra", "%extra"]) {
        const otherKey = questionAttachmentDraftKey(
          environment,
          ThreadId.make(`${threadId}${suffix}`),
          requestId,
          "question:1",
        );
        expect(otherKey.startsWith(prefix)).toBe(false);
        expect(composerDraftEnvironmentId(otherKey, [])).toBe(environment);
      }
    }
  });
  it("resolves thread, new-task, and queued-task drafts without crossing environments", () => {
    expect(composerDraftEnvironmentId("environment-1:thread", [])).toBe(environmentId);
    expect(composerDraftEnvironmentId("new-task:environment-1:project", [])).toBe(environmentId);
    expect(
      composerDraftEnvironmentId("pending-task:message", [{ messageId: "message", environmentId }]),
    ).toBe(environmentId);
    expect(composerDraftEnvironmentId("pending-task:missing", [])).toBeNull();
    const colonEnvironment = EnvironmentId.make("a:vcs-status:b");
    expect(composerDraftEnvironmentId(`${colonEnvironment}:thread`, [])).toBe(colonEnvironment);
    expect(composerDraftEnvironmentId(`new-task:${colonEnvironment}:project`, [])).toBe(
      colonEnvironment,
    );
  });

  it("reads an id-keyed new-task draft's environment from its project stamp", () => {
    const stamped = {
      project: {
        environmentId,
        projectId: "project" as never,
        createdAt: "2026-09-05T00:00:00.000Z",
      },
    };
    expect(composerDraftEnvironmentId("new-task:abc123-def456", [], stamped)).toBe(environmentId);
    // An id-keyed draft that lost its stamp belongs to nobody: uploads must
    // not start and sign-out must not sweep it into some other environment.
    expect(composerDraftEnvironmentId("new-task:abc123-def456", [])).toBeNull();
    // The stamp wins over a legacy-looking key when both are present.
    expect(composerDraftEnvironmentId("new-task:environment-2:project", [], stamped)).toBe(
      environmentId,
    );
  });

  it("only a failed upload blocks sending; an in-flight one queues instead", () => {
    const key = composerAttachmentUploadKey(environmentId, "file");
    const input = {
      environmentId,
      attachments: [request("file").attachment],
      connected: true,
      serverConfig: {
        environment: {
          capabilities: { attachmentUploads: true, fileAttachments: { maxUploadBytes: 1024 } },
        },
      },
      states: {},
    };
    // Not started yet and mid-transfer both let the send through as a queued
    // message; the outbox drain finishes (or redoes) the upload.
    expect(composerAttachmentUploadBlockReason(input)).toBeNull();
    expect(composerAttachmentsStillUploading(input)).toBe(true);
    expect(
      composerAttachmentsStillUploading({
        ...input,
        states: { [key]: { status: "uploading", progress: 0.6 } },
      }),
    ).toBe(true);
    expect(composerAttachmentUploadBlockReason({ ...input, connected: false })).toBeNull();
    expect(
      composerAttachmentUploadBlockReason({
        ...input,
        states: { [key]: { status: "failed", reason: "Offline" } },
      }),
    ).toBe("Retry or remove the failed attachment");
    expect(
      composerAttachmentsStillUploading({
        ...input,
        states: { [key]: { status: "failed", reason: "Offline" } },
      }),
    ).toBe(false);
    expect(
      composerAttachmentUploadBlockReason({ ...input, states: { [key]: { status: "ready" } } }),
    ).toBeNull();
    expect(
      composerAttachmentsStillUploading({ ...input, states: { [key]: { status: "ready" } } }),
    ).toBe(false);
    // Attachments the environment cannot accept never count as uploading.
    expect(composerAttachmentsStillUploading({ ...input, serverConfig: null })).toBe(false);
  });
});