const fs = require('fs');         // File System
const path = require('path');     // File Paths
const http = require('http');     // HTTP Server/Client
const os = require('os');         // Operating System
const crypto = require('crypto'); // Cryptography
const util = require('util');     // Utilities
const events = require('events'); // Event Emitter
const stream = require('stream'); // Streams
const buffer = require('buffer'); // Binary Data
const process = require('process');// Process Info (global)

// Plus more: child_process, cluster, dns, net, dgram, readline, zlib, ...

// ❌ Manually parsing file paths (brittle!)
const fullPath = '/users/john/docs/../../file.txt';
const parts = fullPath.split('/');  // This is WRONG on Windows!

// ❌ Writing sync code when async is needed
const data = fs.readFileSync('large-file.txt'); // Blocks everything!

// ❌ Reinventing the wheel
// Writing your own crypto instead of using built-in crypto module

// is-odd package (11 lines, 3 dependencies!)
const isNumber = require('is-number');
module.exports = function isOdd(value) {
  const n = Math.abs(value);
  if (!isNumber(n)) throw new TypeError('expected a number');
  return !(n % 2 === 0);
};

BUILT-IN MODULES OVERVIEW
═══════════════════════════

                         ┌──────────────────┐
                         │   PROCESS        │
                         │  (global)        │
                         │  argv, env, exit  │
                         └──────┬───────────┘
                                │
┌──────────┐   ┌──────────┐   ┌┴──────────┐   ┌──────────┐   ┌──────────┐
│   FS     │   │   PATH   │   │   HTTP    │   │   OS     │   │  CRYPTO  │
│          │   │          │   │           │   │          │   │          │
│ readFile │   │  join    │   │ createSrv │   │ platform │   │  hash    │
│ writeFile│   │ resolve  │   │   req     │   │   cpus   │   │  random  │
│  mkdir   │   │  parse   │   │   res     │   │   mem    │   │  cipher  │
│  readdir │   │ basename │   │   listen  │   │   homedir│   │  sign    │
└──────────┘   └──────────┘   └──────────┘   └──────────┘   └──────────┘
                                │
              ┌──────────┐   ┌─┴──────────┐   ┌──────────┐
              │  EVENTS  │   │   STREAM   │   │  UTIL    │
              │          │   │            │   │          │
              │   on     │   │ readable   │   │ promisify│
              │  emit    │   │ writable   │   │  types   │
              │  once    │   │ transform  │   │ inherits │
              │  remove  │   │ pipeline   │   │  format  │
              └──────────┘   └────────────┘   └──────────┘

flowchart TB
    subgraph Files["📁 File System"]
        FS["fs module\n• fs.readFile / writeFile\n• fs.mkdir / readdir\n• fs.watch / stat\n• fs.createReadStream"]
        Path["path module\n• path.join / resolve\n• path.parse / basename\n• path.extname / dirname"]
    end

    subgraph Network["🌐 Network"]
        HTTP["http / https\n• http.createServer\n• http.request\n• Server / Response"]
        NET["net / dgram\n• TCP servers\n• UDP sockets\n• DNS lookups"]
    end

    subgraph System["💻 System"]
        OS["os module\n• os.cpus / freemem\n• os.platform / homedir\n• os.hostname / network"]
        Process["process (global)\n• process.env / argv\n• process.exit / cwd\n• process.memoryUsage"]
    end

    subgraph Security["🔒 Security"]
        Crypto["crypto module\n• crypto.createHash\n• crypto.randomBytes\n• crypto.createCipher"]
    end

    subgraph Async["⚡ Async Patterns"]
        Events["events module\n• EventEmitter\n• on / emit\n• once / removeListener"]
        Stream["stream module\n• Readable / Writable\n• Transform / Duplex\n• pipeline"]
    end

    style Files fill:#4f46e5,color:#fff
    style Network fill:#059669,color:#fff
    style System fill:#d97706,color:#fff
    style Security fill:#dc2626,color:#fff
    style Async fill:#7c3aed,color:#fff

flowchart LR
    subgraph App["Your App"]
        Code["app.js\nrequire('fs')"]
    end

    subgraph Node["Node.js Internals"]
        Loader["Module Loader"]
        Native["Native Modules\n(fs.node)\nC++ Bindings"]
        JS["JS Modules\n(fs.js)\nJavaScript wrappers"]
        Libuv["libuv C Library\n(actual I/O)"]
        V8["V8 Engine\n(JS execution)"]
    end

    subgraph OS["Operating System"]
        Kernel["OS Kernel\n(syscalls)"]
    end

    Code --> Loader
    Loader --> JS
    JS --> Native
    Native --> Libuv
    Native --> V8
    Libuv --> Kernel

    style App fill:#4f46e5,color:#fff
    style Node fill:#7c3aed,color:#fff
    style OS fill:#dc2626,color:#fff

flowchart TB
    subgraph Sync["fs.readFileSync (Blocking)"]
        SyncCall["Call readFileSync"] --> SyncBlock["Thread BLOCKED\nwaiting for disk"]
        SyncBlock --> SyncReturn["Return Buffer/String"]
    end

    subgraph Callback["fs.readFile (Callback)"]
        CbCall["Call readFile(cb)"] --> CbAsync["Delegate to\nThread Pool"]
        CbAsync --> CbReturn["Return immediately\n(undefined)"]
        CbAsync --> CbDone["Disk done → callback\nqueued in Event Loop"]
    end

    subgraph Promise["fs.promises.readFile (Async/Await)"]
        PrCall["Call promises.readFile"] --> PrAsync["Delegate to\nThread Pool"]
        PrAsync --> PrReturn["Return Promise<pending>"]
        PrAsync --> PrDone["Disk done → Promise\nresolved/rejected"]
    end

    style Sync fill:#ef4444,color:#fff
    style Callback fill:#f59e0b,color:#fff
    style Promise fill:#10b981,color:#fff

sequenceDiagram
    participant App as app.js
    participant FS as fs module
    participant Binding as C++ Binding
    participant Libuv as libuv Thread Pool
    participant Disk as Disk

    App->>FS: fs.readFile('data.json', 'utf-8', callback)
    FS->>Binding: Internal binding call
    Binding->>Libuv: Queue work in Thread Pool
    FS-->>App: ✅ Returns undefined (immediately)

    Note over App: Continue executing<br/>other code...

    Libuv->>Disk: Read file (blocking in thread)
    Disk-->>Libuv: File data
    Libuv->>Binding: Work complete
    Binding->>FS: Callback pending
    FS->>App: Execute callback(err, data)
    Note over App: console.log(data)<br/>or handle error

// ─── FS (File System) ───────────────────────────────
const fs = require('fs');
const fsp = require('fs').promises;  // Promise-based

// Read
fs.readFile('file.txt', 'utf-8', (err, data) => {});
const data = await fsp.readFile('file.txt', 'utf-8');

// Write
fs.writeFile('file.txt', 'content', (err) => {});
await fsp.writeFile('file.txt', 'content');

// Directory
fs.mkdir('dir', { recursive: true }, (err) => {});
fs.readdir('dir', (err, files) => {});

// Info
fs.stat('file.txt', (err, stats) => {});  // size, mtime, isFile(), isDirectory()

// ─── PATH ───────────────────────────────────────────
const path = require('path');
path.join('users', 'john', 'docs');          // 'users/john/docs' (cross-platform)
path.resolve('src', '..', 'dist');           // '/abs/path/dist'
path.parse('/users/john/file.txt');
// { root: '/', dir: '/users/john', base: 'file.txt', ext: '.txt', name: 'file' }

// ─── HTTP ───────────────────────────────────────────
const http = require('http');
http.createServer((req, res) => {});
http.get('http://api.example.com', (res) => {});

// ─── OS ─────────────────────────────────────────────
const os = require('os');
os.platform();    // 'win32', 'darwin', 'linux'
os.cpus();        // Array of CPU info
os.freemem();     // Free RAM in bytes
os.homedir();     // User's home directory
os.hostname();    // Machine name

// ─── CRYPTO ─────────────────────────────────────────
const crypto = require('crypto');
crypto.createHash('sha256').update('data').digest('hex');
crypto.randomBytes(32);  // Secure random bytes
crypto.randomUUID();     // Generate UUID v4

// ─── UTIL ───────────────────────────────────────────
const util = require('util');
util.promisify(someCallbackFunction);  // Convert callback → promise
util.types.isDate(new Date());         // Type checking
util.inspect(obj);                     // Pretty-print objects

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

// ─── CREATE A DIRECTORY ─────────────────────────────
const dataDir = path.join(__dirname, 'data');

// Create directory (recursive = creates parent dirs too)
fs.mkdir(dataDir, { recursive: true }, (err) => {
  if (err) {
    console.error('Failed to create directory:', err.message);
    return;
  }
  console.log('✅ Directory created:', dataDir);

  // ─── WRITE A FILE ───────────────────────────────
  const userData = JSON.stringify(
    { id: 1, name: 'Alice', email: 'alice@example.com' },
    null,
    2
  );

  const filePath = path.join(dataDir, 'user.json');

  fs.writeFile(filePath, userData, 'utf-8', (err) => {
    if (err) {
      console.error('Failed to write file:', err.message);
      return;
    }
    console.log('✅ File written:', filePath);

    // ─── READ THE FILE BACK ──────────────────────
    fs.readFile(filePath, 'utf-8', (err, data) => {
      if (err) {
        console.error('Failed to read file:', err.message);
        return;
      }

      const user = JSON.parse(data);
      console.log('📖 Read user:', user.name);
      console.log('📖 Email:', user.email);
    });
  });
});

const http = require('http');
const url = require('url');
const fs = require('fs');
const path = require('path');

// ─── SIMPLE ROUTER ──────────────────────────────────
const routes = {
  'GET /': (req, res) => {
    res.writeHead(200, { 'Content-Type': 'text/html' });
    res.end('<h1>🏠 Home</h1><a href="/about">About</a>');
  },

  'GET /about': (req, res) => {
    res.writeHead(200, { 'Content-Type': 'text/html' });
    res.end('<h1>📖 About</h1><p>Learning Node.js built-in modules!</p>');
  },

  'GET /api/time': (req, res) => {
    const now = new Date();
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({
      iso: now.toISOString(),
      unix: now.getTime(),
      timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
    }));
  },

  'POST /api/echo': (req, res) => {
    let body = '';
    req.on('data', chunk => body += chunk);
    req.on('end', () => {
      res.writeHead(200, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({
        received: body,
        parsed: tryParseJSON(body),
        headers: req.headers,
      }));
    });
  },
};

function tryParseJSON(str) {
  try { return JSON.parse(str); }
  catch { return null; }
}

// ─── SERVER ─────────────────────────────────────────
const server = http.createServer((req, res) => {
  const routeKey = `${req.method} ${req.url}`;
  const handler = routes[routeKey];

  if (handler) {
    handler(req, res);
  } else {
    res.writeHead(404, { 'Content-Type': 'text/plain' });
    res.end('404 — Not Found');
  }
});

const PORT = 3000;
server.listen(PORT, () => {
  console.log(`🚀 Server: http://localhost:${PORT}`);
  console.log(`   Routes:`);
  Object.keys(routes).forEach(r => console.log(`   ${r}`));
});

const fs = require('fs');
const path = require('path');
const { EventEmitter } = require('events');
const crypto = require('crypto');

// ─── FILE WATCHER WITH EVENT EMITTER ───────────────
class FileWatcher extends EventEmitter {
  constructor(directory, options = {}) {
    super();
    this.directory = path.resolve(directory);
    this.interval = options.interval || 1000;
    this.fileHashes = new Map();
    this.watchTimer = null;
    this.running = false;
  }

  async start() {
    if (this.running) return;
    this.running = true;

    console.log(`🔍 Watching: ${this.directory}`);

    // Initial scan
    await this.scan();

    // Periodic scan
    this.watchTimer = setInterval(() => this.scan(), this.interval);
    this.watchTimer.unref();  // Don't keep process alive

    this.emit('started', this.directory);
  }

  stop() {
    this.running = false;
    if (this.watchTimer) {
      clearInterval(this.watchTimer);
      this.watchTimer = null;
    }
    this.emit('stopped');
  }

  async scan() {
    try {
      const files = await fs.promises.readdir(this.directory);

      for (const file of files) {
        const filePath = path.join(this.directory, file);
        const stats = await fs.promises.stat(filePath);

        if (!stats.isFile()) continue;

        const hash = await this.hashFile(filePath);
        const previousHash = this.fileHashes.get(filePath);

        if (previousHash === undefined) {
          this.emit('file-added', { file, filePath, hash, stats });
        } else if (previousHash !== hash) {
          this.emit('file-changed', { file, filePath, hash, stats });
        }

        this.fileHashes.set(filePath, hash);
      }

      // Check for deleted files
      for (const [filePath] of this.fileHashes) {
        if (!files.includes(path.basename(filePath))) {
          this.emit('file-removed', { file: path.basename(filePath), filePath });
          this.fileHashes.delete(filePath);
        }
      }
    } catch (err) {
      this.emit('error', err);
    }
  }

  hashFile(filePath) {
    return new Promise((resolve, reject) => {
      const hash = crypto.createHash('md5');
      const stream = fs.createReadStream(filePath);

      stream.on('data', chunk => hash.update(chunk));
      stream.on('end', () => resolve(hash.digest('hex')));
      stream.on('error', reject);
    });
  }
}

// ─── USAGE ──────────────────────────────────────────
const watcher = new FileWatcher('./watch-dir', { interval: 2000 });

watcher.on('file-added', ({ file }) => console.log('➕ Added:', file));
watcher.on('file-changed', ({ file }) => console.log('✏️ Changed:', file));
watcher.on('file-removed', ({ file }) => console.log('➖ Removed:', file));
watcher.on('error', (err) => console.error('❌ Error:', err.message));

watcher.start();

// Stop after 30 seconds (for demo)
setTimeout(() => watcher.stop(), 30000);

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

// ─── PRODUCTION CONFIG LOADER ───────────────────────
class ConfigLoader {
  constructor(options = {}) {
    this.configDir = options.configDir || process.cwd();
    this.env = process.env.NODE_ENV || 'development';
    this.cache = new Map();
    this.cacheTTL = options.cacheTTL || 60000; // 1 minute
  }

  /**
   * Load config with environment-specific overrides
   * Priority: default < environment < local < environment variable
   */
  async load(name) {
    const cacheKey = `${name}:${this.env}`;

    // Check cache
    if (this.cache.has(cacheKey)) {
      const entry = this.cache.get(cacheKey);
      if (Date.now() - entry.timestamp < this.cacheTTL) {
        return entry.data;
      }
      this.cache.delete(cacheKey);
    }

    // Load config files in priority order
    const files = [
      path.join(this.configDir, `${name}.json`),
      path.join(this.configDir, `${name}.${this.env}.json`),
      path.join(this.configDir, `${name}.local.json`),
    ];

    let config = {};
    for (const file of files) {
      try {
        const fileConfig = JSON.parse(
          await fs.promises.readFile(file, 'utf-8')
        );
        config = { ...config, ...fileConfig };
        console.log(`📄 Loaded config: ${path.basename(file)}`);
      } catch (err) {
        if (err.code !== 'ENOENT') {
          console.warn(`⚠️  Error loading ${file}: ${err.message}`);
        }
      }
    }

    // Environment variable overrides (highest priority)
    const prefix = `${name.toUpperCase()}_`;
    for (const [key, value] of Object.entries(process.env)) {
      if (key.startsWith(prefix)) {
        const configKey = key.slice(prefix.length).toLowerCase();
        config[configKey] = tryParse(value);
      }
    }

    // Cache and return
    this.cache.set(cacheKey, { data: config, timestamp: Date.now() });
    return config;
  }

  /**
   * Generate a content hash for config integrity
   */
  getConfigHash(config) {
    return crypto
      .createHash('sha256')
      .update(JSON.stringify(config))
      .digest('hex');
  }

  /**
   * Get system metadata
   */
  getSystemInfo() {
    return {
      hostname: os.hostname(),
      platform: os.platform(),
      cpus: os.cpus().length,
      memory: os.totalmem(),
      nodeVersion: process.version,
      pid: process.pid,
      env: this.env,
    };
  }
}

function tryParse(value) {
  try { return JSON.parse(value); }
  catch { return value; }
}

// ─── USAGE ──────────────────────────────────────────
async function main() {
  const loader = new ConfigLoader();

  // Load database config
  const dbConfig = await loader.load('database');
  console.log('📊 DB Config:', dbConfig);

  // Load app config
  const appConfig = await loader.load('app');
  console.log('⚙️  App Config:', appConfig);

  // Log system info
  console.log('🖥️  System:', loader.getSystemInfo());
}

main().catch(console.error);

fs.readFile() in JavaScript
│
├─ 1. fs.js (JavaScript)
│     Validate arguments
│     Create a FSReqCallback object
│     Call internal binding: binding.readFile()
│
├─ 2. node_file.cc (C++ binding)
│     Convert JS call to C++ call
│     Create a uv_fs_t request
│     Call libuv: uv_fs_read()
│
├─ 3. libuv (C library)
│     If async → queue work in Thread Pool
│     Thread calls OS: read() syscall
│     Thread blocks on I/O (this is fine, it's a thread)
│     I/O completes → callback queued in Event Loop
│
└─ 4. Event Loop (C)
      Picks up completed callback
      Calls fs.js callback with data

// ❌ MISTAKE 1: Not checking for ENOENT (file not found)
const data = fs.readFileSync('config.json'); // ⛔ Crash if not found!
// ✅ FIX:
try {
  const data = fs.readFileSync('config.json', 'utf-8');
} catch (err) {
  if (err.code === 'ENOENT') {
    console.log('Config not found, using defaults');
  } else {
    throw err;
  }
}

// ❌ MISTAKE 2: Using path concatenation instead of path.join
const fullPath = __dirname + '/' + 'data/' + file;  // ❌ Breaks on Windows!
const fullPath = path.join(__dirname, 'data', file); // ✅ Cross-platform!

// ❌ MISTAKE 3: Forgetting encoding with readFile
fs.readFile('file.txt', (err, data) => {
  console.log(data); // <Buffer ...> — not a string!
});
// ✅ FIX:
fs.readFile('file.txt', 'utf-8', (err, data) => { ... });

// ❌ MISTAKE 4: Using sync fs in request handlers
app.get('/data', (req, res) => {
  const data = fs.readFileSync('data.json'); //⛔ Blocks ALL requests!
});

// ❌ MISTAKE 5: Creating a new hash for every password attempt
// Instead: use crypto.timingSafeEqual() to prevent timing attacks

const safePath = path.resolve(baseDir, userInput);
if (!safePath.startsWith(baseDir)) throw new Error('Invalid path');

downloads/
├── pdf/
│   ├── report.pdf
│   └── invoice.pdf
├── jpg/
│   ├── photo1.jpg
│   └── photo2.jpg
└── js/
    └── script.js

// ─── BUGGY CODE ───
const fs = require('fs');
const path = require('path');

const directory = './data';
const user = { name: 'Alice', age: 30 };

// Bug 1: Directory might not exist
fs.writeFileSync(
  path.join(directory, 'user.json'),
  user  // Bug 2: Can't write object directly
);

const data = fs.readFileSync(path.join(directory, 'user.json'));
console.log('Name:', data.name);  // Bug 3: data is a Buffer, not parsed

// ─── FS ─────────────────────────────────────────────
fs.readFileSync('f', 'utf-8');                          // Blocking
const data = await fs.promises.readFile('f', 'utf-8');   // Async
fs.createReadStream('f');                                // Streaming
fs.watch('f', (event, filename) => {});                  // File watcher

// ─── PATH ────────────────────────────────────────────
path.join('a', 'b', 'c');            // 'a/b/c' (cross-platform)
path.resolve('dist');                // '/abs/path/dist'
path.parse('/a/b.txt');              // { dir, base, name, ext, root }

// ─── HTTP ────────────────────────────────────────────
http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('OK');
}).listen(3000);

// ─── CRYPTO ──────────────────────────────────────────
crypto.createHash('sha256').update('data').digest('hex');
crypto.randomBytes(32).toString('hex');
crypto.randomUUID();
crypto.timingSafeEqual(Buffer.from('a'), Buffer.from('a'));

// ─── OS ──────────────────────────────────────────────
os.cpus().length;           // CPU core count
os.freemem();               // Free memory in bytes
os.totalmem();              // Total memory

// ─── UTIL ────────────────────────────────────────────
const readFile = util.promisify(fs.readFile);