import { parentPort, workerData } from 'node:worker_threads';

const fibonacci = (n) => {
  if (n <= 1) return n;
  return fibonacci(n - 1) + fibonacci(n - 2);
};

// parentPort 是 node:worker_threads 模块中 `Worker 线程` 特有的属性，类型为 MessagePort 或 null（非 Worker 线程时为 null）。
// 作为 Worker 线程与父线程（通常为主线程）的双向通信接口，实现跨线程的消息传递。
// Worker 线程通过 parentPort 发送 / 接收消息，父线程通过 Worker 实例的事件接口（如 worker.on('message')）与之交互。
// 本质是 MessagePort 实例
// parentPort.postMessage(value[, transferList]): value：需传递的数据，必须是可序列化的 JavaScript 值（支持循环引用、RegExp、Map、Set 等）。
// parentPort.postMessage(value[, transferList]):transferList（可选）：包含 Transferable 对象（如 ArrayBuffer、MessagePort、FileHandle）的数组，用于零拷贝传输（转移所有权后发送方不可再访问）。
parentPort.postMessage(fibonacci(workerData));

// 监听父线程消息并回复
parentPort.on('message', (msg) => {
  console.log('Received from main:', msg);
  parentPort.postMessage('Message received!');
});


// workerData
// workerData 是 Worker 线程中的一个只读属性，类型为 任意 JavaScript 值（由父线程传递并克隆而来）。
// 作为父线程向 Worker 线程传递初始化数据的载体，用于在 Worker 启动时传递配置参数、输入数据等。

import { Worker,isMainThread } from 'node:worker_threads';

let worker;
const computeFibonacci = (num) => {
  return new Promise((resolve, reject) => {
    worker = new Worker('./fibonacci.mjs', { workerData: num });   
    worker.on('message', resolve);
    worker.on('error', reject);
    worker.on('exit', (code) => {
      if (code !== 0) reject(new Error(`Worker stopped with exit code ${code}`));
    });
  });
};
computeFibonacci(30).then(result => {
  console.log(`Fibonacci result: ${result}`);
  if (worker) {
    worker.postMessage(result);
    setTimeout(() => {
      worker.terminate(); // 终止worker线程 
    }, 1000);
   
  }
}).catch(err => {
  console.error(err);
});

console.log("This is：" + (isMainThread?' main thread':' worker thread'))

// 输出结果：
// This is： main thread
// Fibonacci result: 832040

import worker from 'node:worker_threads';
console.log(worker);

{
  isMainThread: true,
  MessagePort: [Function: MessagePort],
  MessageChannel: [Function: MessageChannel],
  markAsUntransferable: [Function: markAsUntransferable],
  moveMessagePortToContext: [Function: moveMessagePortToContext],
  receiveMessageOnPort: [Function: receiveMessageOnPort],
  resourceLimits: {},
  threadId: 0,
  SHARE_ENV: Symbol(nodejs.worker_threads.SHARE_ENV),
  Worker: [class Worker extends EventEmitter],
  parentPort: null,
  workerData: null,
  BroadcastChannel: [class BroadcastChannel extends EventTarget],
  setEnvironmentData: [Function: setEnvironmentData],
  getEnvironmentData: [Function: getEnvironmentData]
}

// 主线程（main.js）
const { Worker } = require('worker_threads');
const path = require('path');

const imagePaths = ['image1.jpg', 'image2.jpg', /* ... 1000个路径 */];

imagePaths.forEach((imagePath) => {
  const worker = new Worker(path.resolve('./image-worker.js'), {
    workerData: imagePath
  });

  worker.on('message', (result) => {
    console.log(`压缩完成: ${result}`);
  });

  worker.on('error', (err) => {
    console.error(`Worker 错误: ${err}`);
  });
});

// Worker 线程（image-worker.js）
const { workerData, parentPort } = require('worker_threads');
const sharp = require('sharp'); // 图像处理库

async function compressImage(imagePath) {
  await sharp(imagePath)
    .resize(800, 600)
    .jpeg({ quality: 80 })
    .toFile(`compressed_${imagePath}`);
}

compressImage(workerData)
  .then(() => parentPort.postMessage(workerData))
  .catch(console.error);

// 主线程（main.js）
const { Worker, isMainThread, parentPort } = require('worker_threads');

if (isMainThread) {
  const matrixA = /* 生成矩阵 A */;
  const matrixB = /* 生成矩阵 B */;
  const chunkSize = 1000;

  // 将矩阵分块
  const chunks = [];
  for (let i = 0; i < matrixA.length; i += chunkSize) {
    chunks.push({
      a: matrixA.slice(i, i + chunkSize),
      b: matrixB,
      startRow: i
    });
  }

  // 为每个分块创建 Worker
  const results = new Array(matrixA.length);
  chunks.forEach((chunk) => {
    const worker = new Worker(__filename, { workerData: chunk });
    worker.on('message', (rows) => {
      rows.forEach((row, idx) => {
        results[chunk.startRow + idx] = row;
      });
    });
  });

} else {
  // Worker 线程
  const { multiplyMatrices } = require('./math-utils');

  const chunk = workerData;
  const resultChunk = multiplyMatrices(chunk.a, chunk.b);
  parentPort.postMessage(resultChunk);
}

// 主线程（main.js）
const { Worker } = require('worker_threads');

const sensorData = [/* 10 万条数据 */];
const threadCount = 4;
const chunkSize = Math.ceil(sensorData.length / threadCount);

for (let i = 0; i < threadCount; i++) {
  const worker = new Worker('./stats-worker.js', {
    workerData: {
      data: sensorData.slice(i * chunkSize, (i + 1) * chunkSize),
      chunkId: i
    }
  });

  worker.on('message', (localStats) => {
    // 合并所有 Worker 的统计结果
    aggregateStats(localStats);
  });
}

// Worker 线程（stats-worker.js）
const { workerData, parentPort } = require('worker_threads');

function calculateStats(data) {
  const sum = data.reduce((acc, val) => acc + val, 0);
  const avg = sum / data.length;
  return { sum, avg };
}

const result = calculateStats(workerData.data);
parentPort.postMessage(result);

// 主线程（main.js）
const { Worker } = require('worker_threads');
const zlib = require('zlib');
const fs = require('fs');

const files = ['log1.txt', 'log2.txt', /* ... 50个文件 */];

files.forEach((file) => {
  const worker = new Worker('./compress-worker.js', {
    workerData: file
  });

  worker.on('exit', () => {
    console.log(`${file} 压缩完成`);
  });
});

// Worker 线程（compress-worker.js）
const { workerData, parentPort } = require('worker_threads');
const zlib = require('zlib');
const fs = require('fs');

const fileContent = fs.readFileSync(workerData);
zlib.gzip(fileContent, (err, compressed) => {
  fs.writeFileSync(`${workerData}.gz`, compressed);
  parentPort.postMessage('done');
});