import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test";

const mocks = vi.hoisted(() => ({ createPlayer: vi.fn() }));
vi.mock("expo-video", () => ({ createVideoPlayer: mocks.createPlayer }));

let thumbnails: typeof import("./videoThumbnails");
const frame = { width: 480, height: 270 };
const player = () => ({
  replaceAsync: vi.fn(async (): Promise<void> => {}),
  generateThumbnailsAsync: vi.fn(async () => [frame]),
  release: vi.fn(),
});
const source = () => ({ uri: "file:///clip.mp4", dispose: vi.fn() });

beforeEach(async () => {
  vi.resetModules();
  mocks.createPlayer.mockReset().mockImplementation(player);
  thumbnails = await import("./videoThumbnails");
});

afterEach(() => vi.useRealTimers());

describe("video thumbnails", () => {
  it("reuses a frame for duplicate requests and refreshed signed URLs", async () => {
    const file = source();
    const resolveSource = vi.fn(async () => file);
    const signal = new AbortController().signal;
    const results = await Promise.all([
      thumbnails.loadVideoThumbnail("env:clip", resolveSource, signal),
      thumbnails.loadVideoThumbnail("env:clip", resolveSource, signal),
    ]);
    expect(results).toEqual([frame, frame]);
    expect(resolveSource).toHaveBeenCalledTimes(1);
    expect(mocks.createPlayer).toHaveBeenCalledTimes(1);
    expect(file.dispose).toHaveBeenCalledTimes(1);
    const refreshed = vi.fn(async () => ({ ...source(), uri: "https://host/new-token/clip.mp4" }));
    expect(await thumbnails.loadVideoThumbnail("env:clip", refreshed, signal)).toBe(frame);
    expect(refreshed).not.toHaveBeenCalled();
  });

  it("serializes decoding and skips queued requests that scroll out of view", async () => {
    const started = Promise.withResolvers<void>();
    const generated = Promise.withResolvers<(typeof frame)[]>();
    const first = player();
    first.generateThumbnailsAsync.mockImplementation(() => {
      started.resolve();
      return generated.promise;
    });
    mocks.createPlayer.mockReturnValueOnce(first);
    const firstRequest = thumbnails.loadVideoThumbnail(
      "first",
      async () => source(),
      new AbortController().signal,
    );
    await started.promise;
    const removed = new AbortController();
    const skipped = vi.fn(async () => source());
    const queued = thumbnails.loadVideoThumbnail("removed", skipped, removed.signal);
    const next = vi.fn(async () => source());
    const nextRequest = thumbnails.loadVideoThumbnail("next", next, new AbortController().signal);
    expect(next).not.toHaveBeenCalled();
    removed.abort();
    generated.resolve([frame]);
    expect(await firstRequest).toBe(frame);
    expect(await queued).toBeNull();
    expect(await nextRequest).toBe(frame);
    expect(skipped).not.toHaveBeenCalled();
    expect(first.release).toHaveBeenCalledTimes(1);
  });

  it("releases an active canceled player and ignores late source loading", async () => {
    const started = Promise.withResolvers<void>();
    const replaced = Promise.withResolvers<void>();
    const first = player();
    first.replaceAsync.mockImplementation(() => {
      started.resolve();
      return replaced.promise;
    });
    mocks.createPlayer.mockReturnValueOnce(first);
    const file = source();
    const controller = new AbortController();
    const request = thumbnails.loadVideoThumbnail("canceled", async () => file, controller.signal);
    await started.promise;
    controller.abort();
    expect(await request).toBeNull();
    expect(first.release).toHaveBeenCalledTimes(1);
    expect(file.dispose).toHaveBeenCalledTimes(1);
    replaced.resolve();
    expect(
      await thumbnails.loadVideoThumbnail(
        "next",
        async () => source(),
        new AbortController().signal,
      ),
    ).toBe(frame);
    expect(first.generateThumbnailsAsync).not.toHaveBeenCalled();
    expect(thumbnails.cachedVideoThumbnail("canceled")).toBeNull();
  });

  it("releases failed extractions and permits a later retry", async () => {
    const broken = player();
    broken.generateThumbnailsAsync.mockRejectedValue(new Error("Invalid video"));
    mocks.createPlayer.mockReturnValueOnce(broken);
    const file = source();
    expect(
      await thumbnails.loadVideoThumbnail("retry", async () => file, new AbortController().signal),
    ).toBeNull();
    expect(broken.release).toHaveBeenCalledTimes(1);
    expect(file.dispose).toHaveBeenCalledTimes(1);
    expect(
      await thumbnails.loadVideoThumbnail(
        "retry",
        async () => source(),
        new AbortController().signal,
      ),
    ).toBe(frame);
  });

  it("does not let an unreachable source block the queue indefinitely", async () => {
    vi.useFakeTimers();
    const started = Promise.withResolvers<void>();
    const first = player();
    first.replaceAsync.mockImplementation(() => {
      started.resolve();
      return new Promise(() => {});
    });
    mocks.createPlayer.mockReturnValueOnce(first);
    const file = source();
    const request = thumbnails.loadVideoThumbnail(
      "unreachable",
      async () => file,
      new AbortController().signal,
    );
    await started.promise;
    await vi.advanceTimersByTimeAsync(15_000);
    expect(await request).toBeNull();
    expect(first.release).toHaveBeenCalledTimes(1);
    expect(file.dispose).toHaveBeenCalledTimes(1);
    expect(
      await thumbnails.loadVideoThumbnail(
        "reachable",
        async () => source(),
        new AbortController().signal,
      ),
    ).toBe(frame);
  });

  it("bounds the retained native images without invalidating frames still displayed", async () => {
    for (let i = 0; i < 33; i++) {
      await thumbnails.loadVideoThumbnail(
        `clip:${i}`,
        async () => source(),
        new AbortController().signal,
      );
    }
    expect(thumbnails.cachedVideoThumbnail("clip:0")).toBeNull();
    expect(thumbnails.cachedVideoThumbnail("clip:32")).toBe(frame);
    expect(mocks.createPlayer).toHaveBeenCalledTimes(33);
    expect(
      await thumbnails.loadVideoThumbnail(
        "clip:0",
        async () => source(),
        new AbortController().signal,
      ),
    ).toBe(frame);
    expect(mocks.createPlayer).toHaveBeenCalledTimes(34);
  });
});