const fs = require('fs');

// BLOCKING - Thread waits for file to be read
const data = fs.readFileSync('test.txt', 'utf-8');
console.log(data);
console.log('This waits for file read to complete');

const fs = require('fs');

// NON-BLOCKING - Thread continues execution
fs.readFile('test.txt', 'utf-8', (err, data) => {
  if (err) throw err;
  console.log(data); // Executes when ready
});
console.log('This executes immediately');

// Starvation example -- DO NOT do this in production
function dangerous() {
  process.nextTick(dangerous); // Event loop never advances
}

// Safe alternative -- yields to I/O between calls
function safe() {
  setImmediate(safe); // I/O callbacks can fire between iterations
}

// Set BEFORE any other code or imports
process.env.UV_THREADPOOL_SIZE = '8';

const crypto = require('crypto');
const fs = require('fs');

// Both compete for thread pool threads
crypto.pbkdf2('password', 'salt', 100000, 64, 'sha512', () => {});
fs.readFile('large-file.csv', () => {});

// fork -- Node.js child with IPC
const { fork } = require('child_process');
const child = fork('./heavy-computation.js');
child.send({ data: largeDataset });
child.on('message', (result) => {
  console.log('Computation result:', result);
});

// spawn -- any system command, streamed output
const { spawn } = require('child_process');
const ffmpeg = spawn('ffmpeg', ['-i', 'input.mp4', '-codec', 'libx264', 'output.mp4']);
ffmpeg.stderr.on('data', (data) => {
  console.log('Progress:', data.toString());
});

// BAD -- blocks the event loop for all users
app.get('/fibonacci', (req, res) => {
  const result = fibonacci(45); // ~7 seconds of blocking
  res.json({ result });
});

// GOOD -- offloads to a worker thread pool
const Piscina = require('piscina');
const pool = new Piscina({ filename: './fibonacci-worker.js' });

app.get('/fibonacci', async (req, res) => {
  const result = await pool.run(45);
  res.json({ result });
});

const { pipeline } = require('stream');
const fs = require('fs');
const zlib = require('zlib');

// GOOD -- pipeline handles errors and cleanup
pipeline(
  fs.createReadStream('access.log'),     // 4 GB log file
  zlib.createGzip(),                      // Compress on the fly
  fs.createWriteStream('access.log.gz'), // Write compressed
  (err) => {
    if (err) console.error('Pipeline failed:', err);
    else console.log('Pipeline succeeded');
  }
);

// BAD -- errors are not propagated, resource leaks possible
fs.createReadStream('access.log')
  .pipe(zlib.createGzip())
  .pipe(fs.createWriteStream('access.log.gz'));

// Dangerous: parallel async without proper error handling
async function riskyParallel() {
  try {
    const p1 = fetchUser(1);    // No await -- fires immediately
    const p2 = fetchUser(2);    // No await -- fires immediately
    // If p2 rejects before p1, the rejection is unhandled
    const user1 = await p1;
    const user2 = await p2;
  } catch (err) {
    // Only catches the FIRST awaited rejection
  }
}

// Safe: use Promise.allSettled or Promise.all
async function safeParallel() {
  try {
    const [user1, user2] = await Promise.all([
      fetchUser(1),
      fetchUser(2)
    ]);
  } catch (err) {
    // Catches if ANY promise rejects
  }
}

const cluster = require('cluster');
const os = require('os');

if (cluster.isPrimary) {
  const numCPUs = os.cpus().length;
  console.log(`Master process ${process.pid} forking ${numCPUs} workers`);

  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }

  cluster.on('exit', (worker, code) => {
    console.log(`Worker ${worker.process.pid} died (code: ${code}). Restarting...`);
    cluster.fork(); // Auto-restart crashed workers
  });
} else {
  const express = require('express');
  const app = express();
  app.listen(3000, () => {
    console.log(`Worker ${process.pid} listening on port 3000`);
  });
}

// CommonJS -- synchronous, dynamic
const config = require(`./config.${process.env.NODE_ENV}.js`);
console.log(__dirname); // Available

// ES Module -- static, async
import config from './config.js';
// Dynamic import for conditional loading
const module = await import(`./plugins/${pluginName}.js`);

// ESM equivalent of __dirname
import { fileURLToPath } from 'url';
import { dirname } from 'path';
const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);

// Classic memory leak -- global cache with no eviction
const cache = {}; // This grows forever
app.get('/user/:id', async (req, res) => {
  if (!cache[req.params.id]) {
    cache[req.params.id] = await db.getUser(req.params.id);
  }
  res.json(cache[req.params.id]);
});

// Fixed -- LRU cache with max size
const { LRUCache } = require('lru-cache');
const cache = new LRUCache({ max: 1000, ttl: 1000 * 60 * 5 });

const EventEmitter = require('events');

class OrderService extends EventEmitter {
  placeOrder(order) {
    // Business logic
    this.emit('orderPlaced', order);
    // WARNING: All listeners execute synchronously before this line
    console.log('This runs AFTER all listeners complete');
  }
}

const service = new OrderService();
service.on('orderPlaced', (order) => sendConfirmationEmail(order));
service.on('orderPlaced', (order) => updateInventory(order));
service.on('orderPlaced', (order) => notifyWarehouse(order));

// If any listener throws, subsequent listeners do NOT run
// and the error propagates to the caller

// This is what Node ACTUALLY wraps your code in:
(function(exports, require, module, __filename, __dirname) {
  // Your app.js code runs here
  const express = require('express');
  const app = express();
  app.listen(3000); // Registers a handle -> event loop stays alive
});

const server = app.listen(3000);
const connections = new Set();

server.on('connection', (conn) => {
  connections.add(conn);
  conn.on('close', () => connections.delete(conn));
});

async function gracefulShutdown(signal) {
  console.log(`Received ${signal}. Starting graceful shutdown...`);

  // 1. Stop accepting new connections
  server.close(() => {
    console.log('HTTP server closed');
  });

  // 2. Close idle keep-alive connections
  for (const conn of connections) {
    conn.end(); // Gracefully close
  }

  // 3. Close external resources
  await database.disconnect();
  await redis.quit();
  await messageQueue.close();

  // 4. Exit clean
  process.exit(0);
}

// 5. Hard timeout safety net
function forceShutdown() {
  console.error('Forcing shutdown after timeout');
  process.exit(1);
}

process.on('SIGTERM', () => {
  gracefulShutdown('SIGTERM');
  setTimeout(forceShutdown, 25000);
});
process.on('SIGINT', () => {
  gracefulShutdown('SIGINT');
  setTimeout(forceShutdown, 25000);
});

// Middleware execution order matters
app.use(express.json());                    // 1. Parse body
app.use(helmet());                          // 2. Security headers
app.use(cors({ origin: 'https://app.com' }));  // 3. CORS
app.use(authMiddleware);                    // 4. Auth check

app.get('/api/users', authorize('admin'), getUsers);  // 5. Route

// ERROR handler MUST be last, MUST have 4 params
app.use((err, req, res, next) => {          // 6. Error handler
  console.error(err.stack);
  res.status(err.status || 500).json({
    error: process.env.NODE_ENV === 'production'
      ? 'Internal Server Error'
      : err.message
  });
});