ఎక్సెప్షన్ హ్యాండ్లింగ్, ఫైల్ I/O & గ్రాండ్ కాప్‌స్టోన్ ప్రాజెక్ట్ (Exceptions, Files & Capstone)

#include <iostream>
#include <stdexcept> // standard exception classes

// సురక్షితమైన డివిజన్ ఫంక్షన్
double safeDivide(double numerator, double denominator) {
    if (denominator == 0.0) {
        // జీరోతో భాగించడం అసాధ్యం, కాబట్టి runtime_error ను త్రో చేస్తున్నాం
        throw std::runtime_error("గణిత లోపం: సున్నాతో భాగించడం సాధ్యం కాదు (Divide by Zero)!");
    }
    return numerator / denominator;
}

int main() {
    std::cout << "--- Modern C++ ఎక్సెప్షన్ హ్యాండ్లింగ్ డిమో ---\n";

    double a = 100.0;
    double b = 0.0;

    try {
        std::cout << "డివిజన్ ఆపరేషన్ ప్రారంభమవుతోంది...\n";
        double result = safeDivide(a, b);
        // ఎక్సెప్షన్ వస్తే క్రింది లైన్ ఎగ్జిక్యూట్ అవ్వదు!
        std::cout << "ఫలితం: " << result << "\n";
    }
    catch (const std::runtime_error& ex) {
        // సురక్షితంగా ఎక్సెప్షన్‌ను పట్టుకున్నాం
        std::cerr << "🚨 [ERROR CAUGHT]: " << ex.what() << "\n";
        std::cout << "ℹ️ రికవరీ లాజిక్: డిఫాల్ట్ వేల్యూ 0.0 కేటాయించబడింది.\n";
    }

    std::cout << "✅ ప్రోగ్రామ్ సురక్షితంగా తన ప్రయాణాన్ని కొనసాగిస్తోంది!\n";
    return 0;
}

#include <iostream>
#include <string>
#include <stdexcept>

// RAII రిసోర్స్ క్లాస్ - డిస్ట్రక్టర్ ఎగ్జిక్యూషన్ ట్రాక్ చేయడానికి
class NetworkSocket {
    std::string endpoint;
public:
    NetworkSocket(const std::string& ep) : endpoint(ep) {
        std::cout << "  🔌 [OPEN] సాకెట్ కనెక్షన్ తెరవబడింది: " << endpoint << "\n";
    }
    ~NetworkSocket() {
        std::cout << "  🧹 [CLEANUP] Stack Unwinding ద్వారా సాకెట్ క్లోజ్ చేయబడింది: " << endpoint << "\n";
    }
};

void deepFunction() {
    NetworkSocket sock("192.168.1.100:8080");
    std::cout << "  ⚡ deepFunction లోపల కీలక డేటా ప్రాసెస్ అవుతోంది...\n";
    
    // ఏదో తప్పు జరిగి ఎక్సెప్షన్ త్రో అయింది
    throw std::runtime_error("నెట్‌వర్క్ ప్యాకెట్ డ్రాప్ అయ్యింది (Corrupted Payload)!");
    
    std::cout << "  ఈ లైన్ ఎప్పటికీ ప్రింట్ అవ్వదు!\n";
}

int main() {
    std::cout << "=== STACK UNWINDING & RAII సేఫ్టీ డెమో ===\n";
    try {
        deepFunction();
    }
    catch (const std::exception& e) {
        std::cout << "🚨 [CATCH BLOCK]: ప్రధాన హ్యాండ్లర్ లో ఎర్రర్ దొరికింది: " << e.what() << "\n";
    }
    std::cout << "✅ ఏ మెమరీ లీక్ లేకుండా సిస్టమ్ రికవర్ అయ్యింది!\n";
    return 0;
}

#include <iostream>
#include <string>
#include <stdexcept>

// బ్యాంకింగ్ డొమైన్ కోసం రూట్ బేస్ ఎక్సెప్షన్
class BankingException : public std::runtime_error {
public:
    explicit BankingException(const std::string& msg) : std::runtime_error(msg) {}
};

// అకౌంట్‌లో తగినంత నిధులు లేనప్పుడు వచ్చే కస్టమ్ ఎక్సెప్షన్
class InsufficientFundsException : public BankingException {
    double currentBalance;
    double requestedAmount;
public:
    InsufficientFundsException(double balance, double requested)
        : BankingException("ఖాతాలో సరిపడా నిధులు లేవు! బ్యాలెన్స్: " + std::to_string(balance) + 
                           ", ఉపసంహరించదలచిన మొత్తం: " + std::to_string(requested)),
          currentBalance(balance), requestedAmount(requested) {}

    double getDeficit() const noexcept { return requestedAmount - currentBalance; }
};

class BankAccount {
    std::string accNumber;
    double balance;
public:
    BankAccount(const std::string& acc, double initial) : accNumber(acc), balance(initial) {}

    void withdraw(double amount) {
        if (amount > balance) {
            throw InsufficientFundsException(balance, amount);
        }
        balance -= amount;
        std::cout << "✅ ఉపసంహరణ విజయవంతం! విత్‌డ్రా: ₹ " << amount << ", ప్రస్తుత నిల్వ: ₹ " << balance << "\n";
    }
};

int main() {
    BankAccount myAcc("SB-987654321", 5000.0);

    try {
        std::cout << "లావాదేవీ 1: ₹ 2000 విత్‌డ్రా చేయడానికి ప్రయత్నిస్తున్నాం...\n";
        myAcc.withdraw(2000.0);

        std::cout << "\nలావాదేవీ 2: ₹ 7000 విత్‌డ్రా చేయడానికి ప్రయత్నిస్తున్నాం...\n";
        myAcc.withdraw(7000.0);
    }
    catch (const InsufficientFundsException& ex) {
        std::cerr << "❌ [BANKING ERROR]: " << ex.what() << "\n";
        std::cerr << "   లక్ష్యం నెరవేరడానికి ఇంకా లోటు మొత్తం: ₹ " << ex.getDeficit() << "\n";
    }
    catch (const BankingException& ex) {
        std::cerr << "❌ [GENERAL BANK ERROR]: " << ex.what() << "\n";
    }
    return 0;
}

#include <iostream>
#include <fstream>
#include <string>

void writeAuditLog(const std::string& filename) {
    // ofstream ఆబ్జెక్ట్ సృష్టించి ఫైల్ ఓపెన్ చేస్తున్నాం
    std::ofstream outFile(filename, std::ios::out | std::ios::app);
    
    if (!outFile.is_open()) {
        std::cerr << "ఫైల్ తెరవడంలో లోపం ఏర్పడింది!\n";
        return;
    }

    outFile << "TIMESTAMP: 2026-11-01 10:30:00 | USER: Admin | EVENT: Login Successful\n";
    outFile << "TIMESTAMP: 2026-11-01 10:32:15 | USER: User_42 | EVENT: Fund Transfer ₹ 5000\n";
    outFile << "TIMESTAMP: 2026-11-01 10:35:40 | USER: Admin | EVENT: Password Updated\n";

    std::cout << "✅ ఆడిట్ లాగ్ డేటా విజయవంతంగా ఫైల్ లోకి వ్రాయబడింది!\n";
    // outFile ఇక్కడ స్కోప్ దాటగానే ఆటోమేటిక్‌గా క్లోజ్ అవుతుంది (RAII)
}

void readAuditLog(const std::string& filename) {
    std::ifstream inFile(filename);

    if (!inFile.is_open()) {
        std::cerr << "ఫైల్ చదవడానికి అందుబాటులో లేదు: " << filename << "\n";
        return;
    }

    std::cout << "\n--- [" << filename << "] నుండి లైన్ల వారీగా డేటా రీడింగ్ ---\n";
    std::string line;
    int lineNum = 1;
    while (std::getline(inFile, line)) {
        std::cout << "లైన్ " << lineNum++ << ": " << line << "\n";
    }
}

int main() {
    std::string path = "system_audit.log";
    writeAuditLog(path);
    readAuditLog(path);
    return 0;
}

#include <iostream>
#include <fstream>
#include <cstring>

// ఫిక్స్‌డ్ సైజ్ ఉన్న POD (Plain Old Data) స్ట్రక్చర్
struct AccountRecord {
    int accountId;
    char customerName[32];
    double balance;
    bool isActive;
};

void saveBinaryRecord(const std::string& filename, const AccountRecord& record) {
    std::ofstream out(filename, std::ios::binary);
    if (!out) {
        std::cerr << "బైనరీ ఫైల్ తెరవడం విఫలమైంది!\n";
        return;
    }
    // మెమరీలోని బైట్లను నేరుగా డిస్క్‌పై వ్రాయడం
    out.write(reinterpret_cast<const char*>(&record), sizeof(AccountRecord));
    std::cout << "💾 బైనరీ రికార్డ్ సేవ్ చేయబడింది (" << sizeof(AccountRecord) << " బైట్స్).\n";
}

void loadBinaryRecord(const std::string& filename) {
    std::ifstream in(filename, std::ios::binary);
    if (!in) {
        std::cerr << "బైనరీ ఫైల్ చదవడం విఫలమైంది!\n";
        return;
    }
    AccountRecord loadedRecord{};
    in.read(reinterpret_cast<char*>(&loadedRecord), sizeof(AccountRecord));

    std::cout << "\n🔍 [డిస్క్ నుండి లోడ్ చేయబడిన రికార్డ్]:\n";
    std::cout << "  • అకౌంట్ ID: " << loadedRecord.accountId << "\n";
    std::cout << "  • ఖాతాదారుని పేరు: " << loadedRecord.customerName << "\n";
    std::cout << "  • బ్యాలెన్స్: ₹ " << loadedRecord.balance << "\n";
    std::cout << "  • యాక్టివ్ స్టేటస్: " << (loadedRecord.isActive ? "ACTIVE" : "INACTIVE") << "\n";
}

int main() {
    AccountRecord user1{101, "రాజేష్ శర్మ", 85400.50, true};
    std::string binFile = "account_101.dat";

    saveBinaryRecord(binFile, user1);
    loadBinaryRecord(binFile);
    return 0;
}

#include <iostream>
#include <string>
#include <vector>
#include <unordered_map>
#include <memory>
#include <fstream>
#include <sstream>
#include <iomanip>
#include <chrono>
#include <ctime>
#include <stdexcept>

// ==========================================
// 1. కస్టమ్ ఎక్సెప్షన్ హైరార్కీ (Domain Exceptions)
// ==========================================
class BankingException : public std::runtime_error {
public:
    explicit BankingException(const std::string& msg) : std::runtime_error(msg) {}
};

class InsufficientFundsException : public BankingException {
public:
    InsufficientFundsException(const std::string& acc, double balance, double req)
        : BankingException("ఖాతా [" + acc + "] లో తగినంత నిధులు లేవు! అందుబాటులో ఉన్నది: ₹ " + 
                           std::to_string(balance) + ", కోరినది: ₹ " + std::to_string(req)) {}
};

class InvalidAccountException : public BankingException {
public:
    explicit InvalidAccountException(const std::string& acc)
        : BankingException("ఖాతా సంఖ్య చెల్లదు లేదా బ్యాంక్ రికార్డులలో లేదు: " + acc) {}
};

// ==========================================
// 2. లావాదేవీ రికార్డ్ & డిస్క్ ఆడిటర్ (Audit Logger)
// ==========================================
struct Transaction {
    std::string timestamp;
    std::string accountId;
    std::string type;
    double amount;
    double postBalance;
};

class AuditLogger {
    std::string logFilePath;
public:
    AuditLogger(const std::string& path) : logFilePath(path) {}

    void log(const Transaction& tx) {
        std::ofstream file(logFilePath, std::ios::app);
        if (file.is_open()) {
            file << tx.timestamp << " | ACC: " << std::setw(12) << tx.accountId 
                 << " | TYPE: " << std::setw(10) << tx.type 
                 << " | AMOUNT: ₹ " << std::fixed << std::setprecision(2) << std::setw(10) << tx.amount 
                 << " | BAL: ₹ " << std::setw(10) << tx.postBalance << "\n";
        }
    }
};

// ==========================================
// 3. అబ్‌స్ట్రాక్ట్ బేస్ క్లాస్: Account (OOP)
// ==========================================
class Account {
protected:
    std::string accountId;
    std::string holderName;
    double balance;
public:
    Account(std::string id, std::string name, double initialBal)
        : accountId(std::move(id)), holderName(std::move(name)), balance(initialBal) {}
    
    virtual ~Account() = default;

    virtual void deposit(double amount) {
        if (amount <= 0) throw BankingException("డిపాజిట్ మొత్తం ₹ 0 కంటే ఎక్కువగా ఉండాలి!");
        balance += amount;
    }

    virtual void withdraw(double amount) = 0; // Pure Virtual Function

    const std::string& getId() const noexcept { return accountId; }
    const std::string& getName() const noexcept { return holderName; }
    double getBalance() const noexcept { return balance; }
    virtual std::string getAccountType() const = 0;
};

// ==========================================
// 4. డెరైవ్డ్ క్లాస్ 1: SavingsAccount (వడ్డీ సౌకర్యం)
// ==========================================
class SavingsAccount : public Account {
    double interestRate;
public:
    SavingsAccount(std::string id, std::string name, double bal, double rate = 4.5)
        : Account(std::move(id), std::move(name), bal), interestRate(rate) {}

    void withdraw(double amount) override {
        if (amount <= 0) throw BankingException("విత్‌డ్రా మొత్తం ధనాత్మకంగా ఉండాలి!");
        if (amount > balance) {
            throw InsufficientFundsException(accountId, balance, amount);
        }
        balance -= amount;
    }

    std::string getAccountType() const override { return "SAVINGS (సేవింగ్స్)"; }
};

// ==========================================
// 5. డెరైవ్డ్ క్లాస్ 2: CheckingAccount (ఓవర్‌డ్రాఫ్ట్ సౌకర్యం)
// ==========================================
class CheckingAccount : public Account {
    double overdraftLimit;
public:
    CheckingAccount(std::string id, std::string name, double bal, double limit = 15000.0)
        : Account(std::move(id), std::move(name), bal), overdraftLimit(limit) {}

    void withdraw(double amount) override {
        if (amount <= 0) throw BankingException("విత్‌డ్రా మొత్తం ధనాత్మకంగా ఉండాలి!");
        if (amount > (balance + overdraftLimit)) {
            throw InsufficientFundsException(accountId, balance + overdraftLimit, amount);
        }
        balance -= amount;
    }

    std::string getAccountType() const override { return "CURRENT/CHECKING (ఓవర్‌డ్రాఫ్ట్)"; }
};

// ==========================================
// 6. సెంట్రల్ బ్యాంక్ సిస్టమ్ మేనేజర్ (STL + Exceptions + File I/O)
// ==========================================
class EnterpriseBankSystem {
    std::unordered_map<std::string, std::shared_ptr<Account>> accounts;
    AuditLogger auditor;

    std::string getCurrentTimestamp() {
        auto now = std::chrono::system_clock::now();
        std::time_t t = std::chrono::system_clock::to_time_t(now);
        char buf[32];
        std::strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", std::localtime(&t));
        return std::string(buf);
    }

public:
    EnterpriseBankSystem(const std::string& logFile) : auditor(logFile) {}

    void openAccount(std::shared_ptr<Account> acc) {
        std::string id = acc->getId();
        accounts[id] = acc;
        auditor.log({getCurrentTimestamp(), id, "OPEN_ACC", acc->getBalance(), acc->getBalance()});
        std::cout << "  🎉 ఖాతా తెరవబడింది: [" << id << "] " << acc->getName() 
                  << " | టైప్: " << acc->getAccountType() << " | ప్రారంభ బ్యాలెన్స్: ₹ " << acc->getBalance() << "\n";
    }

    void processDeposit(const std::string& id, double amount) {
        auto it = accounts.find(id);
        if (it == accounts.end()) throw InvalidAccountException(id);

        it->second->deposit(amount);
        auditor.log({getCurrentTimestamp(), id, "DEPOSIT", amount, it->second->getBalance()});
        std::cout << "  💰 డిపాజిట్ విజయవంతం: ACC [" << id << "] +₹ " << amount 
                  << " => కొత్త బ్యాలెన్స్: ₹ " << it->second->getBalance() << "\n";
    }

    void processWithdrawal(const std::string& id, double amount) {
        auto it = accounts.find(id);
        if (it == accounts.end()) throw InvalidAccountException(id);

        it->second->withdraw(amount);
        auditor.log({getCurrentTimestamp(), id, "WITHDRAW", amount, it->second->getBalance()});
        std::cout << "  🏧 విత్‌డ్రా విజయవంతం: ACC [" << id << "] -₹ " << amount 
                  << " => కొత్త బ్యాలెన్స్: ₹ " << it->second->getBalance() << "\n";
    }

    void transferFunds(const std::string& fromId, const std::string& toId, double amount) {
        std::cout << "\n  🔄 అకౌంట్ ట్రాన్స్‌ఫర్ మొదలైంది: [" << fromId << "] నుండి [" << toId << "] కి ₹ " << amount << "...\n";
        auto fromIt = accounts.find(fromId);
        auto toIt = accounts.find(toId);

        if (fromIt == accounts.end()) throw InvalidAccountException(fromId);
        if (toIt == accounts.end()) throw InvalidAccountException(toId);

        // Transactional Safety: డెబిట్ సక్సెస్ అయితేనే క్రెడిట్ చేస్తాం!
        fromIt->second->withdraw(amount);
        try {
            toIt->second->deposit(amount);
        } catch (...) {
            // రోల్‌బ్యాక్ మెకానిజమ్
            fromIt->second->deposit(amount);
            throw BankingException("ట్రాన్స్‌ఫర్ ఫెయిల్ అయ్యింది! నిధులు రోల్‌బ్యాక్ చేయబడ్డాయి.");
        }

        auditor.log({getCurrentTimestamp(), fromId, "XFER_OUT", amount, fromIt->second->getBalance()});
        auditor.log({getCurrentTimestamp(), toId, "XFER_IN", amount, toIt->second->getBalance()});
        std::cout << "  ✅ నిధుల బదిలీ పూర్తయింది! ఆడిట్ లాగ్ రికార్డ్ అయ్యింది.\n";
    }

    void displayAllAccounts() const {
        std::cout << "\n=========================================================================================\n";
        std::cout << "                      🏦 ఎంటర్‌ప్రైజ్ బ్యాంక్ - ఖాతాదారుల రియల్-టైమ్ సమ్మరీ\n";
        std::cout << "=========================================================================================\n";
        for (const auto& [id, acc] : accounts) {
            std::cout << "  ID: " << std::setw(12) << acc->getId() 
                      << " | పేరు: " << std::setw(18) << acc->getName() 
                      << " | టైప్: " << std::setw(22) << acc->getAccountType() 
                      << " | బ్యాలెన్స్: ₹ " << std::setw(10) << acc->getBalance() << "\n";
        }
        std::cout << "=========================================================================================\n";
    }
};

int main() {
    std::cout << "=========================================================================================\n";
    std::cout << "      🚀 MODERN C++ గ్రాండ్ కాప్‌స్టోన్ ప్రాజెక్ట్: ENTERPRISE BANK AUDIT SYSTEM\n";
    std::cout << "=========================================================================================\n\n";

    EnterpriseBankSystem bank("enterprise_bank_audit.txt");

    // 1. ఖాతాలు తెరవడం
    bank.openAccount(std::make_shared<SavingsAccount>("SB-1001", "రాహుల్ వర్మ", 45000.0));
    bank.openAccount(std::make_shared<CheckingAccount>("CA-2001", "టెక్-సొల్యూషన్స్ లిమిటెడ్", 120000.0, 50000.0));
    bank.openAccount(std::make_shared<SavingsAccount>("SB-1002", "అనన్య రెడ్డి", 15000.0));

    bank.displayAllAccounts();

    // 2. సాధారణ విజయవంతమైన లావాదేవీలు
    std::cout << "\n[లావాదేవీల ఎగ్జిక్యూషన్]:\n";
    try {
        bank.processDeposit("SB-1001", 10000.0);
        bank.processWithdrawal("CA-2001", 25000.0);
        bank.transferFunds("SB-1001", "SB-1002", 15000.0);
    }
    catch (const BankingException& e) {
        std::cerr << "🚨 [ERROR]: " << e.what() << "\n";
    }

    // 3. ఎక్సెప్షన్ హ్యాండ్లింగ్ టెస్టింగ్ (నిధుల కొరత)
    std::cout << "\n[ఎక్సెప్షన్ టెస్ట్ 1: ఖాతాలో ఉన్నదానికంటే ఎక్కువ విత్‌డ్రా చేసినప్పుడు]:\n";
    try {
        bank.processWithdrawal("SB-1002", 90000.0);
    }
    catch (const InsufficientFundsException& e) {
        std::cerr << "  🚨 ఆపరేషన్ తిరస్కరించబడింది: " << e.what() << "\n";
    }

    // 4. ఎక్సెప్షన్ టెస్ట్ 2: లేని ఖాతాకు బదిలీ ప్రయత్నించినప్పుడు
    std::cout << "\n[ఎక్సెప్షన్ టెస్ట్ 2: లేని అకౌంట్ నంబర్ ఇచ్చినప్పుడు]:\n";
    try {
        bank.transferFunds("SB-1001", "SB-9999_UNKNOWN", 500.0);
    }
    catch (const InvalidAccountException& e) {
        std::cerr << "  🚨 ఆపరేషన్ తిరస్కరించబడింది: " << e.what() << "\n";
    }

    bank.displayAllAccounts();

    std::cout << "\n🎯 కాప్‌స్టోన్ ప్రాజెక్ట్ సక్సెస్: అన్ని లావాదేవీలు 'enterprise_bank_audit.txt' లో ఆడిట్ అయ్యాయి!\n";
    std::cout << "🏆 అభినందనలు! మీరు Modern C++ Masterclass కోర్సును విజయవంతంగా పూర్తి చేసారు! 🚀\n";
    return 0;
}