Online store with direct and instalment payments

class Catalog {
  constructor() {
    this.products = new Map();
  }
  check(item) {
    if (!item.sku || !Number.isInteger(item.price) || item.price <= 0 || !Number.isInteger(item.stock) || item.stock < 0) {
      throw new Error("invalid product " + item.sku);
    }
  }
  add(item) {
    this.check(item);
    const existing = this.products.get(item.sku);
    if (existing) existing.stock += item.stock;
    else this.products.set(item.sku, { ...item });
  }
  importFrom(source) {
    const items = source.load();
    items.forEach((item) => this.check(item));
    items.forEach((item) => this.add(item));
  }
  get(sku) {
    return this.products.get(sku);
  }
  browse() {
    return [...this.products.values()].filter((p) => p.stock > 0).map((p) => p.sku);
  }
}

class ListSource {
  constructor(items) {
    this.items = items;
  }
  load() {
    return this.items.map((item) => ({ ...item }));
  }
}

class CsvSource {
  constructor(text) {
    this.text = text;
  }
  load() {
    return this.text
      .split("\n")
      .filter((line) => line.length > 0)
      .map((line) => {
        const [sku, name, price, stock] = line.split(",");
        return { sku, name, price: Number(price), stock: Number(stock) };
      });
  }
}

class FeedSource {
  constructor(payload) {
    this.payload = payload;
  }
  load() {
    return this.payload.items.map((i) => ({
      sku: i.id,
      name: i.title,
      price: Math.round(i.priceRupees * 100),
      stock: i.qty,
    }));
  }
}

class FakeGateway {
  constructor() {
    this.charges = [];
    this.failures = 0;
  }
  failNext(count) {
    this.failures = count;
  }
  charge(userId, amount) {
    if (this.failures > 0) {
      this.failures -= 1;
      return { ok: false };
    }
    this.charges.push({ userId, amount });
    return { ok: true, ref: "ch" + this.charges.length };
  }
}

class PastPaymentsPolicy {
  constructor(base, percentOfPaid, cap) {
    this.base = base;
    this.percentOfPaid = percentOfPaid;
    this.cap = cap;
  }
  limitFor(account) {
    return Math.min(this.cap, this.base + Math.floor((account.paidTotal * this.percentOfPaid) / 100));
  }
}

function splitEvenly(total, parts) {
  const base = Math.floor(total / parts);
  const amounts = Array.from({ length: parts }, () => base);
  amounts[0] += total - base * parts;
  return amounts;
}

class DirectPayment {
  constructor(gateway) {
    this.name = "direct";
    this.gateway = gateway;
  }
  pay(account, order) {
    if (!this.gateway.charge(account.id, order.total).ok) return { ok: false, reason: "declined" };
    account.paidTotal += order.total;
    order.paid = order.total;
    return { ok: true, status: "PAID" };
  }
  payNext() {
    return { ok: false, reason: "nothing due" };
  }
}

class InstalmentPayment {
  constructor(gateway, policy, count) {
    this.name = "instalment";
    this.gateway = gateway;
    this.policy = policy;
    this.count = count;
  }
  pay(account, order) {
    const available = this.policy.limitFor(account) - account.outstanding;
    if (order.total > available) return { ok: false, reason: "over credit limit" };
    const amounts = splitEvenly(order.total, this.count).filter((amount) => amount > 0);
    if (!this.gateway.charge(account.id, amounts[0]).ok) return { ok: false, reason: "declined" };
    account.paidTotal += amounts[0];
    account.outstanding += order.total - amounts[0];
    order.paid = amounts[0];
    order.schedule = amounts.slice(1);
    return { ok: true, status: order.schedule.length === 0 ? "PAID" : "INSTALMENTS" };
  }
  payNext(account, order) {
    if (order.schedule.length === 0) return { ok: false, reason: "nothing due" };
    const amount = order.schedule[0];
    if (!this.gateway.charge(account.id, amount).ok) return { ok: false, reason: "declined" };
    order.schedule.shift();
    order.paid += amount;
    account.paidTotal += amount;
    account.outstanding -= amount;
    if (order.schedule.length === 0) order.status = "PAID";
    return { ok: true, status: order.status };
  }
}

class Store {
  constructor(catalog, methods) {
    this.catalog = catalog;
    this.methods = new Map(methods.map((m) => [m.name, m]));
    this.accounts = new Map();
    this.orders = [];
  }
  registerMethod(method) {
    this.methods.set(method.name, method);
  }
  account(id) {
    if (!this.accounts.has(id)) this.accounts.set(id, { id, paidTotal: 0, outstanding: 0 });
    return this.accounts.get(id);
  }
  checkout(userId, lines, methodName) {
    const method = this.methods.get(methodName);
    if (!method) throw new Error("unknown payment method " + methodName);
    const wanted = new Map();
    for (const line of lines) {
      if (!Number.isInteger(line.qty) || line.qty <= 0) return { ok: false, reason: "unavailable " + line.sku };
      wanted.set(line.sku, (wanted.get(line.sku) || 0) + line.qty);
    }
    if (wanted.size === 0) return { ok: false, reason: "empty cart" };
    let total = 0;
    for (const [sku, qty] of wanted) {
      const product = this.catalog.get(sku);
      if (!product || product.stock < qty) {
        return { ok: false, reason: "unavailable " + sku };
      }
      total += product.price * qty;
    }
    const order = {
      id: this.orders.length + 1,
      userId,
      method: methodName,
      total,
      status: "NEW",
      paid: 0,
      schedule: [],
    };
    this.orders.push(order);
    const result = method.pay(this.account(userId), order);
    if (!result.ok) {
      order.status = "FAILED";
      return { ok: false, reason: result.reason, orderId: order.id };
    }
    for (const [sku, qty] of wanted) this.catalog.get(sku).stock -= qty;
    order.status = result.status;
    return { ok: true, orderId: order.id, status: order.status };
  }
  payNext(orderId) {
    const order = this.orders[orderId - 1];
    if (!order) return { ok: false, reason: "unknown order" };
    return this.methods.get(order.method).payNext(this.account(order.userId), order);
  }
}