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));

function processData(value) {
  let result = "start";

  try {
    result += " -> try";
    if (value === null) throw new TypeError("Null value");
    if (value < 0) throw new RangeError("Negative value");
    result += " -> success";
    return result;
  } catch (e) {
    result += ` -> catch(${e.constructor.name})`;
    return result;
  } finally {
    result += " -> finally";
    console.log(result);
  }
}

console.log(processData(null));

function createCounter() {
  let count = 0;

  return {
    increment() { count++; },
    decrement() { count--; },
    getCount() { return count; },
    reset: () => { count = 0; }
  };
}

const counter = createCounter();
counter.increment();
counter.increment();
counter.increment();
counter.decrement();

const { getCount, reset } = counter;

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

class Pipeline {
  #value;
  #log = [];

  constructor(value) {
    this.#value = value;
  }

  map(fn) {
    this.#value = fn(this.#value);
    this.#log.push(`map:${this.#value}`);
    return this;
  }

  filter(fn) {
    if (Array.isArray(this.#value)) {
      this.#value = this.#value.filter(fn);
      this.#log.push(`filter:${this.#value}`);
    }
    return this;
  }

  reduce(fn, init) {
    if (Array.isArray(this.#value)) {
      this.#value = this.#value.reduce(fn, init);
      this.#log.push(`reduce:${this.#value}`);
    }
    return this;
  }

  result() {
    console.log(this.#log.join(' | '));
    return this.#value;
  }
}

new Pipeline([1, 2, 3, 4, 5, 6])
  .filter(n => n % 2 === 0)
  .map(arr => arr.map(n => n ** 2))
  .reduce((acc, n) => acc + n, 0)
  .result();

const name = "Taylor";
const age = 28;
const role = "engineer";

const user = {
  name,
  age,
  role,
  greet() {
    return `Hi, I'm ${this.name}, age ${this.age}`;
  },
  get info() {
    return `${this.role.toUpperCase()} @ ${this.age}`;
  }
};

const { name: userName, info, greet } = user;

console.log(userName);
console.log(info);
console.log(greet.call({ name: "Jordan", age: 35 }));

const handler = {
  get(target, prop, receiver) {
    if (prop in target) {
      const value = Reflect.get(target, prop, receiver);
      return typeof value === "number" ? value * 2 : value;
    }
    return `Property "${prop}" not found`;
  },
  set(target, prop, value) {
    if (typeof value !== "number") {
      throw new TypeError("Only numbers allowed");
    }
    Reflect.set(target, prop, value ** 2);
    return true;
  },
  has(target, prop) {
    return prop.startsWith("_") ? false : prop in target;
  },
};

const store = new Proxy({ _secret: 99, score: 5 }, handler);

store.level = 3;

console.log(store.score);
console.log(store.level);
console.log("_secret" in store);
console.log("score" in store);
console.log(store._secret);

class Range {
  constructor(start, end, step = 1) {
    this.start = start;
    this.end = end;
    this.step = step;
  }

  [Symbol.iterator]() {
    let current = this.start;
    const { end, step } = this;
    return {
      next() {
        if (current <= end) {
          const value = current;
          current += step;
          return { value, done: false };
        }
        return { value: undefined, done: true };
      }
    };
  }
}

const range = new Range(1, 10, 3);
const result = [...range].map(n => n ** 2);
console.log(result);