/** 

This Java implementation showcases the core principles of double-entry accounting, using ducats as 
the currency in honor of the Medici banking dynasty. Here's what the code demonstrates:

1. **The Fundamental Principle**: Every transaction affects at least two accounts 
(the double-entry principle), and the sum of debits must always equal the sum of credits.

2. **Five Main Account Types**:
   - Assets: Resources owned by the business
   - Liabilities: Debts owed by the business
   - Equity: Owner's interest in the business
   - Revenue: Income earned by the business
   - Expenses: Costs incurred by the business

3. **Account Balance Rules**:
   - Assets and Expenses: Increased by debits, decreased by credits
   - Liabilities, Equity, and Revenue: Increased by credits, decreased by debits

4. **Key Financial Reports**:
   - Trial Balance: Verifies that total debits equal total credits
   - Balance Sheet: Shows Assets = Liabilities + Equity
   - Income Statement: Shows Revenue - Expenses = Net Income

The example simulates transactions for the Medici Bank in the year 1397, 
including initial capitalization, loans with interest (a key banking activity), 
property acquisition, and operating expenses.

*/
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.LocalDate;
import java.util.*;

/**
 * A double-entry accounting system implementation inspired by the 
 * Florentine banking practices of the deMedici family.
 */
public class MediciBankingSystem {

    public static void main(String[] args) {
        // Create a new ledger for our banking operations
        Ledger mediciLedger = new Ledger("Medici Family Bank");
        
        // Define our chart of accounts
        Account cash = mediciLedger.createAccount("Cash", AccountType.ASSET);
        Account accounts_receivable = mediciLedger.createAccount("Accounts Receivable", AccountType.ASSET);
        Account inventory = mediciLedger.createAccount("Inventory", AccountType.ASSET);
        Account land = mediciLedger.createAccount("Land", AccountType.ASSET);
        
        Account accounts_payable = mediciLedger.createAccount("Accounts Payable", AccountType.LIABILITY);
        Account loans = mediciLedger.createAccount("Loans", AccountType.LIABILITY);
        
        Account capital = mediciLedger.createAccount("Owner's Capital", AccountType.EQUITY);
        Account retained_earnings = mediciLedger.createAccount("Retained Earnings", AccountType.EQUITY);
        
        Account revenue = mediciLedger.createAccount("Revenue", AccountType.REVENUE);
        Account interest_income = mediciLedger.createAccount("Interest Income", AccountType.REVENUE);
        
        Account expenses = mediciLedger.createAccount("Expenses", AccountType.EXPENSE);
        Account wages = mediciLedger.createAccount("Wages", AccountType.EXPENSE);
        
        // Starting our banking operations with initial capital
        System.out.println("=== STARTING THE MEDICI BANK ===");
        mediciLedger.recordTransaction(
            LocalDate.of(1397, 1, 1),
            "Initial investment from Giovanni de' Medici",
            new TransactionEntry(cash, new BigDecimal("10000.00")),
            new TransactionEntry(capital, new BigDecimal("10000.00"))
        );
        
        // Recording a loan to a wool merchant
        mediciLedger.recordTransaction(
            LocalDate.of(1397, 2, 15),
            "Loan to Wool Merchant",
            new TransactionEntry(accounts_receivable, new BigDecimal("2000.00")),
            new TransactionEntry(cash, new BigDecimal("2000.00"))
        );
        
        // Receiving partial payment with interest
        mediciLedger.recordTransaction(
            LocalDate.of(1397, 8, 10),
            "Partial loan repayment from Wool Merchant with interest",
            new TransactionEntry(cash, new BigDecimal("1200.00")),
            new TransactionEntry(accounts_receivable, new BigDecimal("1000.00")),
            new TransactionEntry(interest_income, new BigDecimal("200.00"))
        );
        
        // Purchasing land for a new banking house
        mediciLedger.recordTransaction(
            LocalDate.of(1397, 9, 5),
            "Purchase of land for new Medici banking house",
            new TransactionEntry(land, new BigDecimal("3000.00")),
            new TransactionEntry(cash, new BigDecimal("3000.00"))
        );
        
        // Paying wages to bank employees
        mediciLedger.recordTransaction(
            LocalDate.of(1397, 12, 1),
            "Quarterly wages for bank employees",
            new TransactionEntry(wages, new BigDecimal("800.00")),
            new TransactionEntry(cash, new BigDecimal("800.00"))
        );
        
        // Print the trial balance to verify our accounting is balanced
        System.out.println("\n=== MEDICI BANK TRIAL BALANCE (Year 1397) ===");
        mediciLedger.printTrialBalance();
        
        // Print the balance sheet
        System.out.println("\n=== MEDICI BANK BALANCE SHEET (Year 1397) ===");
        mediciLedger.printBalanceSheet();
        
        // Print the income statement
        System.out.println("\n=== MEDICI BANK INCOME STATEMENT (Year 1397) ===");
        mediciLedger.printIncomeStatement();
    }
}

/**
 * Represents a financial account in the double-entry system
 */
class Account {
    private String name;
    private AccountType type;
    private BigDecimal balance;
    
    public Account(String name, AccountType type) {
        this.name = name;
        this.type = type;
        this.balance = BigDecimal.ZERO;
    }
    
    public String getName() {
        return name;
    }
    
    public AccountType getType() {
        return type;
    }
    
    public BigDecimal getBalance() {
        return balance;
    }
    
    /**
     * Debits increase ASSET and EXPENSE accounts
     * Debits decrease LIABILITY, EQUITY, and REVENUE accounts
     */
    public void debit(BigDecimal amount) {
        if (type == AccountType.ASSET || type == AccountType.EXPENSE) {
            balance = balance.add(amount);
        } else {
            balance = balance.subtract(amount);
        }
    }
    
    /**
     * Credits decrease ASSET and EXPENSE accounts
     * Credits increase LIABILITY, EQUITY, and REVENUE accounts
     */
    public void credit(BigDecimal amount) {
        if (type == AccountType.ASSET || type == AccountType.EXPENSE) {
            balance = balance.subtract(amount);
        } else {
            balance = balance.add(amount);
        }
    }
    
    @Override
    public String toString() {
        return name + " (" + type + "): " + balance + " ducats";
    }
}

/**
 * The different types of accounts in double-entry accounting
 */
enum AccountType {
    ASSET,      // Resources owned by the business
    LIABILITY,  // Debts owed by the business
    EQUITY,     // Owner's interest in the business
    REVENUE,    // Income earned by the business
    EXPENSE     // Costs incurred by the business
}

/**
 * Represents a single entry in a transaction
 */
class TransactionEntry {
    private Account account;
    private BigDecimal amount;
    
    public TransactionEntry(Account account, BigDecimal amount) {
        this.account = account;
        this.amount = amount;
    }
    
    public Account getAccount() {
        return account;
    }
    
    public BigDecimal getAmount() {
        return amount;
    }
}

/**
 * Represents a complete financial transaction in the double-entry system
 */
class Transaction {
    private String description;
    private LocalDate date;
    private List<TransactionEntry> debits;
    private List<TransactionEntry> credits;
    
    public Transaction(LocalDate date, String description) {
        this.date = date;
        this.description = description;
        this.debits = new ArrayList<>();
        this.credits = new ArrayList<>();
    }
    
    public void addDebit(TransactionEntry entry) {
        debits.add(entry);
    }
    
    public void addCredit(TransactionEntry entry) {
        credits.add(entry);
    }
    
    public boolean isBalanced() {
        BigDecimal totalDebits = debits.stream()
            .map(TransactionEntry::getAmount)
            .reduce(BigDecimal.ZERO, BigDecimal::add);
            
        BigDecimal totalCredits = credits.stream()
            .map(TransactionEntry::getAmount)
            .reduce(BigDecimal.ZERO, BigDecimal::add);
            
        return totalDebits.compareTo(totalCredits) == 0;
    }
    
    public void post() {
        // Apply all debits
        for (TransactionEntry entry : debits) {
            entry.getAccount().debit(entry.getAmount());
        }
        
        // Apply all credits
        for (TransactionEntry entry : credits) {
            entry.getAccount().credit(entry.getAmount());
        }
    }
    
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("Transaction: ").append(date).append(" - ").append(description).append("\n");
        
        sb.append("  Debits:\n");
        for (TransactionEntry entry : debits) {
            sb.append("    ").append(entry.getAccount().getName())
              .append(": ").append(entry.getAmount()).append(" ducats\n");
        }
        
        sb.append("  Credits:\n");
        for (TransactionEntry entry : credits) {
            sb.append("    ").append(entry.getAccount().getName())
              .append(": ").append(entry.getAmount()).append(" ducats\n");
        }
        
        return sb.toString();
    }
}

/**
 * The main ledger that keeps track of all accounts and transactions
 */
class Ledger {
    private String name;
    private List<Account> accounts;
    private List<Transaction> transactions;
    
    public Ledger(String name) {
        this.name = name;
        this.accounts = new ArrayList<>();
        this.transactions = new ArrayList<>();
    }
    
    public Account createAccount(String name, AccountType type) {
        Account account = new Account(name, type);
        accounts.add(account);
        return account;
    }
    
    /**
     * Records a transaction with any number of debits and credits,
     * ensuring that debits = credits (the fundamental principle of double-entry)
     */
    public void recordTransaction(LocalDate date, String description, 
                                  TransactionEntry... entries) {
        Transaction transaction = new Transaction(date, description);
        
        // Separate entries into debits and credits based on account type
        for (TransactionEntry entry : entries) {
            Account account = entry.getAccount();
            AccountType type = account.getType();
            
            // For asset and expense accounts, positive amounts are debits
            // For liability, equity, and revenue accounts, positive amounts are credits
            if (type == AccountType.ASSET || type == AccountType.EXPENSE) {
                if (entry.getAmount().compareTo(BigDecimal.ZERO) >= 0) {
                    transaction.addDebit(entry);
                } else {
                    // Negative amount means we're crediting the account
                    transaction.addCredit(new TransactionEntry(
                        account, entry.getAmount().abs()));
                }
            } else {
                if (entry.getAmount().compareTo(BigDecimal.ZERO) >= 0) {
                    transaction.addCredit(entry);
                } else {
                    // Negative amount means we're debiting the account
                    transaction.addDebit(new TransactionEntry(
                        account, entry.getAmount().abs()));
                }
            }
        }
        
        // Verify that the transaction is balanced
        if (!transaction.isBalanced()) {
            throw new IllegalArgumentException("Transaction is not balanced: debits must equal credits");
        }
        
        // Post the transaction to update account balances
        transaction.post();
        
        // Record the transaction in the ledger
        transactions.add(transaction);
        System.out.println(transaction);
    }
    
    /**
     * Prints a trial balance to verify that debits = credits across all accounts
     */
    public void printTrialBalance() {
        BigDecimal totalDebits = BigDecimal.ZERO;
        BigDecimal totalCredits = BigDecimal.ZERO;
        
        System.out.printf("%-30s %-15s %-15s%n", "Account", "Debit (Ducats)", "Credit (Ducats)");
        System.out.println("-".repeat(60));
        
        for (Account account : accounts) {
            BigDecimal balance = account.getBalance();
            
            // For the trial balance, we show positive balances in their normal position
            // Assets and Expenses with positive balances are shown as debits
            // Liabilities, Equity, and Revenue with positive balances are shown as credits
            if (account.getType() == AccountType.ASSET || 
                account.getType() == AccountType.EXPENSE) {
                if (balance.compareTo(BigDecimal.ZERO) > 0) {
                    System.out.printf("%-30s %-15s %-15s%n", 
                        account.getName(), balance.setScale(2, RoundingMode.HALF_UP), "");
                    totalDebits = totalDebits.add(balance);
                } else if (balance.compareTo(BigDecimal.ZERO) < 0) {
                    System.out.printf("%-30s %-15s %-15s%n", 
                        account.getName(), "", balance.abs().setScale(2, RoundingMode.HALF_UP));
                    totalCredits = totalCredits.add(balance.abs());
                }
            } else {
                if (balance.compareTo(BigDecimal.ZERO) > 0) {
                    System.out.printf("%-30s %-15s %-15s%n", 
                        account.getName(), "", balance.setScale(2, RoundingMode.HALF_UP));
                    totalCredits = totalCredits.add(balance);
                } else if (balance.compareTo(BigDecimal.ZERO) < 0) {
                    System.out.printf("%-30s %-15s %-15s%n", 
                        account.getName(), balance.abs().setScale(2, RoundingMode.HALF_UP), "");
                    totalDebits = totalDebits.add(balance.abs());
                }
            }
        }
        
        System.out.println("-".repeat(60));
        System.out.printf("%-30s %-15s %-15s%n", 
            "TOTAL", totalDebits.setScale(2, RoundingMode.HALF_UP), 
            totalCredits.setScale(2, RoundingMode.HALF_UP));
            
        if (totalDebits.compareTo(totalCredits) == 0) {
            System.out.println("\nThe books are balanced! ✓");
        } else {
            System.out.println("\nWARNING: The books are NOT balanced! ✗");
        }
    }
    
    /**
     * Prints a balance sheet (Assets = Liabilities + Equity)
     */
    public void printBalanceSheet() {
        BigDecimal totalAssets = BigDecimal.ZERO;
        BigDecimal totalLiabilities = BigDecimal.ZERO;
        BigDecimal totalEquity = BigDecimal.ZERO;
        
        // Print Assets
        System.out.println("ASSETS");
        System.out.println("-".repeat(40));
        for (Account account : accounts) {
            if (account.getType() == AccountType.ASSET && account.getBalance().compareTo(BigDecimal.ZERO) != 0) {
                System.out.printf("%-30s %10s%n", 
                    account.getName(), account.getBalance().setScale(2, RoundingMode.HALF_UP));
                totalAssets = totalAssets.add(account.getBalance());
            }
        }
        System.out.println("-".repeat(40));
        System.out.printf("%-30s %10s%n", "TOTAL ASSETS", totalAssets.setScale(2, RoundingMode.HALF_UP));
        System.out.println();
        
        // Print Liabilities
        System.out.println("LIABILITIES");
        System.out.println("-".repeat(40));
        for (Account account : accounts) {
            if (account.getType() == AccountType.LIABILITY && account.getBalance().compareTo(BigDecimal.ZERO) != 0) {
                System.out.printf("%-30s %10s%n", 
                    account.getName(), account.getBalance().setScale(2, RoundingMode.HALF_UP));
                totalLiabilities = totalLiabilities.add(account.getBalance());
            }
        }
        System.out.println("-".repeat(40));
        System.out.printf("%-30s %10s%n", "TOTAL LIABILITIES", totalLiabilities.setScale(2, RoundingMode.HALF_UP));
        System.out.println();
        
        // Print Equity
        System.out.println("EQUITY");
        System.out.println("-".repeat(40));
        for (Account account : accounts) {
            if (account.getType() == AccountType.EQUITY && account.getBalance().compareTo(BigDecimal.ZERO) != 0) {
                System.out.printf("%-30s %10s%n", 
                    account.getName(), account.getBalance().setScale(2, RoundingMode.HALF_UP));
                totalEquity = totalEquity.add(account.getBalance());
            }
        }
        System.out.println("-".repeat(40));
        System.out.printf("%-30s %10s%n", "TOTAL EQUITY", totalEquity.setScale(2, RoundingMode.HALF_UP));
        System.out.println();
        
        // Verify the accounting equation: Assets = Liabilities + Equity
        System.out.println("ACCOUNTING EQUATION");
        System.out.println("-".repeat(40));
        System.out.printf("%-30s %10s%n", "Total Assets", totalAssets.setScale(2, RoundingMode.HALF_UP));
        System.out.printf("%-30s %10s%n", "Total Liabilities + Equity", 
            totalLiabilities.add(totalEquity).setScale(2, RoundingMode.HALF_UP));
            
        if (totalAssets.compareTo(totalLiabilities.add(totalEquity)) == 0) {
            System.out.println("\nThe accounting equation is balanced! ✓");
        } else {
            System.out.println("\nWARNING: The accounting equation is NOT balanced! ✗");
        }
    }
    
    /**
     * Prints an income statement (Revenue - Expenses = Net Income)
     */
    public void printIncomeStatement() {
        BigDecimal totalRevenue = BigDecimal.ZERO;
        BigDecimal totalExpenses = BigDecimal.ZERO;
        
        // Print Revenue
        System.out.println("REVENUE");
        System.out.println("-".repeat(40));
        for (Account account : accounts) {
            if (account.getType() == AccountType.REVENUE && account.getBalance().compareTo(BigDecimal.ZERO) != 0) {
                System.out.printf("%-30s %10s%n", 
                    account.getName(), account.getBalance().setScale(2, RoundingMode.HALF_UP));
                totalRevenue = totalRevenue.add(account.getBalance());
            }
        }
        System.out.println("-".repeat(40));
        System.out.printf("%-30s %10s%n", "TOTAL REVENUE", totalRevenue.setScale(2, RoundingMode.HALF_UP));
        System.out.println();
        
        // Print Expenses
        System.out.println("EXPENSES");
        System.out.println("-".repeat(40));
        for (Account account : accounts) {
            if (account.getType() == AccountType.EXPENSE && account.getBalance().compareTo(BigDecimal.ZERO) != 0) {
                System.out.printf("%-30s %10s%n", 
                    account.getName(), account.getBalance().setScale(2, RoundingMode.HALF_UP));
                totalExpenses = totalExpenses.add(account.getBalance());
            }
        }
        System.out.println("-".repeat(40));
        System.out.printf("%-30s %10s%n", "TOTAL EXPENSES", totalExpenses.setScale(2, RoundingMode.HALF_UP));
        System.out.println();
        
        // Calculate Net Income
        BigDecimal netIncome = totalRevenue.subtract(totalExpenses);
        System.out.println("SUMMARY");
        System.out.println("-".repeat(40));
        System.out.printf("%-30s %10s%n", "Total Revenue", totalRevenue.setScale(2, RoundingMode.HALF_UP));
        System.out.printf("%-30s %10s%n", "Total Expenses", totalExpenses.setScale(2, RoundingMode.HALF_UP));
        System.out.println("-".repeat(40));
        System.out.printf("%-30s %10s%n", "NET INCOME", netIncome.setScale(2, RoundingMode.HALF_UP));
    }
}