import { pipeline, env } from "https://cdn.jsdelivr.net/npm/@xenova/transformers@2.17.2";
import { analyzeLongText } from "./ner_long_text.js?v=20260514-offsets1";

let pipe = null;
let modelName = null;

self.addEventListener("message", async (event) => {
  const message = event.data ?? {};
  const requestId = message.requestId ?? null;

  try {
    if (message.type === "init") {
      await loadModel(message.modelName, requestId, message.revision ?? null);
      return;
    }

    if (message.type === "analyze") {
      await runAnalysis(message, requestId);
      return;
    }

    if (message.type === "dispose") {
      pipe = null;
      modelName = null;
      self.postMessage({ type: "disposed", requestId });
    }
  } catch (error) {
    self.postMessage({
      type: "error",
      requestId,
      message: error instanceof Error ? error.message : String(error),
    });
  }
});

async function loadModel(nextModelName, requestId, revision = null) {
  const modelKey = `${nextModelName}@${revision ?? "main"}`;
  if (pipe && modelName === modelKey) {
    self.postMessage({ type: "ready", requestId });
    return;
  }

  env.allowLocalModels = false;
  env.useBrowserCache = true;
  modelName = modelKey;

  self.postMessage({ type: "status", requestId, message: "Chargement du modèle..." });

  const options = {
    progress_callback: (progress) => {
      if (progress.status !== "progress" || !progress.total) {
        return;
      }

      const pct = Math.round((progress.loaded / progress.total) * 100);
      self.postMessage({
        type: "model-progress",
        requestId,
        progress: pct,
        message: `Téléchargement... ${pct}%`,
      });
    },
  };

  if (revision) {
    options.revision = revision;
  }

  pipe = await pipeline("token-classification", nextModelName, options);

  self.postMessage({ type: "ready", requestId });
}

async function runAnalysis(message, requestId) {
  if (!pipe) {
    await loadModel(message.modelName, requestId, message.revision ?? null);
  }

  const analysis = await analyzeLongText(pipe, message.text, {
    chunkOptions: message.chunkOptions ?? {},
    minScore: message.minScore ?? 0,
    onProgress: ({ done, total }) => {
      self.postMessage({
        type: "analysis-progress",
        requestId,
        done,
        total,
        progress: total ? Math.round((done / total) * 100) : 0,
        message: `Analyse chunk ${done}/${total}`,
      });
    },
  });

  self.postMessage({
    type: "result",
    requestId,
    analysis,
  });
}