import { describe, expect, it, vi } from "vitest";

import { browserDataFailure } from "../../src/adapters/browser-file-storage/result.ts";
import { createResumableUploadRuntime } from "../../src/adapters/browser-transfer/resumable-upload/resumable-upload-runtime.ts";
import {
  activeSignal,
  byteStreamSource,
  createControlHarness,
  executorFor,
  MemoryCheckpointStore,
  noContentionLock,
  runtimePolicy,
} from "./resumable-upload-runtime-fixture.ts";

/**
 * TR-RR-06. A non-cooperative mutation lock or provider must not make teardown
 * unbounded: `dispose()` bounds its drain and reports honestly when the runtime
 * is still CLOSING, and an abort is admitted physical work it cannot step over.
 */
describe("TR-RR-06 bounded resumable teardown", () => {
  it("reports an unproved drain instead of waiting forever", async () => {
    const checkpoints = new MemoryCheckpointStore();
    const harness = createControlHarness();
    const runtime = createResumableUploadRuntime({
      controlPlane: harness.control,
      partExecutor: executorFor(harness, { delay: async () => {} }),
      checkpoints,
      // A lock that never grants: dispose must still be bounded.
      mutationLock: Object.freeze({
        async run<Value>(): Promise<Value> {
          return await new Promise<never>(() => {});
        },
      }),
      crypto,
      policy: runtimePolicy({ cleanupDeadlineMs: 20 }),
      now: () => 1_000,
      random: () => 0,
      sleep: async () => {},
    });

    void runtime.upload({
      uploadKey: "upload_key_hung",
      purpose: "attachment",
      mediaType: "application/octet-stream",
      source: byteStreamSource(new Uint8Array([1, 2, 3, 4, 5])),
      signal: activeSignal,
    });
    await Promise.resolve();
    await Promise.resolve();

    const disposed = await runtime.dispose();
    expect(disposed.ok).toBe(false);
    // Still CLOSING: physical work the caller must not treat as finished.
    expect(runtime.lifecycle()).toBe("CLOSING");
    expect(checkpoints.closed).toBe(false);
  });

  it("closes once every admitted operation settles", async () => {
    const checkpoints = new MemoryCheckpointStore();
    const harness = createControlHarness();
    const runtime = createResumableUploadRuntime({
      controlPlane: harness.control,
      partExecutor: executorFor(harness, { delay: async () => {} }),
      checkpoints,
      mutationLock: noContentionLock,
      crypto,
      policy: runtimePolicy({ cleanupDeadlineMs: 200 }),
      now: () => 1_000,
      random: () => 0,
      sleep: async () => {},
    });
    const disposed = await runtime.dispose();
    expect(disposed).toMatchObject({ ok: true });
    expect(runtime.lifecycle()).toBe("CLOSED");
    expect(checkpoints.closed).toBe(true);
  });
});

/**
 * TR-04. `dispose()` proved quiescence from the wrapper registry only. A
 * provider that ignored its attempt deadline let the wrapper settle first and
 * leave the set empty, so teardown reported a drained runtime — and closed the
 * checkpoint store — while the provider was still running.
 */
describe("TR-04 teardown waits for raw provider work, not only its wrapper", () => {
  it("refuses to report a drained runtime while a provider is still running", async () => {
    const harness = createControlHarness();
    const checkpoints = new MemoryCheckpointStore();
    const closeStore = vi.spyOn(checkpoints, "close");
    let releaseProvider: (() => void) | undefined;
    // Ignores the attempt signal entirely and outlives its own deadline.
    harness.control.createSession = () =>
      new Promise((resolve) => {
        releaseProvider = () =>
          resolve(
            browserDataFailure("UNAVAILABLE", "UPLOAD_SESSION", {
              retryable: true,
              recovery: "RESUME",
            }),
          );
      });

    const runtime = createResumableUploadRuntime({
      controlPlane: harness.control,
      partExecutor: executorFor(harness),
      checkpoints,
      mutationLock: noContentionLock,
      crypto,
      policy: runtimePolicy({
        providerAttemptTimeoutMs: 5,
        cleanupDeadlineMs: 25,
        maxRetries: 0,
      }),
      now: () => 1_000,
      random: () => 0,
      sleep: async () => {},
    });

    const uploading = runtime.upload({
      uploadKey: "upload_key_raw",
      purpose: "attachment",
      mediaType: "application/octet-stream",
      source: byteStreamSource(new Uint8Array([1, 2, 3, 4, 5])),
      signal: activeSignal,
    });
    await vi.waitFor(() => expect(releaseProvider).toBeDefined());
    // The wrapper has already given up on the attempt.
    await uploading;

    const disposed = await runtime.dispose();
    expect(disposed.ok).toBe(false);
    if (!disposed.ok) {
      expect(disposed.error.code).toBe("UNAVAILABLE");
      expect(disposed.error.recovery).toBe("RESUME");
    }
    // The store stays open while something could still write a checkpoint.
    expect(closeStore).not.toHaveBeenCalled();

    releaseProvider?.();
  });

  it("reports a drained runtime once the raw provider settles", async () => {
    const harness = createControlHarness();
    const checkpoints = new MemoryCheckpointStore();
    let releaseProvider: (() => void) | undefined;
    harness.control.createSession = () =>
      new Promise((resolve) => {
        releaseProvider = () =>
          resolve(
            browserDataFailure("UNAVAILABLE", "UPLOAD_SESSION", {
              retryable: true,
              recovery: "RESUME",
            }),
          );
      });

    const runtime = createResumableUploadRuntime({
      controlPlane: harness.control,
      partExecutor: executorFor(harness),
      checkpoints,
      mutationLock: noContentionLock,
      crypto,
      policy: runtimePolicy({
        providerAttemptTimeoutMs: 5,
        cleanupDeadlineMs: 1_000,
        maxRetries: 0,
      }),
      now: () => 1_000,
      random: () => 0,
      sleep: async () => {},
    });

    const uploading = runtime.upload({
      uploadKey: "upload_key_raw_2",
      purpose: "attachment",
      mediaType: "application/octet-stream",
      source: byteStreamSource(new Uint8Array([1, 2, 3, 4, 5])),
      signal: activeSignal,
    });
    await vi.waitFor(() => expect(releaseProvider).toBeDefined());
    await uploading;

    const disposing = runtime.dispose();
    releaseProvider?.();
    await expect(disposing).resolves.toMatchObject({ ok: true });
    expect(runtime.lifecycle()).toBe("CLOSED");
  });
});