Classes & Encapsulation

#include <cstdint>
#include <format>
#include <print>
#include <stdexcept>
#include <string>
#include <string_view>

// Value struct: pure passive data bundle with no invariant logic.
struct Money {
    int64_t paise{0};

    [[nodiscard]] double toRupees() const noexcept {
        return static_cast<double>(paise) / 100.0;
    }
};

// Class: maintains strict invariants over private state.
// Invariants:
// 1. balancePaise_ >= 0 (wallet cannot be overdrawn).
// 2. dailyLimitPaise_ > 0 (spending limit must be positive).
// 3. spentTodayPaise_ >= 0 and spentTodayPaise_ <= dailyLimitPaise_.
class Wallet {
private:
    std::string walletId_;
    int64_t balancePaise_{0};
    int64_t dailyLimitPaise_{100'000}; // Default limit Rs.1,000 (100,000 paise)
    int64_t spentTodayPaise_{0};

public:
    // Single-argument constructor marked explicit to prevent silent implicit conversions.
    explicit Wallet(std::string walletId, int64_t initialDepositPaise = 0, int64_t dailyLimitPaise = 100'000)
        : walletId_(std::move(walletId)),
          balancePaise_(initialDepositPaise),
          dailyLimitPaise_(dailyLimitPaise) {
        if (walletId_.empty()) {
            throw std::invalid_argument("Wallet ID cannot be empty");
        }
        if (initialDepositPaise < 0) {
            throw std::invalid_argument("Initial deposit cannot be negative");
        }
        if (dailyLimitPaise <= 0) {
            throw std::invalid_argument("Daily limit must be strictly positive");
        }
    }

    // Mutator with [[nodiscard]] so callers cannot ignore rejected deposits.
    [[nodiscard]] bool deposit(int64_t amountPaise) {
        if (amountPaise <= 0) {
            return false;
        }
        balancePaise_ += amountPaise;
        return true;
    }

    // Mutator: enforces both balance invariant and daily spend limit invariant.
    [[nodiscard]] bool withdraw(int64_t amountPaise) {
        if (amountPaise <= 0) {
            return false;
        }
        if (amountPaise > balancePaise_) {
            return false; // Invariant: balance cannot drop below 0
        }
        if (spentTodayPaise_ + amountPaise > dailyLimitPaise_) {
            return false; // Invariant: cannot exceed daily spending limit
        }

        balancePaise_ -= amountPaise;
        spentTodayPaise_ += amountPaise;
        return true;
    }

    // Const inspection methods: guarantee zero mutation on const instances.
    [[nodiscard]] int64_t balancePaise() const noexcept {
        return balancePaise_;
    }

    [[nodiscard]] int64_t remainingDailyLimitPaise() const noexcept {
        return dailyLimitPaise_ - spentTodayPaise_;
    }

    [[nodiscard]] const std::string& walletId() const noexcept {
        return walletId_;
    }

    void resetDailySpending() noexcept {
        spentTodayPaise_ = 0;
    }
};

int main() {
    Wallet customerWallet("wal_usr_9021", 50'000, 30'000); // Rs.500 balance, Rs.300 daily limit
    std::println("Created wallet {} with balance Rs.{:.2f}",
                 customerWallet.walletId(),
                 Money{customerWallet.balancePaise()}.toRupees());

    bool w1 = customerWallet.withdraw(20'000); // Withdraw Rs.200
    std::println("Withdraw Rs.200 -> ok={}, remaining balance Rs.{:.2f}, daily limit left Rs.{:.2f}",
                 w1,
                 Money{customerWallet.balancePaise()}.toRupees(),
                 Money{customerWallet.remainingDailyLimitPaise()}.toRupees());

    bool w2 = customerWallet.withdraw(15'000); // Attempt Rs.150 -> exceeds remaining limit Rs.100
    std::println("Withdraw Rs.150 (exceeds limit) -> ok={}, balance Rs.{:.2f}",
                 w2,
                 Money{customerWallet.balancePaise()}.toRupees());

    bool d1 = customerWallet.deposit(10'000); // Deposit Rs.100
    std::println("Deposit Rs.100 -> ok={}, new balance Rs.{:.2f}",
                 d1,
                 Money{customerWallet.balancePaise()}.toRupees());

    return 0;
}