const handler = {
  get(target, prop, receiver) {
    if (prop in target) {
      return Reflect.get(target, prop, receiver) * 2;
    }
    return Reflect.get(target, prop, receiver);
  },
  set(target, prop, value, receiver) {
    if (typeof value !== "number") return false;
    return Reflect.set(target, prop, value * 3, receiver);
  },
  has(target, prop) {
    return prop.startsWith("x") && Reflect.has(target, prop);
  },
};

const obj = new Proxy({ x1: 10, y1: 20 }, handler);
obj.x2 = 15;
obj.y2 = 40;

console.log(obj.x1);
console.log(obj.x2);
console.log("x1" in obj);
console.log("y1" in obj);
console.log(obj.y2);

const compose = (...fns) => x => fns.reduceRight((acc, fn) => fn(acc), x);
const pipe = (...fns) => x => fns.reduce((acc, fn) => fn(acc), x);

const double = x => x * 2;
const addTen = x => x + 10;
const square = x => x ** 2;
const negate = x => -x;

const transform1 = compose(negate, square, addTen, double);
const transform2 = pipe(negate, square, addTen, double);

console.log(transform1(3));
console.log(transform2(3));

function* range(start, end) {
  while (start < end) {
    yield start++;
  }
}

function* labeled(prefix, gen) {
  for (const val of gen) {
    yield `${prefix}:${val}`;
  }
}

function* pipeline() {
  yield* labeled("A", range(1, 4));
  yield* labeled("B", range(10, 12));
}

const results = [...pipeline()];
console.log(results.length, results[0], results[results.length - 1]);

function Vehicle(make, model, year) {
  this.make = make;
  this.model = model;
  this.year = year;
  this.describe = function () {
    return `${this.year} ${this.make} ${this.model}`;
  };
}

Vehicle.prototype.age = function (currentYear) {
  return currentYear - this.year;
};

const car = new Vehicle("Toyota", "Supra", 1998);
const truck = new Vehicle("Ford", "Raptor", 2021);

console.log(car.describe());
console.log(truck.age(2025));
console.log(car.constructor === Vehicle);
console.log(Object.getPrototypeOf(car) === Vehicle.prototype);

const balance = 9007199254740991n; // Number.MAX_SAFE_INTEGER as BigInt
const fee = 1n;
const multiplier = 2n;

const total = (balance + fee) * multiplier;
const asNumber = Number(total);

const isSafe = Number.isSafeInteger(asNumber);
const isExact = BigInt(asNumber) === total;

console.log(`${total}n | safe: ${isSafe} | exact: ${isExact}`);

console.log('1: start');

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

Promise.resolve()
  .then(() => {
    console.log('3: promise 1');
    return Promise.resolve('chained');
  })
  .then((val) => console.log(`4: ${val}`));

queueMicrotask(() => console.log('5: microtask'));

new Promise((resolve) => {
  console.log('6: executor');
  resolve();
}).then(() => console.log('7: promise 2'));

console.log('8: end');

class BankAccount {
  #balance;
  #transactionHistory = [];

  constructor(initialBalance) {
    this.#balance = initialBalance;
  }

  deposit(amount) {
    this.#balance += amount;
    this.#transactionHistory.push(`+${amount}`);
    return this;
  }

  withdraw(amount) {
    this.#balance -= amount;
    this.#transactionHistory.push(`-${amount}`);
    return this;
  }

  get summary() {
    return `Balance: ${this.#balance} | Transactions: ${this.#transactionHistory.join(", ")}`;
  }

  static hasPrivateBalance(obj) {
    return #balance in obj;
  }
}

const account = new BankAccount(100);
account.deposit(50).deposit(25).withdraw(30);

console.log(account.summary);
console.log(BankAccount.hasPrivateBalance(account));
console.log(BankAccount.hasPrivateBalance({}));

class EventEmitter {
  #listeners = new Map();

  on(event, listener) {
    if (!this.#listeners.has(event)) {
      this.#listeners.set(event, []);
    }
    this.#listeners.get(event).push(listener);
    return this;
  }

  emit(event, ...args) {
    const handlers = this.#listeners.get(event) ?? [];
    handlers.forEach(fn => fn(...args));
    return this;
  }

  once(event, listener) {
    const wrapper = (...args) => {
      listener(...args);
      this.off(event, wrapper);
    };
    return this.on(event, wrapper);
  }

  off(event, listener) {
    const updated = (this.#listeners.get(event) ?? []).filter(fn => fn !== listener);
    this.#listeners.set(event, updated);
    return this;
  }
}

const emitter = new EventEmitter();
const log = [];

emitter.on("data", val => log.push(`on:${val}`));
emitter.once("data", val => log.push(`once:${val}`));
emitter.on("data", val => log.push(`on2:${val}`));

emitter.emit("data", "A");
emitter.emit("data", "B");

console.log(log.join(", "));

function makeCounter(start = 0, step = 1) {
  let count = start;
  const history = [];

  return {
    increment() {
      count += step;
      history.push(count);
      return this;
    },
    decrement() {
      count -= step;
      history.push(count);
      return this;
    },
    getHistory: () => history,
    getCount: () => count,
  };
}

const counter = makeCounter(10, 3);
counter.increment().increment().decrement();

console.log(counter.getCount());
console.log(counter.getHistory());