Grand Finale: Real-World Java Capstone Project (ఎంటర్‌ప్రైజ్ బ్యాంకింగ్ ఇంజిన్ ఆర్కిటెక్చర్)

import java.time.Instant;
import java.util.*;

public class CoreBankingDomainAndExceptions {

    // 1. Transaction & Account Status Enums
    public enum AccountStatus { ACTIVE, FROZEN, CLOSED }
    public enum TxnStatus { SUCCESS, FAILED, FLAGGED_FOR_FRAUD }

    // 2. Custom Banking Exceptions Hierarchy
    public static class BankingCoreException extends Exception {
        private final String errorCode;
        public BankingCoreException(String errorCode, String message) {
            super(message);
            this.errorCode = errorCode;
        }
        public String getErrorCode() { return errorCode; }
    }

    public static class InsufficientBalanceException extends BankingCoreException {
        public InsufficientBalanceException(String accNo, double balance, double reqAmount) {
            super("ERR_INSUFFICIENT_FUNDS", 
                String.format("ఖాతా %s లో నిధులు సరిపోవు! ప్రస్తుత నిల్వ: ₹%,.2f | అవసరమైన మొత్తం: ₹%,.2f", 
                accNo, balance, reqAmount));
        }
    }

    public static class AccountNotFoundException extends BankingCoreException {
        public AccountNotFoundException(String accNo) {
            super("ERR_ACCOUNT_NOT_FOUND", "చెల్లని ఖాతా సంఖ్య: " + accNo);
        }
    }

    // 3. Domain Model: Immutable Java 21 Record for Account
    public record BankAccount(
        String accountNumber,
        String holderName,
        double balance,
        AccountStatus status,
        Instant createdDate
    ) {
        // Compact Constructor: ఇన్వేరియంట్ వాలిడేషన్స్
        public BankAccount {
            Objects.requireNonNull(accountNumber, "అకౌంట్ నంబర్ తప్పనిసరి");
            Objects.requireNonNull(holderName, "ఖాతాదారుని పేరు తప్పనిసరి");
            if (balance < 0) {
                throw new IllegalArgumentException("ప్రారంభ నిల్వ రుణాత్మకం (Negative) కాకూడదు!");
            }
        }
    }

    public static void main(String[] args) {
        System.out.println("=== 1. DOMAIN & EXCEPTION ARCHITECTURE TEST ===");
        
        BankAccount sampleAcc = new BankAccount("ACC-9001", "Balaji Coding Academy", 150000.0, AccountStatus.ACTIVE, Instant.now());
        System.out.println("నమోదు చేయబడిన ఖాతా: " + sampleAcc);

        // Exception Simulation
        try {
            double transferAmount = 200000.0;
            if (sampleAcc.balance() < transferAmount) {
                throw new InsufficientBalanceException(sampleAcc.accountNumber(), sampleAcc.balance(), transferAmount);
            }
        } catch (InsufficientBalanceException e) {
            System.err.println("
❌ [CAUGHT EXPECTED BANKING ERROR]");
            System.err.println("  Error Code: " + e.getErrorCode());
            System.err.println("  Details   : " + e.getMessage());
        }
    }
}

import java.time.Instant;
import java.util.*;
import java.util.function.Predicate;

public class FraudDetectionAndTransactionPipeline {

    public record AuditTxn(
        String txnId,
        String sender,
        String receiver,
        double amount,
        boolean isFlagged,
        Instant timestamp
    ) {}

    public static void main(String[] args) {
        System.out.println("=== REAL-TIME BANKING FRAUD DETECTION PIPELINE ===");

        // బ్లాక్‌లిస్ట్ చేయబడిన ఖాతాల సెట్ (O(1) శోధన కోసం HashSet)
        Set<String> blacklistedAccounts = Set.of("ACC-FRAUD-01", "ACC-SCAM-99");

        // ఇన్కమింగ్ లైవ్ ట్రాన్స్‌ఫర్ అభ్యర్థనలు
        List<AuditTxn> incomingTraffic = List.of(
            new AuditTxn("TXN-1001", "ACC-101", "ACC-202", 45000, false, Instant.now()),
            new AuditTxn("TXN-1002", "ACC-101", "ACC-FRAUD-01", 12000, false, Instant.now()), // బ్లాక్‌లిస్ట్ రిసీవర్!
            new AuditTxn("TXN-1003", "ACC-303", "ACC-404", 350000, false, Instant.now()), // భారీ మొత్తం!
            new AuditTxn("TXN-1004", "ACC-SCAM-99", "ACC-505", 8000, false, Instant.now()), // బ్లాక్‌లిస్ట్ సెండర్!
            new AuditTxn("TXN-1005", "ACC-202", "ACC-303", 95000, false, Instant.now())
        );

        // 1. ఫ్రాడ్ ప్రెడికేట్ లాంబ్డా సూత్రం
        Predicate<AuditTxn> isSuspicious = txn -> 
            txn.amount() >= 200000 || 
            blacklistedAccounts.contains(txn.sender()) || 
            blacklistedAccounts.contains(txn.receiver());

        System.out.println("మొత్తం ఇన్కమింగ్ లావాదేవీలు: " + incomingTraffic.size());

        // 2. స్ట్రీమ్ ద్వారా అనుమానాస్పద లావాదేవీల వడపోత
        List<AuditTxn> flaggedTxns = incomingTraffic.stream()
            .filter(isSuspicious)
            .toList();

        System.out.println("
🚨 --- FLAGGED SUSPICIOUS TRANSACTIONS (" + flaggedTxns.size() + ") ---");
        for (AuditTxn t : flaggedTxns) {
            String reason = t.amount() >= 200000 ? "HIGH_VALUE_THRESHOLD" : "BLACKLISTED_ACCOUNT_INTERACTION";
            System.out.printf("  [FLAGGED] ID: %-8s | ₹%,10.2f | From: %-12s To: %-12s | Reason: %s%n",
                t.txnId(), t.amount(), t.sender(), t.receiver(), reason);
        }

        // 3. సురక్షితమైన ఆమోదిత లావాదేవీల మొత్తం విలువ
        double approvedTurnover = incomingTraffic.stream()
            .filter(isSuspicious.negate())
            .mapToDouble(AuditTxn::amount)
            .sum();

        System.out.printf("
✅ సురక్షితమైన ఆమోదిత లావాదేవీల మొత్తం: ₹%,.2f%n", approvedTurnover);
    }
}

import java.time.Instant;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.stream.Collectors;

public class NextGenEnterpriseBankingEngine {

    // --- DOMAIN ENUMS & RECORDS (Java 21) ---
    public enum AccountStatus { ACTIVE, FROZEN, CLOSED }
    public enum TxnType { DEPOSIT, WITHDRAWAL, TRANSFER }

    public record Account(
        String accountNumber,
        String customerName,
        double balance,
        AccountStatus status
    ) {
        public Account withBalance(double newBalance) {
            return new Account(accountNumber, customerName, newBalance, status);
        }
    }

    public record Transaction(
        String txnId,
        String fromAcc,
        String toAcc,
        double amount,
        TxnType type,
        Instant timestamp
    ) {}

    // --- CUSTOM EXCEPTIONS ---
    public static class CoreBankingException extends Exception {
        public CoreBankingException(String msg) { super(msg); }
    }
    public static class InsufficientFundsException extends CoreBankingException {
        public InsufficientFundsException(String msg) { super(msg); }
    }
    public static class InvalidAccountException extends CoreBankingException {
        public InvalidAccountException(String msg) { super(msg); }
    }

    // --- CORE ENGINE IMPLEMENTATION ---
    public static class BankLedgerSystem {
        private final Map<String, Account> accounts = new ConcurrentHashMap<>();
        private final List<Transaction> auditLog = new CopyOnWriteArrayList<>();
        private final Set<String> blacklistedAccounts = ConcurrentHashMap.newKeySet();

        public BankLedgerSystem() {
            blacklistedAccounts.add("ACC-ROGUE-99");
        }

        public void openAccount(String accNo, String name, double initialDeposit) {
            accounts.put(accNo, new Account(accNo, name, initialDeposit, AccountStatus.ACTIVE));
            System.out.printf("🏦 [ACCOUNT OPENED] %s | Name: %-15s | Bal: ₹%,.2f%n", accNo, name, initialDeposit);
        }

        // అటామిక్ ఫండ్ ట్రాన్స్‌ఫర్ మెథడ్
        public synchronized void transferFunds(String fromAccNo, String toAccNo, double amount) 
                throws CoreBankingException {
            
            // 1. అకౌంట్ ధృవీకరణ
            Account sender = accounts.get(fromAccNo);
            Account receiver = accounts.get(toAccNo);

            if (sender == null) throw new InvalidAccountException("పంపే ఖాతా ఉనికిలో లేదు: " + fromAccNo);
            if (receiver == null) throw new InvalidAccountException("స్వీకరించే ఖాతా ఉనికిలో లేదు: " + toAccNo);

            // 2. సెక్యూరిటీ & ఫ్రాడ్ చెక్
            if (blacklistedAccounts.contains(fromAccNo) || blacklistedAccounts.contains(toAccNo)) {
                throw new CoreBankingException("🚨 భద్రతా హెచ్చరిక! బ్లాక్‌లిస్ట్ చేయబడిన ఖాతాతో లావాదేవీ నిలిపివేయబడింది!");
            }

            if (sender.status() != AccountStatus.ACTIVE) {
                throw new CoreBankingException("ఖాతా " + fromAccNo + " యాక్టివ్‌గా లేదు!");
            }

            // 3. నిధుల లభ్యత చెక్
            if (sender.balance() < amount) {
                throw new InsufficientFundsException(
                    String.format("ఖాతా %s లో నిధులు సరిపోవు! నిల్వ: ₹%,.2f, కోరినది: ₹%,.2f", 
                    fromAccNo, sender.balance(), amount));
            }

            // 4. అటామిక్ బ్యాలెన్స్ అప్‌డేట్
            accounts.put(fromAccNo, sender.withBalance(sender.balance() - amount));
            accounts.put(toAccNo, receiver.withBalance(receiver.balance() + amount));

            // 5. ఆడిట్ లాగ్‌లో రికార్డ్ చేయడం
            String txnId = "TXN-" + UUID.randomUUID().toString().substring(0, 8).toUpperCase();
            auditLog.add(new Transaction(txnId, fromAccNo, toAccNo, amount, TxnType.TRANSFER, Instant.now()));

            System.out.printf("✅ [TRANSFER SUCCESS] %s ➔ %s : ₹%,.2f | Ref: %s%n", 
                fromAccNo, toAccNo, amount, txnId);
        }

        // Stream Analytics: రియల్-టైమ్ సమ్మరీ రిపోర్ట్
        public void generateAnalyticsReport() {
            System.out.println("
📊 ================= CORE BANKING LIVE TELEMETRY =================");
            System.out.println("మొత్తం రిజిస్టర్డ్ ఖాతాలు: " + accounts.size());
            System.out.println("మొత్తం విజయవంతమైన లావాదేవీలు: " + auditLog.size());

            // 1. బ్యాంక్ వద్ద ఉన్న మొత్తం డిపాజిట్లు
            double totalBankDeposits = accounts.values().stream()
                .mapToDouble(Account::balance)
                .sum();
            System.out.printf("బ్యాంకు వద్ద ఉన్న మొత్తం కస్టమర్ డిపాజిట్లు: ₹%,.2f%n", totalBankDeposits);

            // 2. అత్యధిక బ్యాలెన్స్ గల టాప్ ఖాతాదారుడు
            accounts.values().stream()
                .max(Comparator.comparingDouble(Account::balance))
                .ifPresent(top -> System.out.printf("అత్యధిక డిపాజిట్ ఉన్న కస్టమర్: %s (₹%,.2f)%n", 
                    top.customerName(), top.balance()));

            // 3. ఆడిట్ లాగ్ సారాంశం
            double totalTurnover = auditLog.stream()
                .mapToDouble(Transaction::amount)
                .sum();
            System.out.printf("నేటి మొత్తం లావాదేవీల వాల్యూమ్ (Turnover): ₹%,.2f%n", totalTurnover);
            System.out.println("==================================================================");
        }
    }

    public static void main(String[] args) {
        System.out.println("🚀 INITIALIZING NEXTGEN BANKING ENGINE (Java 21 LTS Capstone)...");
        BankLedgerSystem bank = new BankLedgerSystem();

        // ఖాతాల నమోదు
        bank.openAccount("ACC-101", "Balaji Technologies", 500000.0);
        bank.openAccount("ACC-102", "Anand Telecom", 120000.0);
        bank.openAccount("ACC-103", "Kavitha Enterprises", 350000.0);

        System.out.println("
--- 1. PROCESSING ATOMIC TRANSFERS ---");
        try {
            bank.transferFunds("ACC-101", "ACC-102", 75000.0);
            bank.transferFunds("ACC-103", "ACC-101", 50000.0);
            // వైఫల్య దృశ్యం 1: సరిపోని నిధులు
            bank.transferFunds("ACC-102", "ACC-103", 900000.0);
        } catch (CoreBankingException e) {
            System.err.println("❌ [REJECTED TRANSACTION]: " + e.getMessage());
        }

        // లైవ్ ఎనలిటిక్స్ రిపోర్ట్ జనరేట్ చేయడం
        bank.generateAnalyticsReport();
    }
}