// Браузер
var globalVar = 'I am on window';
console.log(window.globalVar); // "I am on window"

function globalFunction() {
  return 'Also on window';
}
console.log(window.globalFunction); // [Function: globalFunction]

// Неявна глобальна змінна (без var/let/const)
implicitGlobal = 'Dangerous!';
console.log(window.implicitGlobal); // "Dangerous!"

// let та const НЕ потрапляють у window
let blockScoped = 'Not on window';
const alsoBlockScoped = 'Not on window either';
console.log(window.blockScoped); // undefined
console.log(window.alsoBlockScoped); // undefined

// Node.js (CommonJS модуль)
const myVariable = 'Module-scoped';
console.log(global.myVariable); // undefined

// Явне додавання у глобальний простір (антипатерн!)
global.myVariable = 'Truly global';
console.log(global.myVariable); // "Truly global"

console.log('Node.js version:', process.version);        // v22.11.0
console.log('V8 version:', process.versions.v8);         // 12.4.254.20-node.23
console.log('libuv version:', process.versions.uv);      // 1.48.0
console.log('OpenSSL version:', process.versions.openssl); // 3.0.13+quic

console.log('Platform:', process.platform);  // darwin, linux, win32
console.log('Architecture:', process.arch);  // x64, arm64, x86
console.log('Process ID:', process.pid);     // 42891

import path from 'node:path';

// Умовна логіка залежно від платформи
if (process.platform === 'win32') {
  console.log('Running on Windows');
  // Використання зворотних слешів у шляхах: C:\Users\...
} else if (process.platform === 'darwin') {
  console.log('Running on macOS');
  // Unix-подібні шляхи: /Users/...
} else if (process.platform === 'linux') {
  console.log('Running on Linux');
  // Unix-подібні шляхи: /home/...
}

// Умовна логіка залежно від архітектури
if (process.arch === 'arm64') {
  console.log('Running on ARM64 architecture (Apple Silicon, Raspberry Pi)');
} else if (process.arch === 'x64') {
  console.log('Running on x86-64 architecture (Intel/AMD)');
}

// temperature.js
const args = process.argv.slice(2); // Пропускаємо перші два елементи

if (args.length < 2) {
  console.error('Usage: node temperature.js <value> <unit>');
  console.error('Example: node temperature.js 25 celsius');
  process.exit(1); // Код виходу 1 вказує на помилку
}

const value = parseFloat(args[0]);
const unit = args[1].toLowerCase();

if (isNaN(value)) {
  console.error('Error: Temperature value must be a number');
  process.exit(1);
}

switch (unit) {
  case 'celsius':
  case 'c':
    const fahrenheit = (value * 9/5) + 32;
    const kelvin = value + 273.15;
    console.log(`${value}°C = ${fahrenheit.toFixed(2)}°F = ${kelvin.toFixed(2)}K`);
    break;
    
  case 'fahrenheit':
  case 'f':
    const celsius = (value - 32) * 5/9;
    const kelvinFromF = celsius + 273.15;
    console.log(`${value}°F = ${celsius.toFixed(2)}°C = ${kelvinFromF.toFixed(2)}K`);
    break;
    
  case 'kelvin':
  case 'k':
    const celsiusFromK = value - 273.15;
    const fahrenheitFromK = (celsiusFromK * 9/5) + 32;
    console.log(`${value}K = ${celsiusFromK.toFixed(2)}°C = ${fahrenheitFromK.toFixed(2)}°F`);
    break;
    
  default:
    console.error(`Error: Unknown unit "${unit}". Use celsius, fahrenheit, or kelvin.`);
    process.exit(1);
}

// Доступ до змінної оточення
const port = process.env.PORT || 3000;
const nodeEnv = process.env.NODE_ENV || 'development';
const databaseUrl = process.env.DATABASE_URL;

console.log(`Starting server in ${nodeEnv} mode on port ${port}`);

if (!databaseUrl) {
  console.error('ERROR: DATABASE_URL environment variable is not set');
  process.exit(1);
}

console.log('Current working directory:', process.cwd());
// /Users/arakviel/projects/my-app (залежить від місця запуску)

// Файл: /Users/arakviel/projects/my-app/src/utils/helper.js
console.log('Module directory:', __dirname);
// /Users/arakviel/projects/my-app/src/utils

console.log('Module file:', __filename);
// /Users/arakviel/projects/my-app/src/utils/helper.js

import fs from 'node:fs';
import path from 'node:path';
import { fileURLToPath } from 'node:url';

const __filename: string = fileURLToPath(import.meta.url);
const __dirname: string = path.dirname(__filename);

// ❌ НЕПРАВИЛЬНО: залежить від місця запуску
const configWrong = fs.readFileSync('config.json', 'utf8');

// ✅ ПРАВИЛЬНО: завжди шукає config.json у директорії модуля
const configPath = path.join(__dirname, 'config.json');
const configRight = fs.readFileSync(configPath, 'utf8');

// ✅ ТАКОЖ ПРАВИЛЬНО: шукає config.json у корені проєкту
const rootConfigPath = path.join(process.cwd(), 'config.json');
const rootConfig = fs.readFileSync(rootConfigPath, 'utf8');

import fs from 'node:fs';

try {
  const data: string = fs.readFileSync('important-file.json', 'utf8');
  const config = JSON.parse(data);
  
  if (!config.apiKey) {
    console.error('ERROR: apiKey is missing in configuration');
    process.exit(1); // Код помилки 1
  }
  
  console.log('Configuration loaded successfully');
  // Продовження роботи програми
  
} catch (error) {
  const message = error instanceof Error ? error.message : 'Unknown error';
  console.error('FATAL ERROR:', message);
  process.exit(2); // Код помилки 2 (інший тип помилки)
}

// SIGINT — Ctrl+C у терміналі
process.on('SIGINT', () => {
  console.log('\nReceived SIGINT (Ctrl+C). Exiting gracefully...');
  process.exit(0);
});

// SIGTERM — запит на завершення від менеджера процесів (Docker, Kubernetes, systemd)
process.on('SIGTERM', () => {
  console.log('Received SIGTERM. Shutting down...');
  process.exit(0);
});

// uncaughtException — необроблене виключення
process.on('uncaughtException', (error) => {
  console.error('FATAL: Uncaught Exception', error);
  process.exit(1);
});

// unhandledRejection — необроблений reject у Promise
process.on('unhandledRejection', (reason, promise) => {
  console.error('FATAL: Unhandled Promise Rejection at:', promise, 'reason:', reason);
  process.exit(1);
});

// Час роботи процесу у секундах
console.log('Uptime:', process.uptime(), 'seconds');

// Використання пам'яті
const memUsage = process.memoryUsage();
console.log('Memory Usage:');
console.log('  RSS:', (memUsage.rss / 1024 / 1024).toFixed(2), 'MB');           // Resident Set Size
console.log('  Heap Total:', (memUsage.heapTotal / 1024 / 1024).toFixed(2), 'MB');
console.log('  Heap Used:', (memUsage.heapUsed / 1024 / 1024).toFixed(2), 'MB');
console.log('  External:', (memUsage.external / 1024 / 1024).toFixed(2), 'MB');  // C++ об'єкти

// Використання CPU
const startUsage = process.cpuUsage();
// ... виконання коду ...
const endUsage = process.cpuUsage(startUsage);
console.log('CPU Usage:', {
  user: endUsage.user,      // Мікросекунди у user mode
  system: endUsage.system   // Мікросекунди у kernel mode
});

// Звичайне повідомлення → stdout
console.log('Server started successfully');

// Інформаційне повідомлення → stdout
console.info('Database connection established');

// Попередження → stderr
console.warn('Deprecated API usage detected');

// Помилка → stderr
console.error('Failed to connect to Redis');

const username = 'john_doe';
const userId = 42;
const loginTime = new Date();

// %s — рядок, %d/%i — ціле число, %f — число з плаваючою точкою, %o — об'єкт
console.log('User %s (ID: %d) logged in at %s', username, userId, loginTime.toISOString());
// User john_doe (ID: 42) logged in at 2026-09-02T14:30:00.000Z

const price = 19.99;
console.log('Total: $%f', price);  // Total: $19.99
console.log('Total: $%.2f', price); // Total: $19.99 (заокруглення до 2 знаків)

const user = { id: 1, name: 'Alice', role: 'admin' };
console.log('User object: %o', user);
// User object: { id: 1, name: 'Alice', role: 'admin' }

console.log(`User ${username} (ID: ${userId}) logged in at ${loginTime.toISOString()}`);

const users = [
  { id: 1, name: 'Alice', email: 'alice@example.com', role: 'admin' },
  { id: 2, name: 'Bob', email: 'bob@example.com', role: 'user' },
  { id: 3, name: 'Charlie', email: 'charlie@example.com', role: 'moderator' }
];

console.table(users);

console.table(users, ['name', 'role']);

console.time('Database Query');

// Симуляція запиту до бази даних
setTimeout(() => {
  console.timeEnd('Database Query');
  // Database Query: 150.234ms
}, 150);

// Вкладені таймери
console.time('Total Operation');
console.time('Step 1: Validation');
// ... код валідації ...
console.timeEnd('Step 1: Validation');

console.time('Step 2: Processing');
// ... код обробки ...
console.timeEnd('Step 2: Processing');

console.timeEnd('Total Operation');

console.time('Download');

setTimeout(() => {
  console.timeLog('Download', 'Downloaded 25%');
}, 250);

setTimeout(() => {
  console.timeLog('Download', 'Downloaded 75%');
}, 750);

setTimeout(() => {
  console.timeEnd('Download');
}, 1000);

console.log('Application started');

console.group('Database Configuration');
console.log('Host:', process.env.DB_HOST);
console.log('Port:', process.env.DB_PORT);
console.log('Database:', process.env.DB_NAME);
console.groupEnd();

console.group('API Configuration');
console.log('Base URL:', process.env.API_URL);
console.log('Timeout:', process.env.API_TIMEOUT);

console.group('Rate Limiting');
console.log('Max requests per minute:', 100);
console.log('Burst limit:', 20);
console.groupEnd(); // Закриття вкладеної групи

console.groupEnd(); // Закриття групи API Configuration

console.log('All services initialized');

function processOrder(orderId) {
  validateOrder(orderId);
}

function validateOrder(orderId) {
  if (orderId < 0) {
    console.trace('Invalid order ID detected');
  }
}

processOrder(-1);

const buffer1 = Buffer.from('Hello, Node.js!');
console.log(buffer1);
// <Buffer 48 65 6c 6c 6f 2c 20 4e 6f 64 65 2e 6a 73 21>

console.log(buffer1.length); // 15 (кількість байтів)
console.log(buffer1[0]);     // 72 (код ASCII літери 'H')

const buffer2 = Buffer.from([72, 101, 108, 108, 111]); // "Hello" у ASCII
console.log(buffer2.toString()); // "Hello"

const buffer3 = Buffer.alloc(10); // 10 байтів, заповнених нулями
console.log(buffer3);
// <Buffer 00 00 00 00 00 00 00 00 00 00>

const buffer4 = Buffer.alloc(5, 'AB'); // Заповнення патерном 'AB'
console.log(buffer4);
// <Buffer 41 42 41 42 41> (ABABA)

const buffer5 = Buffer.allocUnsafe(10);
console.log(buffer5);
// <Buffer 38 f2 7a 01 00 00 00 00 00 00> (випадкові дані з пам'яті!)

const text = 'Привіт, світ!';

// UTF-8 (за замовчуванням, підтримує кирилицю та емодзі)
const utf8Buffer = Buffer.from(text, 'utf8');
console.log('UTF-8:', utf8Buffer.length, 'bytes');
// UTF-8: 27 bytes (кирилиця займає 2 байти на символ)

// Base64 (кодування для передачі бінарних даних у текстовому форматі)
const base64 = utf8Buffer.toString('base64');
console.log('Base64:', base64);
// 0J/RgNC40LLRltGCLCDRgdCy0ZbRgiE=

const decodedBuffer = Buffer.from(base64, 'base64');
console.log('Decoded:', decodedBuffer.toString('utf8'));
// Decoded: Привіт, світ!

// Hexadecimal (шістнадцяткове представлення)
const hexString = utf8Buffer.toString('hex');
console.log('Hex:', hexString);
// d0bfd180d0b8d0b2d196d182...

const buffer = Buffer.alloc(8);

// Запис 32-бітного цілого числа (Little-Endian)
buffer.writeInt32LE(305419896, 0);
console.log(buffer);
// <Buffer 78 56 34 12 00 00 00 00>

// Читання 32-бітного цілого числа
const value = buffer.readInt32LE(0);
console.log(value); // 305419896

// Запис числа з плаваючою точкою (64-біт, double)
const floatBuffer = Buffer.alloc(8);
floatBuffer.writeDoubleLE(3.141592653589793, 0);
console.log(floatBuffer.readDoubleLE(0)); // 3.141592653589793

import fs from 'node:fs';

// Читання файлу як Buffer
const imageBuffer: Buffer = fs.readFileSync('photo.jpg');
console.log('File size:', imageBuffer.length, 'bytes');
console.log('First 16 bytes:', imageBuffer.subarray(0, 16));

// Перевірка сигнатури файлу (Magic Number)
if (imageBuffer[0] === 0xFF && imageBuffer[1] === 0xD8) {
  console.log('This is a JPEG image');
} else if (imageBuffer[0] === 0x89 && imageBuffer[1] === 0x50) {
  console.log('This is a PNG image');
}

// Запис буфера у новий файл
fs.writeFileSync('photo-copy.jpg', imageBuffer);

const buf1 = Buffer.from('Hello, ');
const buf2 = Buffer.from('world!');
const buf3 = Buffer.from(' Welcome to Node.js.');

const combined = Buffer.concat([buf1, buf2, buf3]);
console.log(combined.toString());
// Hello, world! Welcome to Node.js.

console.log('Total size:', combined.length, 'bytes');
// Total size: 35 bytes

// setTimeout: одноразове виконання через затримку
const timeoutId = setTimeout(() => {
  console.log('Executed after 2 seconds');
}, 2000);

// Скасування таймера
clearTimeout(timeoutId);

// setInterval: повторюване виконання з інтервалом
let counter = 0;
const intervalId = setInterval(() => {
  counter++;
  console.log(`Interval tick ${counter}`);
  
  if (counter >= 5) {
    clearInterval(intervalId);
    console.log('Interval stopped');
  }
}, 1000);

console.log('1: Script start');

setTimeout(() => {
  console.log('3: setTimeout callback');
}, 0);

setImmediate(() => {
  console.log('4: setImmediate callback');
});

console.log('2: Script end');

import fs from 'node:fs';

fs.readFile(__filename, () => {
  console.log('Inside I/O callback');
  
  setTimeout(() => {
    console.log('setTimeout inside I/O');
  }, 0);
  
  setImmediate(() => {
    console.log('setImmediate inside I/O');
  });
});

console.log('1: Start');

setTimeout(() => console.log('4: setTimeout'), 0);

Promise.resolve().then(() => console.log('3: Promise'));

process.nextTick(() => {
  console.log('2: nextTick');
});

console.log('1.5: Synchronous end');

const hugeArray = Array.from({ length: 1000000 }, (_, i) => i);

function processBatch(data, batchSize, callback) {
  let index = 0;
  
  function processChunk() {
    const endIndex = Math.min(index + batchSize, data.length);
    
    // Обробка частини даних
    for (let i = index; i < endIndex; i++) {
      // Симуляція обчислень
      data[i] = data[i] * 2;
    }
    
    index = endIndex;
    
    if (index < data.length) {
      // Відкладення наступної ітерації, щоб Event Loop міг обробити інші події
      setImmediate(processChunk);
    } else {
      callback();
    }
  }
  
  processChunk();
}

console.log('Processing started...');

processBatch(hugeArray, 10000, () => {
  console.log('Processing complete!');
  console.log('First element:', hugeArray[0]);
  console.log('Last element:', hugeArray[hugeArray.length - 1]);
});

// Event Loop залишається вільним для інших операцій
setTimeout(() => {
  console.log('This timer executes during processing');
}, 50);

// Файл: /Users/arakviel/projects/app/src/server.js

console.log(import.meta.url);
// file:///Users/arakviel/projects/app/src/server.js

// Отримання __dirname та __filename для ES Modules
import { fileURLToPath } from 'node:url';
import { dirname } from 'node:path';

const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);

console.log('Module file:', __filename);
console.log('Module directory:', __dirname);

async function loadModule(moduleName) {
  try {
    const module = await import(`./${moduleName}.js`);
    return module;
  } catch (error) {
    console.error(`Failed to load module ${moduleName}:`, error.message);
  }
}

// Умовне завантаження залежно від конфігурації
const config = { useAdvancedFeatures: true };

if (config.useAdvancedFeatures) {
  const advanced = await import('./advanced-features.js');
  advanced.initialize();
}