06 · The basket that charges twice

public struct BasketItem: Identifiable, Hashable, Sendable {
    public let id: String
    public let name: String
    public let unitPrice: Decimal       // money is never a Double
    public var quantity: Int

    public init(id: String, name: String, unitPrice: Decimal, quantity: Int) {
        self.id = id
        self.name = name
        self.unitPrice = unitPrice
        self.quantity = quantity
    }
}

public protocol CheckoutServing: Sendable {
    func fetchBasket() async throws -> [BasketItem]
    func promotion(for code: String) async throws -> Promotion
    func charge(amount: Decimal, idempotencyKey: String) async throws -> Receipt
}

// CheckoutService: CheckoutServing — prices as Decimal(string: "10.20")!, …;
// charge(amount: Decimal, idempotencyKey: String) always records the key.

import CheckoutKit
import Foundation
import Observation

@Observable
final class BasketViewModel {   // main actor: the target's default isolation
    enum LoadState: Equatable {
        case loading
        case loaded
        case failed(String)
    }

    enum PaymentState: Equatable {
        case idle
        case paying
        case paid(Receipt)
        case failed(String)
    }

    static let freeShippingThreshold: Decimal = 50
    static let shippingFee = Decimal(string: "4.95")!
    static let quantityRange = 1...10

    private(set) var loadState: LoadState = .loading
    private(set) var items: [BasketItem] = []
    private(set) var payment: PaymentState = .idle

    init(service: any CheckoutServing) {
        self.service = service
    }

    // Derived from `items` on every read, so nothing can go stale.
    var subtotal: Decimal {
        items.reduce(0) { $0 + $1.unitPrice * Decimal($1.quantity) }
    }

    var shipping: Decimal {
        items.isEmpty || subtotal >= Self.freeShippingThreshold ? 0 : Self.shippingFee
    }

    var total: Decimal { subtotal + shipping }

    var amountToFreeShipping: Decimal? {
        guard !items.isEmpty, subtotal < Self.freeShippingThreshold else { return nil }
        return Self.freeShippingThreshold - subtotal
    }

    var canPay: Bool { !items.isEmpty && payment != .paying }

    var receipt: Receipt? {
        if case .paid(let receipt) = payment { receipt } else { nil }
    }

    func load() async {
        loadState = .loading
        do {
            items = try await service.fetchBasket()
            loadState = .loaded
        } catch {
            loadState = .failed(error.localizedDescription)
        }
    }

    func canIncrement(_ item: BasketItem) -> Bool { item.quantity < Self.quantityRange.upperBound }
    func canDecrement(_ item: BasketItem) -> Bool { item.quantity > Self.quantityRange.lowerBound }

    func increment(_ id: BasketItem.ID) {
        changeQuantity(of: id, by: 1)
    }

    func decrement(_ id: BasketItem.ID) {
        changeQuantity(of: id, by: -1)
    }

    func remove(at offsets: IndexSet) {
        guard payment != .paying else { return }
        items.remove(atOffsets: offsets)
        basketChanged()
    }

    func pay() async {
        guard canPay else { return }                // a second tap while paying does nothing
        payment = .paying
        do {
            let receipt = try await service.charge(amount: total, idempotencyKey: attemptKey.uuidString)
            payment = .paid(receipt)
            items = []                              // the order is placed
            attemptKey = UUID()
        } catch {
            payment = .failed(error.localizedDescription)   // keep the key: a retry is the same attempt
        }
    }

    func dismissReceipt() {
        payment = .idle
    }

    @ObservationIgnored private let service: any CheckoutServing
    @ObservationIgnored private var attemptKey = UUID()   // one key per basket we try to pay for

    private func changeQuantity(of id: BasketItem.ID, by change: Int) {
        guard payment != .paying, let index = items.firstIndex(where: { $0.id == id }) else { return }
        let quantity = items[index].quantity + change
        guard Self.quantityRange.contains(quantity) else { return }
        items[index].quantity = quantity
        basketChanged()
    }

    /// A different basket is a different payment: it gets a new idempotency key.
    private func basketChanged() {
        attemptKey = UUID()
        if case .failed = payment { payment = .idle }
    }
}

import CheckoutKit
import SwiftUI

struct BasketView: View {
    @State private var viewModel: BasketViewModel

    init(service: any CheckoutServing = CheckoutService()) {
        _viewModel = State(initialValue: BasketViewModel(service: service))
    }

    var body: some View {
        NavigationStack {
            content
                .navigationTitle("Basket")
                .task { await viewModel.load() }
                .sheet(item: Binding(get: { viewModel.receipt },
                                     set: { _ in viewModel.dismissReceipt() })) { receipt in
                    ContentUnavailableView("Order \(receipt.id) placed",
                                           systemImage: "checkmark.circle",
                                           description: Text("We charged \(receipt.amountCharged, format: .currency(code: "EUR")).")
                    )
                }
        }
    }

    @ViewBuilder
    private var content: some View {
        switch viewModel.loadState {
        case .loading:
            ProgressView()
        case .failed(let message):
            ContentUnavailableView {
                Label("Couldn't load your basket", systemImage: "exclamationmark.triangle")
            } description: {
                Text(message)
            } actions: {
                Button("Try again") { Task { await viewModel.load() } }
            }
        case .loaded where viewModel.items.isEmpty:
            ContentUnavailableView("Your basket is empty", systemImage: "bag")
        case .loaded:
            basket
        }
    }

    private var basket: some View {
        List {
            Section {
                ForEach(viewModel.items) { item in
                    BasketRow(item: item,
                              onIncrement: viewModel.canIncrement(item) ? { viewModel.increment(item.id) } : nil,
                              onDecrement: viewModel.canDecrement(item) ? { viewModel.decrement(item.id) } : nil)
                }
                .onDelete { offsets in
                    viewModel.remove(at: offsets)
                }
            }

            Section {
                LabeledContent("Subtotal", value: viewModel.subtotal, format: .currency(code: "EUR"))
                LabeledContent("Shipping", value: viewModel.shipping, format: .currency(code: "EUR"))
                LabeledContent("Total", value: viewModel.total, format: .currency(code: "EUR"))
                    .fontWeight(.semibold)
            } footer: {
                if let missing = viewModel.amountToFreeShipping {
                    Text("Add \(missing, format: .currency(code: "EUR")) more for free shipping.")
                }
            }

            if case .failed(let message) = viewModel.payment {
                Text(message)
                    .foregroundStyle(.red)
            }
        }
        .disabled(viewModel.payment == .paying)
        .safeAreaInset(edge: .bottom) {
            Button {
                Task { await viewModel.pay() }
            } label: {
                if viewModel.payment == .paying {
                    ProgressView()
                        .frame(maxWidth: .infinity)
                } else {
                    Text("Pay \(viewModel.total, format: .currency(code: "EUR"))")
                        .frame(maxWidth: .infinity)
                }
            }
            .buttonStyle(.borderedProminent)
            .controlSize(.large)
            .disabled(!viewModel.canPay)
            .padding()
        }
    }
}

struct BasketRow: View {
    let item: BasketItem
    let onIncrement: (() -> Void)?
    let onDecrement: (() -> Void)?

    var body: some View {
        HStack {
            VStack(alignment: .leading) {
                Text(item.name)
                Text(item.unitPrice, format: .currency(code: "EUR"))
                    .font(.caption)
                    .foregroundStyle(.secondary)
            }
            Spacer()
            Stepper("\(item.quantity)", onIncrement: onIncrement, onDecrement: onDecrement)
                .fixedSize()
                .accessibilityValue("\(item.quantity)")
        }
    }
}

private(set) var promotion: Promotion?
private(set) var promoError: String?
private(set) var isApplyingPromo = false
var promoCode = ""

/// Comes off the items only, never off shipping, and never more than the items cost.
var discount: Decimal {
    guard let promotion, subtotal >= promotion.minimumSubtotal else { return 0 }
    switch promotion.kind {
    case .percentOff(let percent):
        return (subtotal * Decimal(percent) / 100).roundedToCents
    case .amountOff(let amount):
        return min(amount, subtotal)
    }
}

/// Why an applied code isn't taking anything off right now.
var promoNotice: String? {
    guard let promotion, subtotal < promotion.minimumSubtotal else { return nil }
    let missing = (promotion.minimumSubtotal - subtotal).formatted(.currency(code: "EUR"))
    return "Add \(missing) more to use \(promotion.code)."
}

var total: Decimal { subtotal - discount + shipping }      // shipping still uses `subtotal`

/// One code per order: a new code replaces the old one.
func applyPromo() async {
    let code = promoCode.trimmingCharacters(in: .whitespaces).uppercased()
    guard !code.isEmpty, !isApplyingPromo else { return }
    isApplyingPromo = true
    defer { isApplyingPromo = false }
    do {
        promotion = try await service.promotion(for: code)
        promoError = nil
        promoCode = ""
        basketChanged()
    } catch {
        promoError = error.localizedDescription
    }
}

func removePromo() {
    promotion = nil
    basketChanged()
}

extension Decimal {
    /// Rounded to cents, halves away from zero: 4.495 becomes 4.50.
    var roundedToCents: Decimal {
        var value = self
        var result = Decimal()
        NSDecimalRound(&result, &value, 2, .plain)
        return result
    }
}

Section {
    if let promotion = viewModel.promotion {
        LabeledContent(promotion.code) {
            Button("Remove", role: .destructive) { viewModel.removePromo() }
        }
    } else {
        HStack {
            TextField("Promo code", text: $viewModel.promoCode)
                .textInputAutocapitalization(.characters)
                .autocorrectionDisabled()
                .onSubmit { Task { await viewModel.applyPromo() } }
            Button("Apply") { Task { await viewModel.applyPromo() } }
                .disabled(viewModel.promoCode.isEmpty || viewModel.isApplyingPromo)
        }
    }
} footer: {
    if let error = viewModel.promoError {
        Text(error).foregroundStyle(.red)
    } else if let notice = viewModel.promoNotice {
        Text(notice)
    }
}

if viewModel.discount > 0 {
    LabeledContent("Discount", value: -viewModel.discount, format: .currency(code: "EUR"))
}

import CheckoutKit
import Foundation
import Synchronization
import Testing
@testable import Checkout

/// Records every charge's idempotency key, and can decline the first `declines` charges.
nonisolated final class FakeCheckout: CheckoutServing {
    let basket: [BasketItem]
    let declinesLeft: Mutex<Int>
    let chargedKeys = Mutex<[String]>([])

    init(basket: [BasketItem], declines: Int = 0) {
        self.basket = basket
        self.declinesLeft = Mutex(declines)
    }

    func fetchBasket() async throws -> [BasketItem] { basket }

    func promotion(for code: String) async throws -> Promotion {
        switch code {
        case "RUN10": Promotion(code: code, kind: .percentOff(10), minimumSubtotal: 0)
        case "GIFT25": Promotion(code: code, kind: .amountOff(25), minimumSubtotal: 0)
        default: throw CheckoutError.unknownPromotion
        }
    }

    func charge(amount: Decimal, idempotencyKey: String) async throws -> Receipt {
        chargedKeys.withLock { $0.append(idempotencyKey) }
        try await Task.sleep(for: .milliseconds(50))
        let declined = declinesLeft.withLock { left in
            defer { left = max(0, left - 1) }
            return left > 0
        }
        if declined { throw CheckoutError.paymentDeclined }
        return Receipt(id: "ORD-1", amountCharged: amount)
    }
}

private func item(_ id: String, _ price: String, quantity: Int = 1) -> BasketItem {
    BasketItem(id: id, name: id, unitPrice: Decimal(string: price)!, quantity: quantity)
}

struct BasketViewModelTests {
    let fiftyEuros = [item("bottle", "10.20"), item("cap", "21.90"), item("socks", "8.95", quantity: 2)]

    @Test func fiftyEurosIsExactlyFiftyAndShipsFree() async {
        let viewModel = BasketViewModel(service: FakeCheckout(basket: fiftyEuros))
        await viewModel.load()
        #expect(viewModel.subtotal == 50)
        #expect(viewModel.shipping == 0)
        #expect(viewModel.total == 50)
    }

    @Test func quantityStaysBetweenOneAndTen() async {
        let viewModel = BasketViewModel(service: FakeCheckout(basket: [item("cap", "21.90")]))
        await viewModel.load()
        viewModel.decrement("cap")
        #expect(viewModel.items.first?.quantity == 1)
        for _ in 0..<12 { viewModel.increment("cap") }
        #expect(viewModel.items.first?.quantity == 10)
    }

    @Test func tappingPayTwiceChargesOnce() async {
        let service = FakeCheckout(basket: fiftyEuros)
        let viewModel = BasketViewModel(service: service)
        await viewModel.load()
        async let first: Void = viewModel.pay()
        async let second: Void = viewModel.pay()
        _ = await (first, second)
        #expect(service.chargedKeys.withLock { $0.count } == 1)
    }

    @Test func aRetryAfterADeclineReusesTheIdempotencyKey() async {
        let service = FakeCheckout(basket: fiftyEuros, declines: 1)
        let viewModel = BasketViewModel(service: service)
        await viewModel.load()
        await viewModel.pay()
        #expect(viewModel.payment == .failed("Your bank declined the payment."))
        await viewModel.pay()
        let keys = service.chargedKeys.withLock { $0 }
        #expect(keys.count == 2)
        #expect(keys[0] == keys[1])
        #expect(viewModel.receipt?.amountCharged == 50)
    }

    @Test func aPercentCodeComesOffTheItemsAndKeepsFreeShipping() async {
        let viewModel = BasketViewModel(service: FakeCheckout(basket: fiftyEuros))
        await viewModel.load()
        viewModel.promoCode = "run10"
        await viewModel.applyPromo()
        #expect(viewModel.discount == 5)
        #expect(viewModel.shipping == 0)          // the threshold uses the subtotal before the discount
        #expect(viewModel.total == 45)
    }

    @Test func aFixedCodeNeverMakesTheTotalNegative() async {
        let viewModel = BasketViewModel(service: FakeCheckout(basket: [item("cap", "21.90")]))
        await viewModel.load()
        viewModel.promoCode = "GIFT25"
        await viewModel.applyPromo()
        #expect(viewModel.discount == Decimal(string: "21.90")!)
        #expect(viewModel.total == Decimal(string: "4.95")!)   // shipping is still paid
    }
}