// Expression statements
x = 5;
y = x + 10;

// Block statement with local scope
{
    let blockScoped = 'local';
    const PI = 3.14159;
}

// Labeled statement for loop control
outer: for (let i = 0; i < 3; i++) {
    for (let j = 0; j < 3; j++) {
        if (i === 1 && j === 1) break outer;
    }
}

// var: function-scoped, hoisted
console.log(x); // undefined (hoisted)
var x = 5;
if (true) {
    var x = 10; // Same variable
}
console.log(x); // 10

// let: block-scoped, TDZ
// console.log(y); // ReferenceError: Cannot access before initialization
let y = 5;
if (true) {
    let y = 10; // Different variable
    console.log(y); // 10
}
console.log(y); // 5

// const: block-scoped, immutable binding
const z = 5;
// z = 10; // TypeError: Assignment to constant
const obj = { a: 1 };
obj.a = 2; // ✓ OK: mutation allowed
// obj = {}; // ✗ TypeError: reassignment not allowed

// Constants
const MAX_RETRY_COUNT = 3;
const API_BASE_URL = 'https://api.example.com';

// Variables and functions (camelCase)
let userName = 'John';
function calculateTotal(items) {
    return items.reduce((sum, item) => sum + item.price, 0);
}

// Classes (PascalCase)
class UserProfile {
    #privateData; // True private field
    
    constructor(name) {
        this._internalId = Math.random(); // Convention-based private
        this.#privateData = name;
    }
}

// Boolean variables (descriptive prefix)
const isActive = true;
const hasPermission = false;
const canEdit = user.role === 'admin';

/**
 * Calculates the total price with tax
 * @param {number} price - Base price of item
 * @param {number} taxRate - Tax rate as decimal (e.g., 0.08)
 * @returns {number} Total price including tax
 * @throws {TypeError} If parameters are not numbers
 * @example
 * calculateTotal(100, 0.08); // Returns 108
 */
function calculateTotal(price, taxRate) {
    if (typeof price !== 'number' || typeof taxRate !== 'number') {
        throw new TypeError('Parameters must be numbers');
    }
    return price * (1 + taxRate);
}

/**
 * @typedef {Object} User
 * @property {string} name - User's full name
 * @property {number} age - User's age
 * @property {string[]} roles - User roles
 */

/** @type {User} */
const user = {
    name: 'John Doe',
    age: 30,
    roles: ['admin', 'user']
};

'use strict';

// 1. Prevents implicit globals
// mistypedVariable = 17; // ReferenceError (without strict: creates global)

// 2. Prevents duplicate parameters
// function sum(a, a, c) { } // SyntaxError (without strict: allowed)

// 3. Makes 'this' undefined in functions
function showThis() {
    console.log(this); // undefined (without strict: window/global)
}
showThis();

// 4. Prevents assignment to non-writable properties
const obj = {};
Object.defineProperty(obj, 'x', { value: 42, writable: false });
// obj.x = 9; // TypeError (without strict: silently fails)

// 5. Prevents deleting variables
let x = 10;
// delete x; // SyntaxError (without strict: returns false)

// 6. Safer eval
eval('var y = 2;');
// console.log(y); // ReferenceError (without strict: y accessible)

// 7. Octal literals banned
// const octal = 0123; // SyntaxError
const octalCorrect = 0o123; // ✓ Use 0o prefix

// Immutability: primitives are immutable
let str = "hello";
str[0] = "H"; // No effect, strings are immutable
console.log(str); // "hello"

// Primitive vs Wrapper auto-boxing
let num = 42;
console.log(num.toString()); // "42" - temporary wrapper created

// Special number values
console.log(1 / 0);        // Infinity
console.log(-1 / 0);       // -Infinity
console.log(0 / 0);        // NaN
console.log(Number.MAX_SAFE_INTEGER); // 9007199254740991

// Symbols are unique
const sym1 = Symbol("desc");
const sym2 = Symbol("desc");
console.log(sym1 === sym2); // false (each is unique)

// BigInt for large integers
const bigNum = 9007199254740991n + 1n;
console.log(bigNum); // 9007199254740992n

// Primitives: value copied
let a = 5;
let b = a; // Copy value
b = 10;
console.log(a); // 5 (unchanged)

// References: pointer copied
let obj1 = { x: 5 };
let obj2 = obj1; // Copy reference
obj2.x = 10;
console.log(obj1.x); // 10 (both point to same object)

// Comparison
let str1 = "hello";
let str2 = "hello";
console.log(str1 === str2); // true (value comparison)

let arr1 = [1, 2, 3];
let arr2 = [1, 2, 3];
console.log(arr1 === arr2); // false (different references)
console.log(arr1 === arr1); // true (same reference)

// Function parameter behavior
function modifyPrimitive(x) {
    x = 100; // Local copy modified
}
let num = 5;
modifyPrimitive(num);
console.log(num); // 5 (original unchanged)

function modifyObject(obj) {
    obj.value = 100; // Original object modified
}
let data = { value: 5 };
modifyObject(data);
console.log(data.value); // 100 (original changed)

// String coercion (+ with string)
console.log("5" + 3);      // "53" (number to string)
console.log("5" + true);   // "5true"

// Numeric coercion (other operators)
console.log("5" - 3);      // 2 (string to number)
console.log("5" * "2");    // 10
console.log(true + 1);     // 2 (true → 1)
console.log(false + 1);    // 1 (false → 0)

// Boolean coercion
console.log(Boolean(""));    // false
console.log(Boolean(0));     // false
console.log(Boolean(NaN));   // false
console.log(Boolean(null));  // false
console.log(Boolean(undefined)); // false
console.log(Boolean([]));    // true (object)
console.log(Boolean({}));    // true (object)

// Explicit conversions
console.log(Number("123"));     // 123
console.log(Number("12.5"));    // 12.5
console.log(Number("abc"));     // NaN
console.log(parseInt("123px")); // 123 (parses until non-digit)
console.log(String(123));       // "123"
console.log(+"42");             // 42 (unary +)

// Falsy values (6 total)
if (!undefined || !null || !0 || !NaN || !"" || !false) {
    console.log("All falsy values");
}

// typeof: basic primitive checking
console.log(typeof 42);           // "number"
console.log(typeof "hello");      // "string"
console.log(typeof true);         // "boolean"
console.log(typeof undefined);    // "undefined"
console.log(typeof Symbol());     // "symbol"
console.log(typeof 42n);          // "bigint"
console.log(typeof null);         // "object" ⚠️ (legacy bug)
console.log(typeof []);           // "object"
console.log(typeof {});           // "object"
console.log(typeof function(){}); // "function"

// instanceof: prototype chain checking
console.log([] instanceof Array);       // true
console.log({} instanceof Object);      // true
console.log(new Date() instanceof Date); // true
console.log(42 instanceof Number);      // false (primitive)

// Array.isArray: reliable array detection
console.log(Array.isArray([]));         // true
console.log(Array.isArray({}));         // false
console.log(Array.isArray("array"));    // false

// Object.prototype.toString: most reliable
const toString = Object.prototype.toString;
console.log(toString.call([]));         // "[object Array]"
console.log(toString.call({}));         // "[object Object]"
console.log(toString.call(null));       // "[object Null]"
console.log(toString.call(undefined));  // "[object Undefined]"
console.log(toString.call(new Date())); // "[object Date]"
console.log(toString.call(/regex/));    // "[object RegExp]"

// Utility type checking function
function getType(value) {
    if (value === null) return 'null';
    if (Array.isArray(value)) return 'array';
    return typeof value;
}
console.log(getType(null));  // "null"
console.log(getType([]));    // "array"
console.log(getType(42));    // "number"

// Basic symbol creation (each is unique)
const sym1 = Symbol("id");
const sym2 = Symbol("id");
console.log(sym1 === sym2); // false (unique)

// Symbols as object properties
const id = Symbol("id");
const user = {
    name: "John",
    [id]: 123 // Symbol as computed property
};
console.log(user[id]); // 123
console.log(Object.keys(user)); // ["name"] (symbol hidden)

// Symbol registry (shared across realm)
const globalSym1 = Symbol.for("app.id");
const globalSym2 = Symbol.for("app.id");
console.log(globalSym1 === globalSym2); // true (same symbol)
console.log(Symbol.keyFor(globalSym1)); // "app.id"

// Well-known symbols: Symbol.iterator
const iterable = {
    data: [1, 2, 3],
    [Symbol.iterator]() {
        let index = 0;
        return {
            next: () => ({
                value: this.data[index],
                done: index++ >= this.data.length
            })
        };
    }
};
console.log([...iterable]); // [1, 2, 3]

// Symbol.toStringTag
class CustomClass {
    get [Symbol.toStringTag]() {
        return "CustomClass";
    }
}
const obj = new CustomClass();
console.log(Object.prototype.toString.call(obj)); // "[object CustomClass]"

// Symbol.toPrimitive
const obj2 = {
    [Symbol.toPrimitive](hint) {
        if (hint === "number") return 42;
        if (hint === "string") return "hello";
        return true;
    }
};
console.log(+obj2);     // 42 (number hint)
console.log(`${obj2}`); // "hello" (string hint)
console.log(obj2 + ""); // "true" (default hint)

// Creating BigInts
const big1 = 9007199254740991n;
const big2 = BigInt("9007199254740991");
const big3 = BigInt(Number.MAX_SAFE_INTEGER);

// Arithmetic operations
console.log(100n + 50n);   // 150n
console.log(100n - 50n);   // 50n
console.log(100n * 2n);    // 200n
console.log(100n / 3n);    // 33n (integer division, truncates)
console.log(100n % 3n);    // 1n
console.log(2n ** 100n);   // Very large number (2^100)

// Comparison
console.log(10n === 10);   // false (strict equality)
console.log(10n == 10);    // true (loose equality with coercion)
console.log(10n < 20n);    // true
console.log(5n > 3);       // true (coercion in comparison)

// Limitations
// console.log(10n + 5);   // ❌ TypeError: Cannot mix BigInt and Number
console.log(10n + BigInt(5)); // ✓ 15n (explicit conversion)
console.log(Number(10n) + 5); // ✓ 15 (convert to Number)

// console.log(+10n);      // ❌ TypeError: Cannot convert BigInt
console.log(Number(10n));  // ✓ 10 (explicit conversion)

// Bitwise operations
console.log(5n & 3n);     // 1n (binary AND)
console.log(5n | 3n);     // 7n (binary OR)
console.log(5n ^ 3n);     // 6n (binary XOR)
console.log(5n << 2n);    // 20n (left shift)

// Use case: Precise large integer calculations
const largeNumber = 9007199254740992n; // Beyond Number.MAX_SAFE_INTEGER
console.log(largeNumber + 1n); // 9007199254740993n (exact)
console.log(Number.MAX_SAFE_INTEGER + 1); // 9007199254740992 (precision lost)

// var hoisting: declaration hoisted, initialized to undefined
console.log(x); // undefined (no error)
var x = 5;
console.log(x); // 5

// let/const TDZ: declaration hoisted but not initialized
// console.log(y); // ReferenceError: Cannot access 'y' before initialization
let y = 10;
console.log(y); // 10

// Function declaration: fully hoisted
greet(); // "Hello" (works before declaration)
function greet() {
    console.log("Hello");
}

// Function expression: only variable hoisted
// sayHi(); // TypeError: sayHi is not a function
var sayHi = function() {
    console.log("Hi");
};
sayHi(); // "Hi"

// TDZ example with block scope
{
    // TDZ starts here for 'temp'
    // console.log(temp); // ReferenceError
    // const result = doSomething(temp); // ReferenceError
    
    let temp = 5; // TDZ ends here
    console.log(temp); // 5 (now accessible)
}

// Class TDZ
// const p = new Person(); // ReferenceError
class Person {
    constructor(name) { this.name = name; }
}
const p = new Person("John"); // Works after declaration

// Global scope
var globalVar = 'global var';
let globalLet = 'global let';
const globalConst = 'global const';

function demoScopes() {
    // Function scope
    var functionVar = 'function scoped';
    let functionLet = 'function scoped';
    
    console.log(globalVar); // Accessible
    
    if (true) {
        // Block scope
        var blockVar = 'not block scoped (var)';
        let blockLet = 'block scoped';
        const blockConst = 'block scoped';
        
        console.log(functionVar); // Accessible from outer function
        console.log(blockLet);    // Accessible within block
    }
    
    console.log(blockVar);  // Accessible (var ignores blocks)
    // console.log(blockLet); // ReferenceError (block-scoped)
    
    // Loop scope
    for (let i = 0; i < 3; i++) {
        // 'i' is block-scoped to this loop
        setTimeout(() => console.log(i), 100); // Prints 0, 1, 2
    }
    
    for (var j = 0; j < 3; j++) {
        // 'j' is function-scoped (shared)
        setTimeout(() => console.log(j), 100); // Prints 3, 3, 3
    }
}

// Module scope (in ES6 modules)
// Variables not automatically global
// export const moduleVar = 'exported';
// const privateVar = 'not exported';

// Catch block scope
try {
    throw new Error('test');
} catch (error) {
    // 'error' is scoped to catch block
    let catchVar = 'catch scoped';
    console.log(error.message);
}
// console.log(error); // ReferenceError
// console.log(catchVar); // ReferenceError

// Scope chain demonstration
const globalVar = 'global';

function outer() {
    const outerVar = 'outer';
    
    function middle() {
        const middleVar = 'middle';
        
        function inner() {
            const innerVar = 'inner';
            
            // Scope chain: inner → middle → outer → global
            console.log(innerVar);   // Found in inner scope
            console.log(middleVar);  // Found in middle scope (parent)
            console.log(outerVar);   // Found in outer scope (grandparent)
            console.log(globalVar);  // Found in global scope
            
            // Variable lookup order:
            // 1. Check inner scope
            // 2. Check middle scope
            // 3. Check outer scope
            // 4. Check global scope
            // 5. ReferenceError if not found
        }
        
        inner();
        // console.log(innerVar); // ReferenceError (not in scope chain)
    }
    
    middle();
}

outer();

// Lexical scope is determined by code structure
function makeCounter() {
    let count = 0; // In outer function scope
    
    return function() {
        // Lexically scoped to access 'count' from parent
        return ++count;
    };
}

const counter1 = makeCounter();
console.log(counter1()); // 1
console.log(counter1()); // 2

const counter2 = makeCounter();
console.log(counter2()); // 1 (separate scope chain)

// Scope determined at definition, not invocation
let x = 'global x';

function showX() {
    console.log(x); // Lexically bound to global 'x'
}

function demo() {
    let x = 'local x';
    showX(); // Prints "global x" (not "local x")
             // Scope determined where showX was defined
}

demo();

// Basic shadowing
let x = 'outer';

function demo() {
    let x = 'inner'; // Shadows outer 'x'
    console.log(x);  // "inner"
}

demo();
console.log(x); // "outer" (outer unchanged)

// Parameter shadowing
let value = 100;

function processValue(value) { // Parameter shadows outer 'value'
    console.log(value); // Uses parameter, not outer variable
    value = 200;        // Modifies parameter only
}

processValue(50);  // Prints 50
console.log(value); // 100 (outer unchanged)

// Block shadowing
let count = 10;

if (true) {
    let count = 20; // Shadows outer 'count' in block
    console.log(count); // 20
}

console.log(count); // 10 (outer restored after block)

// Nested function shadowing
function outer() {
    let name = 'outer';
    
    function inner() {
        let name = 'inner'; // Shadows parent function's 'name'
        console.log(name);  // "inner"
    }
    
    inner();
    console.log(name); // "outer"
}

outer();

// Loop variable shadowing
for (let i = 0; i < 3; i++) {
    console.log(i); // Loop 'i'
    
    for (let i = 0; i < 2; i++) {
        console.log('  ' + i); // Inner loop 'i' shadows outer
    }
}

// Problematic shadowing to avoid
function calculateTotal() {
    let total = 0;
    
    if (true) {
        let total = 100; // Shadowing can be confusing
        // Which 'total' is which?
    }
    
    return total; // Returns 0, not 100
}

// 1. Private variables pattern
function createCounter() {
    let count = 0; // Private variable
    
    return {
        increment: () => ++count,
        decrement: () => --count,
        getCount: () => count
    };
}

const counter = createCounter();
console.log(counter.increment()); // 1
console.log(counter.increment()); // 2
console.log(counter.getCount());  // 2
// console.log(counter.count); // undefined (private)

// 2. Factory function pattern
function createUser(name) {
    let _name = name; // Private
    let _sessions = 0;
    
    return {
        getName: () => _name,
        login: () => ++_sessions,
        getSessions: () => _sessions
    };
}

const user1 = createUser("Alice");
const user2 = createUser("Bob");
user1.login();
console.log(user1.getSessions()); // 1
console.log(user2.getSessions()); // 0

// 3. Module pattern with IIFE
const calculator = (function() {
    let history = []; // Private state
    
    return {
        add: (a, b) => {
            const result = a + b;
            history.push(`${a} + ${b} = ${result}`);
            return result;
        },
        getHistory: () => [...history] // Return copy
    };
})();

calculator.add(5, 3);
console.log(calculator.getHistory()); // ["5 + 3 = 8"]

// 4. Callback closure preserving context
function fetchDataWithRetry(url, retries) {
    let attempts = 0; // Captured by callback
    
    function attemptFetch() {
        fetch(url)
            .catch(error => {
                if (++attempts < retries) {
                    console.log(`Retry ${attempts}`);
                    attemptFetch(); // Closure accesses 'attempts'
                }
            });
    }
    
    attemptFetch();
}

// 5. Currying with closures
function multiply(a) {
    return function(b) {
        return function(c) {
            return a * b * c;
        };
    };
}

const multiplyBy2 = multiply(2);
const multiplyBy2And3 = multiplyBy2(3);
console.log(multiplyBy2And3(4)); // 24

// 6. Memoization pattern
function memoize(fn) {
    const cache = {}; // Closure maintains cache
    
    return function(...args) {
        const key = JSON.stringify(args);
        if (key in cache) {
            return cache[key];
        }
        const result = fn(...args);
        cache[key] = result;
        return result;
    };
}

const factorial = memoize(n => n <= 1 ? 1 : n * factorial(n - 1));
console.log(factorial(5)); // Computed: 120
console.log(factorial(5)); // Cached: 120

// ===== math.js (Module A) =====
// Private variables (not exported)
const PI = 3.14159;
let calculationCount = 0;

// Private helper function
function log(operation) {
    calculationCount++;
    console.log(`Operation: ${operation}, Count: ${calculationCount}`);
}

// Named exports (public API)
export function add(a, b) {
    log('add');
    return a + b;
}

export function multiply(a, b) {
    log('multiply');
    return a * b;
}

export const TAU = 2 * PI; // Export constant

// Default export
export default function calculate(expr) {
    return eval(expr); // Example only
}

// ===== user.js (Module B) =====
// Module variables are isolated
const userCount = 0; // Won't conflict with other modules

class User {
    constructor(name) {
        this.name = name;
    }
}

export { User, userCount };

// ===== app.js (Main module) =====
// Import from math.js
import calculate, { add, multiply, TAU } from './math.js';
// Import from user.js
import { User, userCount } from './user.js';

// Module-scoped variables (private to this module)
const appName = 'MyApp';
let config = { debug: true };

console.log(add(5, 3));        // 8
console.log(multiply(2, 4));   // 8
console.log(TAU);              // 6.28318

// Cannot access private variables from math.js
// console.log(PI); // ReferenceError
// console.log(calculationCount); // ReferenceError

const user = new User('Alice');

// Top-level 'this' is undefined in modules
console.log(this); // undefined (not window)

// ===== Dynamic imports =====
async function loadModule() {
    if (config.debug) {
        const debugModule = await import('./debug.js');
        debugModule.log('Debug mode enabled');
    }
}

// ===== Barrel export pattern (index.js) =====
// Re-export from multiple modules
export { add, multiply } from './math.js';
export { User } from './user.js';
export { default as calculate } from './math.js';

// Basic arithmetic
console.log(10 + 5);   // 15
console.log(10 - 5);   // 5
console.log(10 * 5);   // 50
console.log(10 / 5);   // 2
console.log(10 % 3);   // 1 (remainder)
console.log(2 ** 3);   // 8 (exponentiation)

// Increment/Decrement
let x = 5;
console.log(x++);      // 5 (returns old value, then increments)
console.log(x);        // 6
console.log(++x);      // 7 (increments, then returns new value)
console.log(x--);      // 7 (returns old value, then decrements)
console.log(--x);      // 5 (decrements, then returns new value)

// String concatenation with +
console.log("Hello" + " " + "World");  // "Hello World"
console.log("5" + 3);    // "53" (string concatenation)
console.log(5 + "3");    // "53"
console.log("5" + 3 + 2); // "532"
console.log(5 + 3 + "2"); // "82" (left to right: 5+3=8, then 8+"2"="82")

// Type coercion with other operators
console.log("10" - 5);   // 5 (string to number)
console.log("10" * "2"); // 20
console.log("10" / "2"); // 5
console.log("10" % 3);   // 1

// Unary operators
console.log(+"42");      // 42 (string to number)
console.log(+"abc");     // NaN
console.log(-"5");       // -5

// Special values
console.log(5 / 0);      // Infinity
console.log(-5 / 0);     // -Infinity
console.log(0 / 0);      // NaN
console.log(NaN + 10);   // NaN (NaN propagates)
console.log(Infinity - 1); // Infinity

// Simple assignment
let x = 10;

// Compound assignments
x += 5;   // x = x + 5;  x is now 15
x -= 3;   // x = x - 3;  x is now 12
x *= 2;   // x = x * 2;  x is now 24
x /= 4;   // x = x / 4;  x is now 6
x %= 5;   // x = x % 5;  x is now 1
x **= 3;  // x = x ** 3; x is now 1

// String concatenation with +=
let str = "Hello";
str += " World";  // str is "Hello World"

// Multiple assignment (right-to-left)
let a, b, c;
a = b = c = 5;  // All are 5
console.log(a, b, c);  // 5 5 5

// Assignment returns value
let y = (x = 10);  // x is 10, y is 10
console.log(x, y);  // 10 10

// Destructuring assignment
let [p, q] = [1, 2];
console.log(p, q);  // 1 2

let {name, age} = {name: "John", age: 30};
console.log(name, age);  // "John" 30

// Compound assignment with side effects
let arr = [10, 20, 30];
let i = 0;
arr[i++] += 5;  // arr[0] becomes 15, then i increments
console.log(arr[0], i);  // 15 1

// Swapping with destructuring
let m = 1, n = 2;
[m, n] = [n, m];  // Swap
console.log(m, n);  // 2 1

// Strict equality (===) - recommended
console.log(5 === 5);        // true
console.log(5 === "5");      // false (different types)
console.log(null === null);  // true
console.log(undefined === undefined); // true

// Loose equality (==) - with type coercion
console.log(5 == "5");       // true (string coerced to number)
console.log(0 == false);     // true (boolean to number)
console.log("" == 0);        // true (string to number)
console.log(null == undefined); // true (special case)

// Inequality
console.log(5 !== "5");      // true (strict)
console.log(5 != "6");       // true (loose)

// Relational operators
console.log(5 < 10);         // true
console.log(10 > 5);         // true
console.log(5 <= 5);         // true
console.log(10 >= 10);       // true

// String comparison (lexicographic)
console.log("apple" < "banana"); // true (a < b)
console.log("10" < "9");         // true (string comparison: "1" < "9")
console.log(10 < "9");           // false (number comparison: 10 > 9)

// Special cases
console.log(NaN === NaN);     // false (use Number.isNaN())
console.log(NaN == NaN);      // false
console.log(Number.isNaN(NaN)); // true (correct way)

console.log(0 === -0);        // true
console.log(Object.is(0, -0)); // false (distinguishes +0 and -0)

// Object comparison (reference)
const obj1 = {a: 1};
const obj2 = {a: 1};
const obj3 = obj1;
console.log(obj1 === obj2);  // false (different references)
console.log(obj1 === obj3);  // true (same reference)

// Array comparison
console.log([1,2] == [1,2]); // false (different references)
console.log([1,2] === [1,2]); // false

// Tricky comparisons to avoid
console.log([] == ![]);      // true (![] is false, [] coerced to "")
console.log([] == false);    // true
console.log("" == 0);        // true
console.log(" " == 0);       // true
console.log("0" == 0);       // true
console.log("0" == false);   // true

// Logical AND (&&) - returns first falsy or last value
console.log(true && true);        // true
console.log(true && false);       // false
console.log(5 && 10);             // 10 (both truthy, returns last)
console.log(0 && 10);             // 0 (first falsy)
console.log(null && "hello");     // null (first falsy)

// Logical OR (||) - returns first truthy or last value
console.log(false || true);       // true
console.log(false || false);      // false (last value)
console.log(5 || 10);             // 5 (first truthy)
console.log(0 || 10);             // 10 (first falsy, returns second)
console.log(null || "default");   // "default" (first falsy)

// Logical NOT (!)
console.log(!true);               // false
console.log(!false);              // true
console.log(!0);                  // true (0 is falsy)
console.log(!"");                 // true ("" is falsy)
console.log(!"hello");            // false ("hello" is truthy)

// Double NOT (!!) - convert to boolean
console.log(!!"hello");           // true
console.log(!!0);                 // false
console.log(!!"");                // false
console.log(!!{});                // true (objects are truthy)

// Short-circuit evaluation - practical uses

// 1. Default values (before ?? was added)
let username = input || "Guest";  // If input is falsy, use "Guest"

// 2. Conditional execution
isLoggedIn && showDashboard();    // Execute if truthy
hasError || showSuccessMessage(); // Execute if falsy

// 3. Guard clauses
function processUser(user) {
    user && user.profile && console.log(user.profile.name);
    // Only accesses nested property if all are truthy
}

// 4. Avoiding function calls
let result = expensiveCheck() || cachedValue;
// If expensiveCheck() is truthy, cachedValue never evaluated

// Short-circuit prevents errors
let obj = null;
let value = obj && obj.property;  // undefined (doesn't throw)
// Without short-circuit: obj.property would throw error

// Combining operators
let access = isAdmin || (isPremium && hasPermission);
console.log(true || (false && error())); // true, error() not called

// Falsy values: false, 0, "", null, undefined, NaN
console.log(false || 0 || "" || null || undefined || NaN || "found");
// "found" (first truthy)

// Basic bitwise operations
console.log(5 & 3);    // 1  (0101 & 0011 = 0001)
console.log(5 | 3);    // 7  (0101 | 0011 = 0111)
console.log(5 ^ 3);    // 6  (0101 ^ 0011 = 0110)
console.log(~5);       // -6 (inverts bits, two's complement)

// Bit shifts
console.log(5 << 1);   // 10  (0101 → 1010) multiply by 2
console.log(5 << 2);   // 20  (0101 → 10100) multiply by 4
console.log(10 >> 1);  // 5   (1010 → 0101) divide by 2
console.log(20 >> 2);  // 5   (10100 → 0101) divide by 4

// Practical use cases

// 1. Check if number is even or odd
function isEven(n) {
    return (n & 1) === 0;
}
console.log(isEven(4));  // true
console.log(isEven(5));  // false

// 2. Flags and permissions
const READ = 1;      // 001
const WRITE = 2;     // 010
const EXECUTE = 4;   // 100

let permissions = 0;
permissions |= READ;       // Add READ permission
permissions |= WRITE;      // Add WRITE permission

console.log(permissions & READ);    // Check if READ (non-zero = true)
console.log(permissions & EXECUTE); // Check if EXECUTE (0 = false)

permissions &= ~WRITE;     // Remove WRITE permission
console.log(permissions);  // 1 (only READ)

// 3. Fast integer conversion
console.log(~~3.14);       // 3 (double NOT truncates decimals)
console.log(5.7 | 0);      // 5 (OR with 0 truncates)
console.log(5.7 >> 0);     // 5 (right shift by 0 truncates)

// 4. XOR swap (without temp variable)
let a = 5, b = 10;
a ^= b;  // a = 5 ^ 10
b ^= a;  // b = 10 ^ (5 ^ 10) = 5
a ^= b;  // a = (5 ^ 10) ^ 5 = 10
console.log(a, b);  // 10 5

// 5. Toggle boolean
let flag = true;
flag ^= 1;  // false (1 ^ 1 = 0)
flag ^= 1;  // true (0 ^ 1 = 1)

// 6. Set specific bit
let n = 0b0000;  // Binary literal
n |= (1 << 2);   // Set bit 2: 0b0100
console.log(n.toString(2));  // "100"

// 7. Clear specific bit
n &= ~(1 << 2);  // Clear bit 2: 0b0000
console.log(n.toString(2));  // "0"

// Optional Chaining (?.)

// Without optional chaining (verbose and error-prone)
let user = null;
// let name = user.profile.name; // TypeError: Cannot read property 'profile' of null
let name = user && user.profile && user.profile.name; // undefined

// With optional chaining (concise and safe)
name = user?.profile?.name; // undefined (no error)

const user2 = {
    profile: {
        name: "Alice",
        address: {
            city: "NYC"
        }
    }
};

console.log(user2?.profile?.name);          // "Alice"
console.log(user2?.profile?.address?.city); // "NYC"
console.log(user2?.profile?.phone);         // undefined (no error)
console.log(user2?.account?.balance);       // undefined

// Optional chaining with arrays
const arr = null;
console.log(arr?.[0]);        // undefined (safe)
console.log(user2?.tags?.[0]); // undefined

// Optional chaining with function calls
const obj = {
    method: function() { return "called"; }
};

console.log(obj.method?.());      // "called"
console.log(obj.nonExistent?.());  // undefined (no error)
console.log(user?.getProfile?.()); // undefined

// Nullish Coalescing (??)

// Problem with || operator
let count = 0;
let value1 = count || 10;  // 10 (0 is falsy, uses default)
let value2 = count ?? 10;  // 0 (0 is not null/undefined)

let text = "";
let msg1 = text || "default";  // "default" ("" is falsy)
let msg2 = text ?? "default";  // "" (empty string is valid)

// Use ?? for actual null/undefined checks
let config = {
    timeout: 0,      // 0 is valid
    enabled: false,  // false is valid
    name: ""         // empty string is valid
};

let timeout = config.timeout ?? 3000;    // 0 (not null/undefined)
let enabled = config.enabled ?? true;    // false (not null/undefined)
let name = config.name ?? "Unnamed";     // "" (not null/undefined)
let missing = config.missing ?? "N/A";   // "N/A" (undefined)

// Combining ?. and ??
const data = {
    user: null,
    settings: { theme: "dark" }
};

let theme = data?.settings?.theme ?? "light";  // "dark"
let userName = data?.user?.name ?? "Guest";    // "Guest"

// Real-world example: API response
function getUserCity(response) {
    return response?.data?.user?.address?.city ?? "Unknown";
}

console.log(getUserCity(null));                    // "Unknown"
console.log(getUserCity({ data: null }));          // "Unknown"
console.log(getUserCity({
    data: { user: { address: { city: "NYC" } } }
})); // "NYC"

// Short-circuit evaluation
let expensiveFn = () => { console.log("Called"); return 42; };
let result = null?.property?.method?.();  // undefined (expensiveFn not called)
console.log(result);  // undefined