// Worker 线程代码
self.onmessage = (event) => {
  const { data } = event;
  const result = heavyCompute(data);
  self.postMessage(result);
};

function heavyCompute(n: number) {
  let sum = 0;
  for (let i = 0; i < n; i++) sum += i;
  return sum;
}

// 主线程
const worker = new Worker(new URL("./worker.ts", import.meta.url), {
  type: "module",
});

worker.onmessage = (event) => {
  console.log("计算结果:", event.data);
};

worker.postMessage(2_000_000_000);

import ComputeWorker from "./worker?worker";

const worker = new ComputeWorker();
worker.postMessage(2_000_000_000);

// 生成 100MB 的 Buffer
const buffer = new ArrayBuffer(100 * 1024 * 1024);

// 第二个参数是 transfer list，标记需要转移所有权的对象
worker.postMessage({ buffer }, [buffer]);

// 转移后，buffer 不可再用（byteLength 变为 0）
console.log(buffer.byteLength); // 0

self.onmessage = (event) => {
  const { buffer } = event.data;
  // Worker 拿到了原始内存，没有任何拷贝
  const view = new Uint8Array(buffer);
  // ... 处理 ...
  // 处理完再转回去
  self.postMessage({ buffer }, [buffer]);
};

// 创建 4 字节共享内存
const sab = new SharedArrayBuffer(4);
const view = new Int32Array(sab);

// 发给 Worker，不是转移而是共享，双方都能读写
worker.postMessage({ sab });

// 主线程修改
view[0] = 42;

self.onmessage = (event) => {
  const view = new Int32Array(event.data.sab);
  // 直接读到主线程写入的值
  console.log(view[0]); // 42
};

class WorkerPool {
  private workers: Worker[] = []
  private queue: Array<{ data: unknown; resolve: (v: unknown) => void }> = []
  // 记录每个 Worker 当前对应的 resolve，为空表示空闲
  private pending = new Map<Worker, (v: unknown) => void>()

  constructor(workerUrl: URL, size = navigator.hardwareConcurrency) {
    for (let i = 0; i < size; i++) {
      const w = new Worker(workerUrl, { type: 'module' })
      w.onmessage = (e) => {
        // 通知等待该 Worker 结果的调用方
        this.pending.get(w)?.(e.data)
        this.pending.delete(w)
        // 继续消费队列
        const next = this.queue.shift()
        if (next) {
          this.pending.set(w, next.resolve)
          w.postMessage(next.data)
        }
        // 无队列任务时 pending 中无此 Worker，视为空闲
      }
      this.workers.push(w)
    }
  }

  run(data: unknown): Promise<unknown> {
    return new Promise((resolve) => {
      const worker = this.workers.find(w => !this.pending.has(w))
      if (worker) {
        this.pending.set(worker, resolve)
        worker.postMessage(data)
      } else {
        this.queue.push({ data, resolve })
      }
    })
  }
}

self.onmessage = (event: MessageEvent<ArrayBuffer>) => {
  const text = new TextDecoder().decode(event.data);
  const lines = text.split("\n");
  const headers = lines[0].split(",");

  const rows = lines.slice(1).map((line) => {
    const values = line.split(",");
    return Object.fromEntries(headers.map((h, i) => [h, values[i]]));
  });

  self.postMessage(rows);
};

import CsvWorker from "./csv-worker?worker";

async function parseCSV(file: File) {
  const buffer = await file.arrayBuffer();
  const worker = new CsvWorker();

  return new Promise<Record<string, string>[]>((resolve) => {
    worker.onmessage = (e) => {
      resolve(e.data);
      worker.terminate();
    };
    // 零拷贝传输 ArrayBuffer
    worker.postMessage(buffer, [buffer]);
  });
}

[lib]
crate-type = ["cdylib"]

[dependencies]
wasm-bindgen = "0.2"

use wasm_bindgen::prelude::*;

// #[wasm_bindgen] 标记暴露给 JS 的函数
#[wasm_bindgen]
pub fn fibonacci(n: u32) -> u32 {
    match n {
        0 => 0,
        1 => 1,
        _ => fibonacci(n - 1) + fibonacci(n - 2),
    }
}

#[wasm_bindgen]
pub fn sum_array(arr: &[f64]) -> f64 {
    arr.iter().sum()
}

import init, { fibonacci, sum_array } from "./pkg/my_wasm_lib.js";

// WASM 需要异步初始化（下载 + 编译 .wasm 文件）
await init();

console.log(fibonacci(40)); // ~102334155，毫秒级完成

const arr = new Float64Array([1, 2, 3, 4, 5]);
console.log(sum_array(arr)); // 15

import { createFFmpeg, fetchFile } from "@ffmpeg/ffmpeg";

const ffmpeg = createFFmpeg({ log: false });

self.onmessage = async (
  event: MessageEvent<{ file: ArrayBuffer; name: string }>,
) => {
  const { file, name } = event.data;

  if (!ffmpeg.isLoaded()) {
    await ffmpeg.load();
  }

  ffmpeg.FS("writeFile", name, new Uint8Array(file));

  await ffmpeg.run("-i", name, "-c:v", "libx264", "-crf", "23", "output.mp4");

  const output = ffmpeg.FS("readFile", "output.mp4");

  // 转移所有权，零拷贝返回
  self.postMessage({ result: output.buffer }, [output.buffer]);
};

import FFmpegWorker from "./ffmpeg-worker?worker";

export async function transcodeVideo(file: File): Promise<Blob> {
  const buffer = await file.arrayBuffer();
  const worker = new FFmpegWorker();

  return new Promise((resolve, reject) => {
    worker.onmessage = (e) => {
      const blob = new Blob([e.data.result], { type: "video/mp4" });
      resolve(blob);
      worker.terminate();
    };
    worker.onerror = reject;
    worker.postMessage({ file: buffer, name: file.name }, [buffer]);
  });
}