E-Commerce Logic 🛒

<?php
// A shopping Cart. Golden rule: NEVER store money as a float.
// $29.99 is stored as the integer 2999 (cents). You divide by 100
// ONLY when you print it — never while calculating.

class Cart {
    // Each line is keyed by product id so duplicates merge automatically.
    // value = ['name' => string, 'price' => int(cents), 'qty' => int]
    private array $lines = [];

    // Add a product, or bump the quantity if it's already in the cart.
    public function add(int $id, string $name, int $priceCents, int $qty = 1): void {
        if (isset($this->lines[$id])) {
            $this->lines[$id]['qty'] += $qty;          // merge: just add to qty
        } else {
            $this->lines[$id] = ['name' => $name, 'price' => $priceCents, 'qty' => $qty];
        }
    }

    // Change a line to an exact quantity. qty <= 0 removes the line entirely.
    public function update(int $id, int $qty): void {
        if (!isset($this->lines[$id])) return;          // nothing to update
        if ($qty <= 0) { unset($this->lines[$id]); return; }
        $this->lines[$id]['qty'] = $qty;
    }

    public function remove(int $id): void {
        unset($this->lines[$id]);                       // drop the line if present
    }

    // Subtotal = sum of (price x qty) for every line, all in cents.
    public function subtotal(): int {
        $sum = 0;
        foreach ($this->lines as $line) {
            $sum += $line['price'] * $line['qty'];
        }
        return $sum;                                    // an int — still cents
    }

    public function lines(): array { return $this->lines; }
}

$cart = new Cart();
$cart->add(1, "Wireless Mouse", 2999);        // one mouse  @ $29.99
$cart->add(2, "Mechanical Keyboard", 8999);   // one board  @ $89.99
$cart->add(3, "USB-C Hub", 3499, 2);          // two hubs   @ $34.99
$cart->add(1, "Wireless Mouse", 2999);        // same id -> merges to qty 2
$cart->update(2, 3);                          // change keyboards to qty 3
$cart->remove(99);                            // id not in cart -> no-op

foreach ($cart->lines() as $id => $line) {
    // money_format: cents -> "$xx.xx". sprintf keeps columns lined up.
    printf("  #%d  %-20s x%d  $%.2f\n",
        $id, $line['name'], $line['qty'], $line['price'] * $line['qty'] / 100);
}
printf("  Subtotal: $%.2f\n", $cart->subtotal() / 100);   // 17996 -> $179.96

  #1  Wireless Mouse       x2  $59.98
  #2  Mechanical Keyboard  x3  $269.97
  #3  USB-C Hub            x2  $69.98
  Subtotal: $399.93

<?php
// Discounts, coupons and tax. The ORDER is the whole ballgame:
//   1. subtotal      (sum of the lines)
//   2. discount      (coupon comes off the subtotal)
//   3. tax           (charged on the DISCOUNTED amount, in most regions)
//   4. total         (discounted subtotal + tax)
// Get the order wrong and every receipt is a penny or two off forever.

// A coupon: percent off, OR a flat amount off (in cents) — never both.
function discountCents(int $subtotal, ?array $coupon): int {
    if ($coupon === null) return 0;
    if ($coupon['type'] === 'percent') {
        // round ONCE, here — not on each line — to avoid drift.
        return (int) round($subtotal * $coupon['value'] / 100);
    }
    // 'flat' coupon: never discount more than the subtotal.
    return min($coupon['value'], $subtotal);
}

// Tax is a percentage of whatever is left AFTER the discount.
function taxCents(int $taxableBase, float $taxPercent): int {
    return (int) round($taxableBase * $taxPercent / 100);
}

$subtotal = 39993;                                  // $399.93 from the cart
$coupon   = ['type' => 'percent', 'value' => 15];   // SAVE15 = 15% off

$discount = discountCents($subtotal, $coupon);      // round(39993*0.15) = 5999
$taxable  = $subtotal - $discount;                  // 33994  (tax base)
$tax      = taxCents($taxable, 8.0);                // round(33994*0.08) = 2720
$total    = $taxable + $tax;                        // 36714  -> $367.14

printf("  Subtotal:  $%7.2f\n", $subtotal / 100);
printf("  Discount: -$%7.2f\n", $discount / 100);
printf("  Taxable:   $%7.2f\n", $taxable  / 100);
printf("  Tax (8%%):  $%7.2f\n", $tax      / 100);   // %% prints one literal %
printf("  --------------------\n");
printf("  TOTAL:     $%7.2f\n", $total    / 100);

  Subtotal:  $ 399.93
  Discount: -$  59.99
  Taxable:   $ 339.94
  Tax (8%):  $  27.20
  --------------------
  TOTAL:     $ 367.14

<?php
// Checkout is the dangerous part: money changes hands and stock moves.
// It must be ALL-OR-NOTHING. A transaction guarantees that: every write
// commits together, or — if anything fails — they all roll back as if
// nothing happened. No half-made orders, no stock vanishing into thin air.

function checkout(PDO $db, int $userId, array $cart, int $totalCents): int {
    $db->beginTransaction();                 // open the transaction
    try {
        // 1) Create the order row. Status starts as 'pending'.
        $stmt = $db->prepare(
            "INSERT INTO orders (user_id, total_cents, status)
             VALUES (?, ?, 'pending')"
        );
        $stmt->execute([$userId, $totalCents]);
        $orderId = (int) $db->lastInsertId();

        // 2) For each line: decrement stock SAFELY, then record the line.
        $dec = $db->prepare(
            // The "AND stock >= ?" is the race-condition guard. If two
            // shoppers race for the last unit, only ONE update matches.
            "UPDATE products SET stock = stock - ?
             WHERE id = ? AND stock >= ?"
        );
        $line = $db->prepare(
            "INSERT INTO order_items (order_id, product_id, qty, price_cents)
             VALUES (?, ?, ?, ?)"
        );

        foreach ($cart as $id => $item) {
            $dec->execute([$item['qty'], $id, $item['qty']]);
            if ($dec->rowCount() === 0) {
                // 0 rows changed = not enough stock. Bail out.
                throw new RuntimeException("Out of stock: {\$item['name']}");
            }
            $line->execute([$orderId, $id, $item['qty'], $item['price']]);
        }

        // 3) Everything worked — mark paid and COMMIT all of it at once.
        $db->prepare("UPDATE orders SET status = 'paid' WHERE id = ?")
           ->execute([$orderId]);
        $db->commit();                       // make every change permanent
        return $orderId;

    } catch (Throwable $e) {
        $db->rollBack();                     // undo EVERYTHING — clean slate
        throw $e;                            // let the caller show the error
    }
}

// (Sketch of the call — needs a real $db connection to run.)
// $orderId = checkout($db, 42, $cart, 36714);
echo "checkout() wraps the order, stock and line items in one transaction.\n";
echo "If any product is out of stock, rollBack() undoes the whole order.\n";

checkout() wraps the order, stock and line items in one transaction.
If any product is out of stock, rollBack() undoes the whole order.

<?php
// 🎯 YOUR TURN — finish the checkout maths. Fill each ___ , then run it.
// Remember the order: subtotal -> discount -> tax-on-discounted -> total.
// Everything is in cents (integers). Divide by 100 only to print.

$subtotal = 12000;                 // $120.00 worth of goods
$couponPercent = 25;               // a 25%-off coupon
$taxPercent = 10.0;                // 10% sales tax

// 1) Discount = 25% of the subtotal, rounded to a whole cent.
$discount = (int) round($subtotal * ___ / 100);   // 👉 replace ___ with $couponPercent

// 2) Tax base is the subtotal with the discount taken off.
$taxable = $subtotal - ___;                        // 👉 replace ___ with $discount

// 3) Tax = 10% of the TAXABLE amount (not the subtotal!).
$tax = (int) round(___ * $taxPercent / 100);       // 👉 replace ___ with $taxable

// 4) Total = taxable + tax.
$total = $taxable + $tax;

printf("Total: $%.2f\n", $total / 100);

// ✅ Expected output:
//    Total: $99.00
//    (discount 3000, taxable 9000, tax 900, total 9900 cents)

Total: $99.00

<?php
// 🎯 YOUR TURN — make stock decrement SAFE against overselling.
// In-memory products. Decrement only if there's enough on hand.

$products = [
    1 => ["name" => "Wireless Mouse", "stock" => 2],
    7 => ["name" => "Rare Vinyl",     "stock" => 1],
];

function buy(array &$products, int $id, int $qty): void {
    $have = $products[$id]['stock'];

    // 1) Only sell when there is ENOUGH stock to cover the order.
    if ($have ___ $qty) {                           // 👉 replace ___ with  >=
        $products[$id]['stock'] -= $qty;            // take it out of stock
        echo "OK: sold {\$qty} x {\$products[$id]['name']}\n";
    } else {
        // 2) Not enough — refuse the sale, leave stock untouched.
        echo "FAIL: only {\$have} left of {\$products[$id]['name']}\n";
    }
}

buy($products, 1, 2);     // 2 in stock, want 2 -> OK, stock now 0
buy($products, 7, 3);     // 1 in stock, want 3 -> FAIL, stock stays 1
buy($products, 7, 1);     // 1 in stock, want 1 -> OK, stock now 0

// ✅ Expected output:
//    OK: sold 2 x Wireless Mouse
//    FAIL: only 1 left of Rare Vinyl
//    OK: sold 1 x Rare Vinyl

OK: sold 2 x Wireless Mouse
FAIL: only 1 left of Rare Vinyl
OK: sold 1 x Rare Vinyl