import {
  FileRenderer,
  disposeHighlighter,
  getSharedHighlighter,
  type BaseCodeOptions,
  type DiffsHighlighter,
  type FileContents,
  type HighlightedToken,
} from "@pierre/diffs";
import { TextDocument } from "@pierre/diffs/editor";
import { WorkerPoolManager, type WorkerRequest, type WorkerResponse } from "@pierre/diffs/worker";
import * as NodeWorkerThreads from "node:worker_threads";
import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test";

type DocumentChange = NonNullable<ReturnType<TextDocument<unknown>["applyEdits"]>>;
interface Tokenizer {
  tokenize(change: DocumentChange): Map<number, HighlightedToken[]>;
  cleanUp(): void;
}

const tokenizerUrl = new URL("./editor/tokenizer.js", import.meta.resolve("@pierre/diffs"));
const { EditorTokenizer } = (await import(/* @vite-ignore */ tokenizerUrl.href)) as {
  EditorTokenizer: new (options: {
    codeOptions: BaseCodeOptions;
    highlighter: DiffsHighlighter;
    textDocument: TextDocument<unknown>;
    setStyle: (style: string) => void;
    onDeferTokenize: () => void;
  }) => Tokenizer;
};

const workerModule = import.meta.resolve("@pierre/diffs/worker/worker.js");
const options = {
  theme: "pierre-dark",
  themeType: "dark",
  preferredHighlighter: "shiki-wasm",
  useTokenTransformer: true,
} as const;
const source = "export const View = () => <div>Ready</div>;";
let pool: WorkerPoolManager;
let renderer: FileRenderer;
let terminationPromises: Promise<number>[];

class WorkerTransport {
  private readonly worker = new NodeWorkerThreads.Worker(
    `const { parentPort, workerData } = require("node:worker_threads");
     globalThis.self = {
       addEventListener(type, listener) {
         if (type === "message") parentPort.on("message", data => listener({ data }));
         if (type === "error") process.on("uncaughtException", listener);
       }
     };
     globalThis.postMessage = data => parentPort.postMessage(data);
     import(workerData.moduleUrl);`,
    { eval: true, workerData: { moduleUrl: workerModule }, execArgv: [] },
  );

  addEventListener(
    type: "message" | "error",
    listener: (event: { data: WorkerResponse } | Error) => void,
  ) {
    if (type === "error") this.worker.on("error", listener);
    else this.worker.on("message", (data: WorkerResponse) => listener({ data }));
  }

  postMessage(message: WorkerRequest) {
    this.worker.postMessage(message, []);
  }

  terminate() {
    terminationPromises.push(this.worker.terminate());
  }
}

function firstEnter(highlighter: DiffsHighlighter, file: FileContents, language: string) {
  const document = new TextDocument(file.name, file.contents, language);
  const tokenizer = new EditorTokenizer({
    codeOptions: options,
    highlighter,
    textDocument: document,
    setStyle: () => {},
    onDeferTokenize: () => {},
  });
  try {
    const end = document.positionAt(file.contents.length);
    const change = document.applyEdits([{ range: { start: end, end }, newText: "\n" }]);
    expect(change).toBeDefined();
    // This is the synchronous first edit, before the tokenizer's debounced prebuild.
    const dirtyLines = tokenizer.tokenize(change!);
    expect([...dirtyLines.keys()]).toEqual([0, 1]);
    expect(document.getText()).toBe(`${file.contents}\n`);
  } finally {
    tokenizer.cleanUp();
  }
}

beforeEach(async () => {
  terminationPromises = [];
  vi.stubGlobal("requestAnimationFrame", (callback: FrameRequestCallback) =>
    setImmediate(() => callback(0)),
  );
  vi.stubGlobal("cancelAnimationFrame", clearImmediate);
  vi.stubGlobal("window", { matchMedia: () => ({ matches: true }) });
  await disposeHighlighter();
  pool = new WorkerPoolManager(
    // Adapt transport only. The installed Pierre worker resolves and highlights the file.
    { workerFactory: () => new WorkerTransport() as unknown as globalThis.Worker, poolSize: 1 },
    options,
  );
  await pool.initialize();
  renderer = new FileRenderer(options, undefined, pool);
});

afterEach(async () => {
  renderer?.cleanUp();
  pool?.terminate();
  await Promise.all(terminationPromises);
  await disposeHighlighter();
  vi.unstubAllGlobals();
});

describe("editable file language readiness", () => {
  it.each(["hydrate", "renderFile"] as const)(
    "%s prepares the inferred language before the first edit of a worker-highlighted file",
    async (method) => {
      const file = { name: "cold.tsx", contents: source, cacheKey: "cold-tsx" };
      await pool.primeFileHighlightCache(file);
      expect(pool.getFileResultCache(file)).toBeDefined();
      const mainHighlighter = await getSharedHighlighter({
        themes: ["pierre-dark"],
        langs: ["text"],
      });
      expect(mainHighlighter.getLoadedLanguages()).not.toContain("tsx");
      renderer[method](file);
      // Read-only worker rendering must not load editor grammars on the main thread.
      expect(mainHighlighter.getLoadedLanguages()).not.toContain("tsx");
      const highlighter = await renderer.initializeHighlighter();
      firstEnter(highlighter, file, "tsx");
    },
  );

  it.each(["hydrate", "renderFile"] as const)(
    "%s respects an explicit language when the filename suggests plain text",
    async (method) => {
      const file: FileContents = {
        name: "source.txt",
        lang: "tsx",
        contents: source,
        cacheKey: "explicit-tsx",
      };
      await pool.primeFileHighlightCache(file);
      renderer[method](file);
      firstEnter(await renderer.initializeHighlighter(), file, "tsx");
    },
  );

  it("loads a newly opened language after reusing a worker-backed renderer", async () => {
    const previousFile: FileContents = {
      name: "previous.ts",
      contents: "export const value = 1;",
      cacheKey: "previous-ts",
    };
    await getSharedHighlighter({ themes: ["pierre-dark"], langs: ["typescript"] });
    renderer.renderFile(previousFile);
    firstEnter(await renderer.initializeHighlighter(), previousFile, "typescript");
    const nextFile = { name: "next.tsx", contents: source, cacheKey: "next-tsx" };
    renderer.renderFile(nextFile);
    firstEnter(await renderer.initializeHighlighter(), nextFile, "tsx");
  });

  it("prepares a hydrated non-worker file even when its theme was already loaded", async () => {
    renderer.cleanUp();
    renderer = new FileRenderer(options);
    const file = { name: "local.tsx", contents: source, cacheKey: "local-tsx" };
    renderer.hydrate(file);
    firstEnter(await renderer.initializeHighlighter(), file, "tsx");
  });

  it("keeps plain text editable without loading an unrelated grammar", async () => {
    const file = { name: "notes.txt", contents: "Plain text", cacheKey: "plain-text" };
    renderer.renderFile(file);
    const highlighter = await renderer.initializeHighlighter();
    firstEnter(highlighter, file, "text");
    expect(highlighter.getLoadedLanguages()).not.toContain("tsx");
  });
});