"""Following one $20 payment: a toy (NOT Stripe's code).

Three mechanisms described in Stripe's public docs/blog, re-implemented in
miniature with the Python standard library only. Deterministic: no randomness,
no clock, no network.

  1. Idempotency keys: a retry after a lost response replays the saved result
     instead of charging twice (docs.stripe.com/api/idempotent_requests).
  2. Double-entry ledger: every transaction must sum to zero; an unbalanced one
     is rejected, so the whole book always sums to zero
     (stripe.com/blog/ledger-stripe-system-for-tracking-and-validating-money-movement).
  3. Fleet-usage load shedder: a slice of capacity is reserved for critical
     requests, so "list charges" gets 503 before "create charge"
     (stripe.com/blog/rate-limiters).
"""

# ---------------------------------------------------------------- 1. ledger
class UnbalancedError(Exception):
    pass


class Ledger:
    def __init__(self):
        self.log = []          # immutable append-only list of transactions
        self.balances = {}     # derived view: account -> cents

    def post(self, event, entries):
        total = sum(amount for _, amount in entries)
        if total != 0:
            raise UnbalancedError(f"{event}: entries sum to {total}, not 0")
        self.log.append((event, tuple(entries)))
        for account, amount in entries:
            self.balances[account] = self.balances.get(account, 0) + amount

    def total(self):
        return sum(self.balances.values())


# ----------------------------------------------------------- 2. charges API
class ParamMismatch(Exception):
    pass


class PaymentsAPI:
    def __init__(self, ledger):
        self.ledger = ledger
        self.saved = {}        # idempotency key -> (params, response)
        self.next_id = 1

    def create_charge(self, amount, idempotency_key=None):
        params = {"amount": amount}
        if idempotency_key is not None and idempotency_key in self.saved:
            old_params, response = self.saved[idempotency_key]
            if old_params != params:
                raise ParamMismatch("same key, different parameters")
            return dict(response, idempotent_replayed=True)
        charge_id = f"ch_{self.next_id}"
        self.next_id += 1
        self.ledger.post(f"{charge_id}.creation", [
            ("charge_unsubmitted", -amount),
            ("charge_undisbursed", +amount),
        ])
        response = {"id": charge_id, "amount": amount}
        if idempotency_key is not None:
            self.saved[idempotency_key] = (params, response)
        return dict(response, idempotent_replayed=False)


def client_pays(api, amount, key):
    """Network drops the first response; the client retries once."""
    api.create_charge(amount, idempotency_key=key)        # executed, reply lost
    return api.create_charge(amount, idempotency_key=key)  # retry


def demo_idempotency():
    print("== 1. retry after a lost response ($20 = 2000 cents) ==")
    for label, key in [("no key  ", None), ("with key", "order-42")]:
        ledger = Ledger()
        api = PaymentsAPI(ledger)
        reply = client_pays(api, 2000, key)
        charges = len(ledger.log)
        print(f"{label}: charges created={charges} "
              f"customer charged={charges * 2000} cents "
              f"replayed={reply['idempotent_replayed']}")
    try:
        api.create_charge(3000, idempotency_key="order-42")
    except ParamMismatch as e:
        print(f"reuse key with 3000 cents -> rejected: {e}")
    return ledger


def demo_ledger(ledger):
    print("== 2. double-entry ledger ==")
    ledger.post("ch_1.release", [
        ("charge_undisbursed", -2000),
        ("business_balance", +2000),
    ])
    print("balances:", dict(sorted(ledger.balances.items())))
    print("sum of all accounts:", ledger.total())
    try:
        ledger.post("buggy.release", [("charge_undisbursed", -2000),
                                      ("business_balance", +1990)])
    except UnbalancedError as e:
        print("rejected:", e)
    print("sum after rejected post:", ledger.total(),
          "| transactions in log:", len(ledger.log))


# ------------------------------------------------------- 3. load shedding
class FleetShedder:
    """capacity slots; `reserve` fraction kept for critical requests only."""

    def __init__(self, capacity, reserve):
        self.capacity = capacity
        self.noncritical_cap = int(capacity * (1 - reserve))
        self.in_flight = {"critical": 0, "noncritical": 0}

    def admit(self, kind):
        used = sum(self.in_flight.values())
        if used >= self.capacity:
            return 503
        if kind == "noncritical" and self.in_flight["noncritical"] >= self.noncritical_cap:
            return 503
        self.in_flight[kind] += 1
        return 200


def demo_shedding():
    print("== 3. load shedding: 9 list calls arrive, then 4 create calls (capacity 10) ==")
    # a surge: 9 list-charges calls arrive first, then 4 create-charge calls
    burst = [("GET /v1/charges", "noncritical")] * 9 + \
            [("POST /v1/charges", "critical")] * 4
    for label, reserve in [("no reserve ", 0.0), ("20% reserve", 0.2)]:
        shed = FleetShedder(capacity=10, reserve=reserve)
        results = {}
        for path, kind in burst:
            results.setdefault(path, []).append(shed.admit(kind))
        for path, codes in results.items():
            print(f"{label} {path:17s} ok={codes.count(200)} "
                  f"503={codes.count(503)} {codes}")


if __name__ == "__main__":
    ledger = demo_idempotency()
    demo_ledger(ledger)
    demo_shedding()
