const EventEmitter = (() => {
  const listeners = new WeakMap();

  return class {
    constructor() {
      listeners.set(this, {});
    }

    on(event, fn) {
      const map = listeners.get(this);
      (map[event] ??= []).push(fn);
      return this;
    }

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

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

bus
  .on("data", val => log.push(`A:${val}`))
  .on("data", val => log.push(`B:${val}`))
  .on("done", ()  => log.push("done"));

bus.emit("data", 1).emit("data", 2).emit("done");

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

class Vehicle {
  #speed = 0;

  constructor(brand) {
    this.brand = brand;
  }

  accelerate(amount) {
    this.#speed += amount;
    return this;
  }

  getSpeed() {
    return this.#speed;
  }

  toString() {
    return `${this.brand} @ ${this.#speed}km/h`;
  }
}

class Car extends Vehicle {
  #gear = 1;

  constructor(brand, model) {
    super(brand);
    this.model = model;
  }

  shiftUp() {
    this.#gear++;
    return this;
  }

  toString() {
    return `${super.toString()} [Gear ${this.#gear}]`;
  }
}

const car = new Car("Toyota", "Supra");
car.accelerate(60).accelerate(40).shiftUp().shiftUp();

console.log(car.toString());
console.log(car instanceof Car);
console.log(car instanceof Vehicle);
console.log(Object.getPrototypeOf(Car) === Vehicle);

const delay = (ms, val) => new Promise(res => setTimeout(res, ms, val));

async function pipeline(...fns) {
  return async (input) => {
    let result = input;
    for (const fn of fns) {
      result = await fn(result);
    }
    return result;
  };
}

const double  = async (x) => delay(10, x * 2);
const addTen  = async (x) => delay(10, x + 10);
const square  = async (x) => delay(10, x ** 2);

(async () => {
  const process = await pipeline(double, addTen, square);
  const output  = await process(3);
  console.log(output);
})();

const inventory = new Map([
  ["sword", { quantity: 3, weight: 15 }],
  ["shield", { quantity: 1, weight: 25 }],
  ["potion", { quantity: 10, weight: 2 }],
]);

inventory.set("bow", { quantity: 2, weight: 8 });
inventory.delete("shield");

const totalWeight = [...inventory.entries()].reduce((acc, [item, { quantity, weight }]) => {
  return acc + quantity * weight;
}, 0);

const heaviestItem = [...inventory.entries()].reduce((max, [item, data]) =>
  data.weight > max.weight ? { name: item, ...data } : max,
  { name: "", weight: 0 }
);

console.log(inventory.size, totalWeight, heaviestItem.name);

const ops = {
  add: (a, b) => a + b,
  subtract: (a, b) => a - b,
  multiply: (a, b) => a * b,
  divide: (a, b) => b !== 0 ? a / b : NaN,
};

const pipeline = (...fns) => (value) => fns.reduce((acc, fn) => fn(acc), value);

const double  = (x) => ops.multiply(x, 2);
const addTen  = (x) => ops.add(x, 10);
const halve   = (x) => ops.divide(x, 2);
const subtractThree = (x) => ops.subtract(x, 3);

const transform = pipeline(double, addTen, halve, subtractThree);

const results = [5, 0, -4].map(transform);
console.log(results);

const values = [0.1 + 0.2, NaN, Infinity, -0, 42.6789];

const results = values.map((v, i) => {
  if (i === 0) return Number.isInteger(v) + " | " + v.toFixed(2);
  if (i === 1) return Number.isFinite(v) + " | " + Number.isNaN(v);
  if (i === 2) return Number.isFinite(v) + " | " + Number.MAX_SAFE_INTEGER;
  if (i === 3) return Object.is(v, -0) + " | " + (v === 0);
  if (i === 4) return v.toFixed(2) + " | " + v.toPrecision(4);
});

results.forEach(r => console.log(r));

const items = [
  { name: "banana", price: 1.5, qty: 10 },
  { name: "apple",  price: 1.5, qty: 5  },
  { name: "cherry", price: 3.0, qty: 8  },
  { name: "date",   price: 2.0, qty: 8  },
];

const sorted = [...items].sort((a, b) => {
  if (a.price !== b.price) return a.price - b.price;
  if (a.qty   !== b.qty)   return b.qty   - a.qty;
  return a.name.localeCompare(b.name);
});

console.log(sorted.map(i => `${i.name}:${i.qty}`).join(", "));

class DatabaseError extends Error {
  constructor(message, code) {
    super(message);
    this.name = "DatabaseError";
    this.code = code;
  }
}

class ConnectionError extends DatabaseError {
  constructor(host) {
    super(`Failed to connect to ${host}`, 503);
    this.name = "ConnectionError";
    this.host = host;
  }
}

const err = new ConnectionError("db.server.io");

console.log([
  err instanceof ConnectionError,
  err instanceof DatabaseError,
  err instanceof Error,
  err.name,
  err.code,
  err.message,
].join(" | "));

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(double, addTen, square, negate);

const memoize = (fn) => {
  const cache = new Map();
  return (x) => {
    if (!cache.has(x)) cache.set(x, fn(x));
    return cache.get(x);
  };
};

const memoTransform1 = memoize(transform1);

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