Closures, this, Hoisting, and Scope

function applyCoupon(order) {
  if (order.total > 500) {
    var discountVar = 50;      // function-scoped
    let discountLet = 50;      // block-scoped
  }
  console.log(discountVar);    // 50  (or undefined if the if didn't run)
  console.log(discountLet);    // ReferenceError: discountLet is not defined
}

console.log(fee);            // undefined   (var hoisted as undefined)
var fee = 40;

console.log(tax);            // ReferenceError: Cannot access 'tax' before initialization
let tax = 15;

console.log(total(100));     // 140   (function declaration fully hoisted)
function total(amount) { return amount + 40; }

console.log(discount(100));  // TypeError: discount is not a function
var discount = function (amount) { return amount - 10; };

var status = 'placed';

function showStatus() {
  console.log(status);       // undefined, not 'placed'
  var status = 'delivered';  // this var is hoisted to the top of showStatus
}

showStatus();

function createOrderCounter(restaurantName) {
  let count = 0;                       // private: no one outside can touch it

  return function placeOrder() {
    count++;
    return restaurantName + ' order #' + count;
  };
}

const biryaniHouse = createOrderCounter('Biryani House');
const pizzaPoint = createOrderCounter('Pizza Point');

console.log(biryaniHouse());  // Biryani House order #1
console.log(biryaniHouse());  // Biryani House order #2
console.log(pizzaPoint());    // Pizza Point order #1  (separate count)

// memoize: cache delivery estimates per route
function memoize(fn) {
  const cache = new Map();               // remembered by the returned function
  return async function (key) {
    if (cache.has(key)) return cache.get(key);
    const result = await fn(key);
    cache.set(key, result);
    return result;
  };
}

const getEstimate = memoize(fetchEstimateFromMaps);

// Express middleware factory: role is remembered
function requireRole(role) {
  return function (req, res, next) {
    if (req.user.role !== role) return res.status(403).send('Forbidden');
    next();
  };
}

app.post('/restaurants/:id/menu', requireRole('owner'), updateMenu);

for (var i = 0; i < 3; i++) {
  setTimeout(function () { console.log('var:', i); }, 0);
}
// var: 3, var: 3, var: 3   -> one shared i, already 3 when the callbacks run

for (let j = 0; j < 3; j++) {
  setTimeout(function () { console.log('let:', j); }, 0);
}
// let: 0, let: 1, let: 2   -> let creates a new j for every loop iteration

const restaurant = {
  name: 'Biryani House',

  getName: function () {
    return this.name;
  },

  getNameArrow: () => {
    return this.name;          // arrow: 'this' from the module, not restaurant
  },

  getNameLater: function () {
    setTimeout(() => {
      console.log('later:', this.name);   // arrow inside a method: uses getNameLater's this
    }, 0);
  }
};

console.log(restaurant.getName());       // Biryani House
console.log(restaurant.getNameArrow());  // undefined (top-level this in CommonJS is module.exports = {})
restaurant.getNameLater();               // later: Biryani House

const getName = restaurant.getName;
console.log(getName());                  // undefined: plain call, 'this' lost

class OrderService {
  constructor() {
    this.pending = [];
  }

  addOrder(order) {
    this.pending.push(order);
  }
}

const service = new OrderService();
const orders = [{ id: 1 }, { id: 2 }];

// BUG: TypeError: Cannot read properties of undefined (reading 'pending')
orders.forEach(service.addOrder);

// FIX 1: bind 'this' permanently
orders.forEach(service.addOrder.bind(service));

// FIX 2: arrow function keeps the method call
orders.forEach((order) => service.addOrder(order));

// FIX 3: class field arrow, bound for every instance
class NotificationService {
  constructor() { this.sent = 0; }
  send = (userId) => { this.sent++; };
}