import { createServer } from 'node:http';

// CPU-інтенсивна функція: обчислення чисел Фібоначчі через рекурсію
function fibonacci(n: number): number {
  if (n <= 1) return n;
  return fibonacci(n - 1) + fibonacci(n - 2);
}

const server = createServer((req, res) => {
  if (req.url === '/fast') {
    // Легка операція: миттєва відповідь
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({ message: 'Швидка відповідь', timestamp: Date.now() }));
  } else if (req.url === '/slow') {
    // Важка операція: обчислення fibonacci(45) блокує потік на ~5-10 секунд
    console.log('Початок обчислення fibonacci(45)...');
    const startTime = Date.now();
    
    const result = fibonacci(45);
    
    const duration = Date.now() - startTime;
    console.log(`Обчислення завершено за ${duration}мс`);
    
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({ result, duration }));
  } else {
    res.writeHead(404);
    res.end('Not Found');
  }
});

server.listen(3000, () => {
  console.log('Сервер запущено на http://localhost:3000');
  console.log('Спробуйте: /fast та /slow');
});

import { parentPort } from 'node:worker_threads';

// Функція обчислення чисел Фібоначчі
function fibonacci(n: number): number {
  if (n <= 1) return n;
  return fibonacci(n - 1) + fibonacci(n - 2);
}

// Слухаємо повідомлення від головного потоку
parentPort?.on('message', (n: number) => {
  console.log(`[Worker] Отримано запит: fibonacci(${n})`);
  
  const startTime = Date.now();
  const result = fibonacci(n);
  const duration = Date.now() - startTime;
  
  console.log(`[Worker] Обчислення завершено за ${duration}мс`);
  
  // Відправляємо результат назад у головний потік
  parentPort?.postMessage({ result, duration });
});

console.log('[Worker] Робочий потік запущено');

import { createServer } from 'node:http';
import { Worker } from 'node:worker_threads';
import { resolve } from 'node:path';

const server = createServer((req, res) => {
  if (req.url === '/fast') {
    // Легка операція: виконується у головному потоці
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({ message: 'Швидка відповідь', timestamp: Date.now() }));
  } else if (req.url === '/slow') {
    console.log('[Main] Створення Worker для обчислення fibonacci(45)...');
    
    // Створюємо новий Worker Thread
    const worker = new Worker(resolve(__dirname, 'worker.ts'));
    
    // Слухаємо відповідь від Worker
    worker.on('message', ({ result, duration }) => {
      console.log(`[Main] Результат отримано від Worker: ${result}`);
      
      res.writeHead(200, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ result, duration }));
      
      // Завершуємо Worker після отримання результату
      worker.terminate();
    });
    
    worker.on('error', (error) => {
      console.error('[Main] Помилка Worker:', error);
      res.writeHead(500);
      res.end('Internal Server Error');
    });
    
    // Відправляємо завдання у Worker
    worker.postMessage(45);
  } else {
    res.writeHead(404);
    res.end('Not Found');
  }
});

server.listen(3000, () => {
  console.log('Сервер запущено на http://localhost:3000');
  console.log('[Main] Event Loop ВІЛЬНИЙ для обробки інших запитів');
});

import { Worker } from 'node:worker_threads';
import { resolve } from 'node:path';

const worker = new Worker(resolve(__dirname, 'worker.ts'), {
  // Опціональні налаштування
  workerData: { initialValue: 42 }, // Початкові дані для Worker
  env: process.env,                  // Змінні оточення (за замовчуванням успадковуються)
  resourceLimits: {
    maxOldGenerationSizeMb: 512,     // Обмеження пам'яті (MB)
    maxYoungGenerationSizeMb: 64,
  },
});

import { parentPort } from 'node:worker_threads';

if (!parentPort) {
  throw new Error('Цей скрипт повинен виконуватися як Worker Thread');
}

// Відправка повідомлення у головний потік
parentPort.postMessage({ status: 'ready', timestamp: Date.now() });

// Отримання повідомлень від головного потоку
parentPort.on('message', (data) => {
  console.log('Отримано від головного потоку:', data);
  
  // Обробка даних та відправка відповіді
  const result = processData(data);
  parentPort.postMessage({ result });
});

// Обробка помилок
parentPort.on('error', (error) => {
  console.error('Помилка комунікації:', error);
});

// Подія закриття потоку
parentPort.on('close', () => {
  console.log('Канал комунікації закрито');
});

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

if (isMainThread) {
  // Код головного потоку
  console.log('Виконується у головному потоці');
  
  const worker = new Worker(__filename); // Запускаємо цей же файл як Worker
  
  worker.on('message', (message) => {
    console.log('Отримано від Worker:', message);
  });
  
  worker.postMessage('Hello from main thread');
} else {
  // Код Worker потоку
  console.log('Виконується у Worker потоці');
  
  parentPort?.on('message', (message) => {
    console.log('Отримано від головного потоку:', message);
    parentPort?.postMessage('Hello from worker thread');
  });
}

// main.ts — головний потік
import { Worker } from 'node:worker_threads';

const worker = new Worker('./worker.ts', {
  workerData: {
    taskId: 'task-001',
    config: {
      timeout: 5000,
      retries: 3,
    },
    filePath: '/path/to/data.json',
  },
});

// worker.ts — робочий потік
import { workerData, parentPort } from 'node:worker_threads';

interface WorkerData {
  taskId: string;
  config: {
    timeout: number;
    retries: number;
  };
  filePath: string;
}

const data = workerData as WorkerData;

console.log(`[Worker ${data.taskId}] Запущено з конфігурацією:`, data.config);
console.log(`[Worker ${data.taskId}] Обробка файлу: ${data.filePath}`);

// Виконання роботи...
const result = await processFile(data.filePath, data.config);

parentPort?.postMessage({ taskId: data.taskId, result });

// Головний потік
const worker = new Worker('./worker.ts');

const complexData = {
  timestamp: new Date(),
  users: [
    { id: 1, name: 'Олександр' },
    { id: 2, name: 'Марія' },
  ],
  metadata: new Map([
    ['version', '1.0.0'],
    ['author', 'kostyl.dev'],
  ]),
  binary: new Uint8Array([1, 2, 3, 4, 5]),
};

worker.postMessage(complexData);

// Worker потік
parentPort?.on('message', (data) => {
  console.log('Date:', data.timestamp instanceof Date); // true
  console.log('Map:', data.metadata instanceof Map);     // true
  console.log('TypedArray:', data.binary instanceof Uint8Array); // true
  
  // Зміни у Worker НЕ впливають на головний потік (окремі копії)
  data.users.push({ id: 3, name: 'Іван' });
});

const worker = new Worker('./worker.ts');

try {
  // ❌ Помилка: функції не підтримуються
  worker.postMessage({
    callback: () => console.log('Hello'),
  });
} catch (error) {
  console.error('Помилка postMessage:', error);
  // DataCloneError: () => console.log('Hello') could not be cloned.
}

try {
  // ❌ Помилка: циклічні посилання
  const obj: any = { name: 'Test' };
  obj.self = obj; // Циклічне посилання
  
  worker.postMessage(obj);
} catch (error) {
  console.error('Помилка postMessage:', error);
  // DataCloneError: Circular reference in value argument not supported
}

// Головний потік
const worker = new Worker('./worker.ts');

// Створюємо великий буфер (100 МБ)
const hugeBuffer = new ArrayBuffer(100 * 1024 * 1024);
const uint8View = new Uint8Array(hugeBuffer);

// Заповнюємо даними
for (let i = 0; i < uint8View.length; i++) {
  uint8View[i] = i % 256;
}

console.log('Розмір буфера:', hugeBuffer.byteLength, 'байт');
console.log('Передача буфера у Worker...');

// ✅ Передаємо ArrayBuffer як transferable (миттєво)
worker.postMessage({ buffer: hugeBuffer }, [hugeBuffer]);

// ❌ Після передачі hugeBuffer у головному потоці стає недоступним!
console.log('Розмір буфера після передачі:', hugeBuffer.byteLength); // 0

// Worker потік
import { parentPort } from 'node:worker_threads';

parentPort?.on('message', ({ buffer }) => {
  console.log('[Worker] Отримано буфер:', buffer.byteLength, 'байт');
  
  // Тепер Worker володіє буфером — можна читати та модифікувати
  const view = new Uint8Array(buffer);
  console.log('[Worker] Перші 10 байтів:', view.slice(0, 10));
  
  // Обробка даних...
  
  // Передаємо буфер назад у головний потік
  parentPort?.postMessage({ processedBuffer: buffer }, [buffer]);
  
  // Після передачі buffer у Worker стає недоступним
  console.log('[Worker] Розмір після повернення:', buffer.byteLength); // 0
});

worker.postMessage(data, [transferableObject1, transferableObject2, ...]);

// main.ts — головний потік
import { Worker } from 'node:worker_threads';
import { resolve } from 'node:path';

// Створюємо спільний буфер на 4 байти (один Int32)
const sharedBuffer = new SharedArrayBuffer(4);
const sharedArray = new Int32Array(sharedBuffer);

// Початкове значення лічильника
sharedArray[0] = 0;

console.log('[Main] Початкове значення:', sharedArray[0]);

// Створюємо 4 Worker-потоки
const workers: Worker[] = [];

for (let i = 0; i < 4; i++) {
  const worker = new Worker(resolve(__dirname, 'counter-worker.ts'), {
    workerData: { workerId: i, sharedBuffer },
  });
  
  worker.on('message', (message) => {
    console.log(`[Main] Worker ${i}:`, message);
  });
  
  workers.push(worker);
}

// Через 2 секунди перевіряємо значення лічильника
setTimeout(() => {
  console.log('[Main] Фінальне значення лічильника:', sharedArray[0]);
  
  // Завершуємо всі Worker-потоки
  workers.forEach((worker) => worker.terminate());
}, 2000);

// counter-worker.ts — робочий потік
import { workerData, parentPort } from 'node:worker_threads';

interface WorkerData {
  workerId: number;
  sharedBuffer: SharedArrayBuffer;
}

const { workerId, sharedBuffer } = workerData as WorkerData;
const sharedArray = new Int32Array(sharedBuffer);

parentPort?.postMessage(`Worker ${workerId} запущено`);

// Кожен Worker інкрементує лічильник 1000 разів
for (let i = 0; i < 1000; i++) {
  // ❌ ПРОБЛЕМА: Race Condition!
  const currentValue = sharedArray[0];
  sharedArray[0] = currentValue + 1;
}

parentPort?.postMessage(`Worker ${workerId} завершив роботу`);

// counter-worker.ts — виправлена версія
import { workerData, parentPort } from 'node:worker_threads';

interface WorkerData {
  workerId: number;
  sharedBuffer: SharedArrayBuffer;
}

const { workerId, sharedBuffer } = workerData as WorkerData;
const sharedArray = new Int32Array(sharedBuffer);

parentPort?.postMessage(`Worker ${workerId} запущено`);

// ✅ Атомарний інкремент — безпечно для багатопотоковості
for (let i = 0; i < 1000; i++) {
  Atomics.add(sharedArray, 0, 1); // Атомарно додає 1 до sharedArray[0]
}

parentPort?.postMessage(`Worker ${workerId} завершив роботу`);

// producer.ts — Worker-виробник
import { workerData, parentPort } from 'node:worker_threads';

const { sharedBuffer } = workerData as { sharedBuffer: SharedArrayBuffer };
const sharedArray = new Int32Array(sharedBuffer);

// sharedArray[0] — статус: 0 = "немає даних", 1 = "дані готові"
// sharedArray[1] — дані

for (let i = 1; i <= 10; i++) {
  // Генеруємо дані
  const data = i * 10;
  
  // Записуємо дані
  Atomics.store(sharedArray, 1, data);
  
  // Встановлюємо прапор "дані готові"
  Atomics.store(sharedArray, 0, 1);
  
  // Сповіщаємо споживача
  Atomics.notify(sharedArray, 0, 1);
  
  console.log(`[Producer] Відправлено: ${data}`);
  
  // Чекаємо, поки споживач обробить дані
  while (Atomics.load(sharedArray, 0) === 1) {
    // Busy-wait (у реальних застосунках краще використовувати wait)
  }
  
  // Невелика затримка
  Atomics.wait(sharedArray, 0, 0, 500); // Чекаємо 500мс або до зміни
}

parentPort?.postMessage('Producer завершено');

// consumer.ts — Worker-споживач
import { workerData, parentPort } from 'node:worker_threads';

const { sharedBuffer } = workerData as { sharedBuffer: SharedArrayBuffer };
const sharedArray = new Int32Array(sharedBuffer);

let receivedCount = 0;

while (receivedCount < 10) {
  // Чекаємо, поки producer встановить прапор "дані готові"
  const result = Atomics.wait(sharedArray, 0, 0, 1000); // Таймаут 1 секунда
  
  if (result === 'ok') {
    // Читаємо дані
    const data = Atomics.load(sharedArray, 1);
    console.log(`[Consumer] Отримано: ${data}`);
    
    receivedCount++;
    
    // Скидаємо прапор "немає даних"
    Atomics.store(sharedArray, 0, 0);
    
    // Сповіщаємо producer, що можна надсилати нові дані
    Atomics.notify(sharedArray, 0, 1);
  } else if (result === 'timed-out') {
    console.warn('[Consumer] Таймаут очікування даних');
  }
}

parentPort?.postMessage('Consumer завершено');

// worker-pool.ts
import { Worker } from 'node:worker_threads';
import { EventEmitter } from 'node:events';
import { resolve } from 'node:path';

interface Task<T = any> {
  id: string;
  data: T;
  resolve: (result: any) => void;
  reject: (error: Error) => void;
}

export class WorkerPool extends EventEmitter {
  private workers: Worker[] = [];
  private freeWorkers: Worker[] = [];
  private taskQueue: Task[] = [];
  private workerTaskMap = new Map<Worker, Task>();

  constructor(
    private workerScript: string,
    private poolSize: number = 4
  ) {
    super();
    this.initialize();
  }

  private initialize(): void {
    for (let i = 0; i < this.poolSize; i++) {
      const worker = new Worker(resolve(__dirname, this.workerScript));
      
      worker.on('message', (result) => {
        this.handleWorkerMessage(worker, result);
      });

      worker.on('error', (error) => {
        this.handleWorkerError(worker, error);
      });

      worker.on('exit', (code) => {
        console.log(`Worker ${i} завершився з кодом ${code}`);
        this.removeWorker(worker);
      });

      this.workers.push(worker);
      this.freeWorkers.push(worker);
    }

    this.emit('ready', this.poolSize);
  }

  private handleWorkerMessage(worker: Worker, result: any): void {
    const task = this.workerTaskMap.get(worker);
    
    if (task) {
      task.resolve(result);
      this.workerTaskMap.delete(worker);
      this.freeWorkers.push(worker);
      
      // Обробляємо наступну задачу з черги
      this.processNextTask();
    }
  }

  private handleWorkerError(worker: Worker, error: Error): void {
    const task = this.workerTaskMap.get(worker);
    
    if (task) {
      task.reject(error);
      this.workerTaskMap.delete(worker);
    }

    // Видаляємо неробочий Worker
    this.removeWorker(worker);

    // Створюємо новий Worker на заміну
    const newWorker = new Worker(resolve(__dirname, this.workerScript));
    newWorker.on('message', (result) => this.handleWorkerMessage(newWorker, result));
    newWorker.on('error', (error) => this.handleWorkerError(newWorker, error));
    
    this.workers.push(newWorker);
    this.freeWorkers.push(newWorker);
    
    // Обробляємо чергову задачу
    this.processNextTask();
  }

  private removeWorker(worker: Worker): void {
    const workerIndex = this.workers.indexOf(worker);
    if (workerIndex !== -1) {
      this.workers.splice(workerIndex, 1);
    }

    const freeIndex = this.freeWorkers.indexOf(worker);
    if (freeIndex !== -1) {
      this.freeWorkers.splice(freeIndex, 1);
    }
  }

  private processNextTask(): void {
    if (this.taskQueue.length === 0 || this.freeWorkers.length === 0) {
      return;
    }

    const task = this.taskQueue.shift()!;
    const worker = this.freeWorkers.shift()!;

    this.workerTaskMap.set(worker, task);
    worker.postMessage(task.data);
  }

  public execute<T = any, R = any>(data: T): Promise<R> {
    return new Promise((resolve, reject) => {
      const task: Task<T> = {
        id: `task-${Date.now()}-${Math.random()}`,
        data,
        resolve,
        reject,
      };

      this.taskQueue.push(task);
      this.processNextTask();
    });
  }

  public async terminate(): Promise<void> {
    const terminationPromises = this.workers.map((worker) => worker.terminate());
    await Promise.all(terminationPromises);
    
    this.workers = [];
    this.freeWorkers = [];
    this.taskQueue = [];
    this.workerTaskMap.clear();
    
    this.emit('terminated');
  }

  public getStats() {
    return {
      totalWorkers: this.workers.length,
      freeWorkers: this.freeWorkers.length,
      busyWorkers: this.workerTaskMap.size,
      queuedTasks: this.taskQueue.length,
    };
  }
}

// compute-worker.ts — робочий потік
import { parentPort } from 'node:worker_threads';

function fibonacci(n: number): number {
  if (n <= 1) return n;
  return fibonacci(n - 1) + fibonacci(n - 2);
}

parentPort?.on('message', (n: number) => {
  const result = fibonacci(n);
  parentPort?.postMessage(result);
});

// main.ts — головний потік
import { WorkerPool } from './worker-pool';

async function main() {
  const pool = new WorkerPool('compute-worker.ts', 4);

  pool.on('ready', (size) => {
    console.log(`Worker Pool готовий: ${size} потоків`);
  });

  console.log('Відправка 20 задач у пул...');
  const startTime = Date.now();

  const tasks = Array.from({ length: 20 }, (_, i) => pool.execute(40 + (i % 5)));

  const results = await Promise.all(tasks);

  const duration = Date.now() - startTime;

  console.log(`Всі задачі виконано за ${duration}мс`);
  console.log('Перші 5 результатів:', results.slice(0, 5));
  console.log('Статистика пулу:', pool.getStats());

  await pool.terminate();
  console.log('Worker Pool завершено');
}

main().catch(console.error);

import { cpus } from 'node:os';

const optimalPoolSize = cpus().length;
console.log(`Оптимальний розмір Worker Pool: ${optimalPoolSize}`);
// Наприклад: Оптимальний розмір Worker Pool: 8 (для CPU з 8 ядрами)

// ❌ АНТИПАТТЕРН: Worker не завершується
const worker = new Worker('./long-running-worker.ts');

worker.postMessage('start');

// Забули викликати worker.terminate() — Worker працює вічно!

// ✅ ПРАВИЛЬНО: завжди завершуйте Worker після використання
const worker = new Worker('./task-worker.ts');

worker.on('message', (result) => {
  console.log('Результат:', result);
  
  // Завершуємо Worker після отримання результату
  worker.terminate().then(() => {
    console.log('Worker коректно завершено');
  });
});

worker.postMessage({ task: 'compute', data: 42 });

// Альтернатива: таймаут для примусового завершення
setTimeout(() => {
  worker.terminate();
  console.warn('Worker примусово завершено через таймаут');
}, 30000); // 30 секунд

// Встановлюємо розмір Thread Pool libuv на 8 потоків
process.env.UV_THREADPOOL_SIZE = '8';

import { readFile } from 'node:fs/promises';
import { performance } from 'node:perf_hooks';

async function measureConcurrentFileReads() {
  const files = Array.from({ length: 20 }, (_, i) => `./data/file-${i}.txt`);

  const start = performance.now();

  const promises = files.map((file) => readFile(file, 'utf-8'));
  await Promise.all(promises);

  const duration = performance.now() - start;

  console.log(`Читання ${files.length} файлів зайняло: ${duration.toFixed(2)}мс`);
}

measureConcurrentFileReads();

// З UV_THREADPOOL_SIZE=4: ~850мс (20 файлів / 4 потоки = 5 пакетів)
// З UV_THREADPOOL_SIZE=8: ~450мс (20 файлів / 8 потоків = 2.5 пакети)

// image-worker.ts
import { parentPort, workerData } from 'node:worker_threads';
import sharp from 'sharp'; // Бібліотека для обробки зображень
import { readFile, writeFile } from 'node:fs/promises';

interface ImageTask {
  inputPath: string;
  outputPath: string;
  quality: number;
}

parentPort?.on('message', async (task: ImageTask) => {
  try {
    console.log(`[Worker] Обробка: ${task.inputPath}`);

    // Читання вхідного зображення
    const inputBuffer = await readFile(task.inputPath);

    // Конвертація JPEG → WebP
    const outputBuffer = await sharp(inputBuffer)
      .webp({ quality: task.quality })
      .toBuffer();

    // Збереження результату
    await writeFile(task.outputPath, outputBuffer);

    const compressionRatio = (
      (1 - outputBuffer.length / inputBuffer.length) * 100
    ).toFixed(2);

    parentPort?.postMessage({
      success: true,
      inputPath: task.inputPath,
      outputPath: task.outputPath,
      originalSize: inputBuffer.length,
      compressedSize: outputBuffer.length,
      compressionRatio: `${compressionRatio}%`,
    });
  } catch (error) {
    parentPort?.postMessage({
      success: false,
      inputPath: task.inputPath,
      error: (error as Error).message,
    });
  }
});

console.log('[Worker] Готовий до обробки зображень');

// batch-converter.ts
import { WorkerPool } from './worker-pool';
import { readdir } from 'node:fs/promises';
import { resolve, join } from 'node:path';

async function convertImagesInBatch(inputDir: string, outputDir: string) {
  const pool = new WorkerPool('image-worker.ts', 4);

  // Отримуємо список JPEG файлів
  const files = await readdir(inputDir);
  const jpegFiles = files.filter((file) => /\.(jpg|jpeg)$/i.test(file));

  console.log(`Знайдено ${jpegFiles.length} JPEG файлів для конвертації`);

  const startTime = Date.now();

  const tasks = jpegFiles.map((file) =>
    pool.execute({
      inputPath: join(inputDir, file),
      outputPath: join(outputDir, file.replace(/\.(jpg|jpeg)$/i, '.webp')),
      quality: 80,
    })
  );

  const results = await Promise.all(tasks);

  const duration = Date.now() - startTime;

  // Статистика
  const successful = results.filter((r: any) => r.success).length;
  const failed = results.filter((r: any) => !r.success).length;

  const totalOriginalSize = results
    .filter((r: any) => r.success)
    .reduce((sum: number, r: any) => sum + r.originalSize, 0);

  const totalCompressedSize = results
    .filter((r: any) => r.success)
    .reduce((sum: number, r: any) => sum + r.compressedSize, 0);

  const overallCompression = (
    (1 - totalCompressedSize / totalOriginalSize) * 100
  ).toFixed(2);

  console.log('\n=== Результати конвертації ===');
  console.log(`Успішно: ${successful} файлів`);
  console.log(`Помилки: ${failed} файлів`);
  console.log(`Час виконання: ${(duration / 1000).toFixed(2)} секунд`);
  console.log(`Оригінальний розмір: ${(totalOriginalSize / 1024 / 1024).toFixed(2)} МБ`);
  console.log(`Стиснутий розмір: ${(totalCompressedSize / 1024 / 1024).toFixed(2)} МБ`);
  console.log(`Економія: ${overallCompression}%`);

  await pool.terminate();
}

// Використання
convertImagesInBatch('./images/input', './images/output').catch(console.error);