const size = navigator.hardwareConcurrency;

function choosePoolSize(options?: { max?: number; min?: number }) {
  const logical = navigator.hardwareConcurrency || 2;
  const min = options?.min ?? 1;
  const max = options?.max ?? 4;

  // Reserve capacity for browser, rendering, OS, and other tabs.
  const reserved = 1;
  const candidate = Math.max(min, logical - reserved);

  return Math.min(candidate, max);
}

const pool = new WorkerPool({ size: 2 });

const pool = new WorkerPool({ minSize: 0, maxSize: 3, idleTtlMs: 30_000 });

const pool = new WorkerPool({
  minSize: 1,
  maxSize: choosePoolSize({ max: 4 }),
  scaleUpWhenQueueDepthAtLeast: 2,
  idleTtlMs: 20_000,
});

type TaskPriority = "user-blocking" | "normal" | "background";

type PoolTask<TPayload = unknown> = {
  id: string;
  kind: string;
  payload: TPayload;
  transfer?: Transferable[];

  priority: TaskPriority;
  createdAt: number;
  deadlineAt?: number;
  timeoutMs: number;

  idempotencyKey?: string;
  supersedesKey?: string;
  estimatedCost?: "small" | "medium" | "large";
  estimatedBytes?: number;

  signal?: AbortSignal;
};

function admit(task: PoolTask, queue: PoolTask[], policy: PoolPolicy) {
  if (task.signal?.aborted) {
    return { ok: false as const, reason: "aborted" };
  }

  if (task.deadlineAt !== undefined && performance.now() > task.deadlineAt) {
    return { ok: false as const, reason: "expired" };
  }

  if (queue.length >= policy.maxQueueDepth) {
    return { ok: false as const, reason: "queue_full" };
  }

  const queuedBytes = queue.reduce((sum, item) => sum + (item.estimatedBytes ?? 0), 0);
  if (queuedBytes + (task.estimatedBytes ?? 0) > policy.maxQueuedBytes) {
    return { ok: false as const, reason: "queue_bytes_exceeded" };
  }

  return { ok: true as const };
}

const priorityRank: Record<TaskPriority, number> = {
  "user-blocking": 0,
  normal: 1,
  background: 2,
};

function pickNextTask(queue: PoolTask[]) {
  const now = performance.now();

  let bestIndex = -1;
  let best: PoolTask | undefined;

  for (let i = 0; i < queue.length; i++) {
    const task = queue[i];

    if (task.deadlineAt !== undefined && task.deadlineAt <= now) {
      continue;
    }

    if (!best) {
      best = task;
      bestIndex = i;
      continue;
    }

    const rankA = priorityRank[task.priority];
    const rankB = priorityRank[best.priority];

    if (rankA < rankB) {
      best = task;
      bestIndex = i;
    }
  }

  if (bestIndex === -1) return undefined;
  return queue.splice(bestIndex, 1)[0];
}

function chooseWorker(workers: PoolWorker[], task: PoolTask) {
  const idle = workers.filter((worker) => worker.state === "idle");
  if (idle.length === 0) return undefined;

  if (task.kind.startsWith("search.")) {
    const warm = idle.find((worker) => worker.capabilities.has("search-index-loaded"));
    if (warm) return warm;
  }

  return idle[0];
}

type PoolPolicy = {
  minSize: number;
  maxSize: number;
  maxQueueDepth: number;
  maxQueuedBytes: number;
  idleTtlMs: number;
};

type PoolWorker = {
  id: string;
  worker: Worker;
  state: "starting" | "idle" | "running" | "draining" | "failed" | "terminated";
  currentTaskId?: string;
  generation: number;
  capabilities: Set<string>;
  lastUsedAt: number;
};

type Pending = {
  resolve: (value: unknown) => void;
  reject: (reason: unknown) => void;
  timeoutId: number;
  startedAt?: number;
};

class WorkerPool {
  private workers = new Map<string, PoolWorker>();
  private queue: PoolTask[] = [];
  private pending = new Map<string, Pending>();
  private generation = 0;

  constructor(
    private readonly createWorker: () => Worker,
    private readonly policy: PoolPolicy,
  ) {}

  async submit<T>(task: PoolTask): Promise<T> {
    const admission = admit(task, this.queue, this.policy);
    if (!admission.ok) {
      throw new Error(`Worker pool rejected task: ${admission.reason}`);
    }

    return new Promise<T>((resolve, reject) => {
      const timeoutId = window.setTimeout(() => {
        this.pending.delete(task.id);
        reject(new Error(`Task timed out: ${task.id}`));
      }, task.timeoutMs);

      this.pending.set(task.id, { resolve: resolve as (value: unknown) => void, reject, timeoutId });
      this.queue.push(task);
      this.scaleIfNeeded();
      this.drain();
    });
  }

  private scaleIfNeeded() {
    const live = [...this.workers.values()].filter((w) => w.state !== "terminated");
    const idle = live.filter((w) => w.state === "idle");

    if (this.queue.length > idle.length && live.length < this.policy.maxSize) {
      this.spawnWorker();
    }
  }

  private spawnWorker() {
    const id = crypto.randomUUID();
    const worker = this.createWorker();
    const poolWorker: PoolWorker = {
      id,
      worker,
      state: "starting",
      generation: ++this.generation,
      capabilities: new Set(),
      lastUsedAt: performance.now(),
    };

    worker.onmessage = (event) => this.handleMessage(poolWorker, event.data);
    worker.onerror = (event) => this.handleWorkerFailure(poolWorker, event.error ?? event.message);
    worker.onmessageerror = () => this.handleWorkerFailure(poolWorker, new Error("messageerror"));

    this.workers.set(id, poolWorker);

    worker.postMessage({ type: "pool.init", workerId: id, generation: poolWorker.generation });
  }

  private drain() {
    while (true) {
      const idle = [...this.workers.values()].find((w) => w.state === "idle");
      if (!idle) return;

      const task = pickNextTask(this.queue);
      if (!task) return;

      idle.state = "running";
      idle.currentTaskId = task.id;
      idle.lastUsedAt = performance.now();

      const pending = this.pending.get(task.id);
      if (pending) pending.startedAt = performance.now();

      idle.worker.postMessage(
        {
          type: "task.run",
          taskId: task.id,
          kind: task.kind,
          payload: task.payload,
          deadlineAt: task.deadlineAt,
        },
        task.transfer ?? [],
      );
    }
  }

  private handleMessage(poolWorker: PoolWorker, message: any) {
    if (message?.type === "pool.ready") {
      poolWorker.state = "idle";
      for (const capability of message.capabilities ?? []) {
        poolWorker.capabilities.add(capability);
      }
      this.drain();
      return;
    }

    if (message?.type === "task.result" || message?.type === "task.error") {
      const taskId = message.taskId;
      const pending = this.pending.get(taskId);

      poolWorker.currentTaskId = undefined;
      poolWorker.state = "idle";
      poolWorker.lastUsedAt = performance.now();

      if (!pending) {
        // Stale result, timed-out task, cancelled task, or duplicate message.
        this.drain();
        return;
      }

      clearTimeout(pending.timeoutId);
      this.pending.delete(taskId);

      if (message.type === "task.result") {
        pending.resolve(message.result);
      } else {
        pending.reject(new Error(message.error?.message ?? "Worker task failed"));
      }

      this.drain();
    }
  }

  private handleWorkerFailure(poolWorker: PoolWorker, reason: unknown) {
    poolWorker.state = "failed";

    if (poolWorker.currentTaskId) {
      const pending = this.pending.get(poolWorker.currentTaskId);
      if (pending) {
        clearTimeout(pending.timeoutId);
        this.pending.delete(poolWorker.currentTaskId);
        pending.reject(reason);
      }
    }

    try {
      poolWorker.worker.terminate();
    } finally {
      poolWorker.state = "terminated";
      this.workers.delete(poolWorker.id);
      this.scaleIfNeeded();
      this.drain();
    }
  }
}

type WorkerTaskMessage = {
  type: "task.run";
  taskId: string;
  kind: string;
  payload: unknown;
  deadlineAt?: number;
};

const handlers: Record<string, (payload: unknown, ctx: TaskContext) => Promise<unknown>> = {
  "csv.parse": parseCsv,
  "search.buildIndex": buildSearchIndex,
  "diff.compute": computeDiff,
};

type TaskContext = {
  taskId: string;
  deadlineAt?: number;
  throwIfExpired(): void;
};

self.onmessage = async (event) => {
  const message = event.data;

  if (message?.type === "pool.init") {
    self.postMessage({ type: "pool.ready", capabilities: Object.keys(handlers) });
    return;
  }

  if (message?.type !== "task.run") return;

  const task = message as WorkerTaskMessage;
  const handler = handlers[task.kind];

  if (!handler) {
    self.postMessage({
      type: "task.error",
      taskId: task.taskId,
      error: { code: "UNKNOWN_TASK_KIND", message: task.kind },
    });
    return;
  }

  const ctx: TaskContext = {
    taskId: task.taskId,
    deadlineAt: task.deadlineAt,
    throwIfExpired() {
      if (task.deadlineAt !== undefined && performance.now() > task.deadlineAt) {
        throw new Error("Task deadline expired");
      }
    },
  };

  try {
    const result = await handler(task.payload, ctx);
    self.postMessage({ type: "task.result", taskId: task.taskId, result });
  } catch (error) {
    self.postMessage({
      type: "task.error",
      taskId: task.taskId,
      error: serializeError(error),
    });
  }
};

function serializeError(error: unknown) {
  if (error instanceof Error) {
    return { name: error.name, message: error.message, stack: error.stack };
  }
  return { name: "UnknownError", message: String(error) };
}

function cancelTask(taskId: string) {
  const queuedIndex = this.queue.findIndex((task) => task.id === taskId);

  if (queuedIndex >= 0) {
    this.queue.splice(queuedIndex, 1);
    const pending = this.pending.get(taskId);
    if (pending) {
      clearTimeout(pending.timeoutId);
      pending.reject(new DOMException("Task aborted", "AbortError"));
      this.pending.delete(taskId);
    }
    return;
  }

  const running = [...this.workers.values()].find((worker) => worker.currentTaskId === taskId);
  if (running) {
    running.worker.postMessage({ type: "task.cancel", taskId });
  }
}

type FailureKey = `${string}:${string}`; // kind:fingerprint
const failureCounts = new Map<FailureKey, number>();

function recordFailure(kind: string, fingerprint: string) {
  const key: FailureKey = `${kind}:${fingerprint}`;
  const next = (failureCounts.get(key) ?? 0) + 1;
  failureCounts.set(key, next);

  if (next >= 3) {
    openCircuitForTaskShape(kind, fingerprint);
  }
}

let searchGeneration = 0;

async function runSearch(query: string) {
  const generation = ++searchGeneration;

  const result = await pool.submit<SearchResult>({
    id: crypto.randomUUID(),
    kind: "search.query",
    payload: { query },
    priority: "user-blocking",
    createdAt: performance.now(),
    timeoutMs: 5_000,
  });

  if (generation !== searchGeneration) {
    return; // stale result
  }

  renderSearchResult(result);
}

type PoolSnapshot = {
  workers: Array<{
    id: string;
    state: PoolWorker["state"];
    currentTaskId?: string;
    generation: number;
    lastUsedAt: number;
  }>;
  queue: Array<{
    id: string;
    kind: string;
    priority: TaskPriority;
    createdAt: number;
    deadlineAt?: number;
  }>;
  pendingCount: number;
};

if (import.meta.env.DEV) {
  Object.assign(window, {
    __workerPoolDebug: () => pool.snapshot(),
  });
}