┌─────────────────────────────────────────────────────────────────────────────┐
│                    EVOLUTION OF LENDING                                     │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  Traditional Banking        FinTech Lending         DeFi Lending           │
│  (Pre-2000s)               (2010s)                (2020s)                  │
│                                                                             │
│  ┌─────────────────┐     ┌─────────────────┐     ┌─────────────────────┐   │
│  │ • Physical banks │     │ • Online/App    │     │ • Smart contracts   │   │
│  │ • Manual process │     │ • Algorithmic   │     │ • Permissionless    │   │
│  │ • Credit history │     │ • Data-driven   │     │ • Collateralised   │   │
│  │ • Days to approve│     │ • Hours to      │     │ • Instant           │   │
│  │ • High barriers  │     │   approve       │     │ • Global access    │   │
│  └─────────────────┘     └─────────────────┘     └─────────────────────┘   │
│                                                                             │
│  Key Drivers:                                                               │
│  • Technology adoption                                                      │
│  • Data availability and AI                                                │
│  • Blockchain and smart contracts                                          │
│  • Financial inclusion                                                     │
│  • Alternative credit scoring                                              │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                    DIGITAL LENDING PROCESS                                   │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  1. APPLICATION                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ Borrower applies via platform                                        │   │
│  │ Submits KYC, financial data                                         │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  2. CREDIT ASSESSMENT                                                       │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Traditional: Credit bureau check                                   │   │
│  │ • Alternative: Income, behavioural, on-chain data                  │   │
│  │ • DeFi: Collateral valuation                                        │   │
│  │ • Credit scoring algorithm                                          │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  3. APPROVAL & TERMS                                                       │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Loan amount                                                         │   │
│  │ • Interest rate                                                       │   │
│  │ • Term and repayment schedule                                        │   │
│  │ • Collateral requirement                                             │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  4. DISBURSEMENT                                                            │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Funds transferred to borrower                                     │   │
│  │ • Smart contract locks collateral                                    │   │
│  │ • Loan recorded on-chain                                             │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  5. REPAYMENT & MONITORING                                                 │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Automated repayments                                              │   │
│  │ • Interest accrual                                                  │   │
│  │ • Delinquency monitoring                                            │   │
│  │ • Liquidation if collateral drops                                   │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                    ALTERNATIVE CREDIT DATA SOURCES                          │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    FINANCIAL TRANSACTIONS                            │   │
│  │  • Bank account history                                             │   │
│  │  • Mobile money usage                                               │   │
│  │  • Utility bill payments                                            │   │
│  │  • Digital wallet activity                                          │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    BEHAVIOURAL DATA                                  │   │
│  │  • E-commerce purchase history                                      │   │
│  │  • Social media activity (with consent)                             │   │
│  │  • Mobile app usage patterns                                        │   │
│  │  • Geolocation data                                                 │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    ON-CHAIN DATA                                     │   │
│  │  • Transaction history                                              │   │
│  │  • DeFi protocol interactions                                       │   │
│  │  • Reputation scores                                                │   │
│  │  • Collateral history                                               │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

Utilization Rate = Total Borrowed / Total Liquidity

Interest Rate = Base Rate + Slope × Utilization Rate

Where slope increases at higher utilization to incentivise repayments.

# ===================================================================
# MODULE 2, LESSON 7: DIGITAL LENDING AND CREDIT
# ===================================================================

import time
import random
from typing import Dict, List, Optional, Tuple
from dataclasses import dataclass
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
import warnings
warnings.filterwarnings('ignore')

print("="*70)
print("DIGITAL LENDING AND CREDIT")
print("="*70)

# ----------------------------------------------------------------
# PART A: DIGITAL LENDING PLATFORM SIMULATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART A: Digital Lending Platform Simulation")
print("-"*60)

@dataclass
class LoanApplication:
    applicant_id: str
    amount: float
    purpose: str
    income: float
    credit_score: int
    loan_term: int  # months
    timestamp: float

class CreditScoring:
    def __init__(self):
        self.weights = {
            'income': 0.3,
            'credit_score': 0.4,
            'employment_history': 0.15,
            'debt_to_income': 0.15
        }
    
    def calculate_score(self, application: LoanApplication, additional_data: Dict = None) -> float:
        # Base scoring model
        income_score = min(application.income / 5000, 1.0) * 100
        
        # Credit score (300-850) normalised
        credit_score_norm = (application.credit_score - 300) / (850 - 300) * 100
        
        # Combined score (simplified)
        base_score = income_score * 0.4 + credit_score_norm * 0.6
        
        # Add adjustments based on purpose and term
        if application.purpose in ['Education', 'Medical']:
            base_score += 5
        elif application.purpose == 'Investment':
            base_score -= 5
        
        if application.loan_term > 36:
            base_score -= 5
        
        # Risk adjustment
        debt_to_income = additional_data.get('debt_to_income', 0.3) if additional_data else 0.3
        if debt_to_income > 0.4:
            base_score -= 10
        
        return max(0, min(100, base_score))

class DigitalLender:
    def __init__(self, name: str):
        self.name = name
        self.pool_balance = 1000000  # Initial pool
        self.loans: List[Dict] = []
        self.applications: List[LoanApplication] = []
        self.credit_scorer = CreditScoring()
        self.approval_threshold = 60
        self.default_rate = 0.05
        self.interest_rate = 0.08  # 8% annual
    
    def apply_for_loan(self, applicant_id: str, amount: float, purpose: str, 
                       income: float, credit_score: int, loan_term: int) -> float:
        app = LoanApplication(applicant_id, amount, purpose, income, credit_score, loan_term, time.time())
        self.applications.append(app)
        
        # Score the application
        score = self.credit_scorer.calculate_score(app)
        
        # Decision
        approved = score >= self.approval_threshold and amount <= self.pool_balance * 0.1
        
        if approved:
            return self._originate_loan(app)
        else:
            print(f"Application for {applicant_id} DENIED (Score: {score:.1f})")
            return 0
    
    def _originate_loan(self, app: LoanApplication) -> float:
        # Adjust amount based on risk score
        score = self.credit_scorer.calculate_score(app)
        max_loan_multiplier = min(score / 20, 5.0)  # Max 5x income
        max_amount = min(app.income * max_loan_multiplier, app.amount)
        
        if max_amount < app.amount:
            print(f"Loan adjusted from {app.amount:.2f} to {max_amount:.2f}")
        
        interest = self.interest_rate * (1 + (1 - score/100) * 0.5)  # Higher risk = higher rate
        
        loan = {
            'applicant': app.applicant_id,
            'original_amount': app.amount,
            'disbursed_amount': max_amount,
            'purpose': app.purpose,
            'term_months': app.loan_term,
            'interest_rate': interest,
            'credit_score': score,
            'disbursement_date': time.time(),
            'status': 'active',
            'repayments_made': 0,
            'total_repayment': max_amount * (1 + interest * app.loan_term/12)
        }
        self.loans.append(loan)
        self.pool_balance -= max_amount
        
        print(f"Loan disbursed to {app.applicant_id}: ${max_amount:.2f} at {interest*100:.1f}% APR")
        return max_amount
    
    def make_repayment(self, loan_index: int, amount: float) -> bool:
        if loan_index >= len(self.loans):
            return False
        loan = self.loans[loan_index]
        if loan['status'] != 'active':
            return False
        
        loan['repayments_made'] += 1
        # Simulate repayment (simplified)
        self.pool_balance += amount * 0.95  # 5% fee
        print(f"Repayment received on loan #{loan_index}: ${amount:.2f}")
        
        if loan['repayments_made'] >= loan['term_months']:
            loan['status'] = 'completed'
            print(f"Loan #{loan_index} fully repaid!")
        return True
    
    def get_metrics(self) -> Dict:
        total_loaned = sum(l['disbursed_amount'] for l in self.loans)
        active_loans = len([l for l in self.loans if l['status'] == 'active'])
        completed = len([l for l in self.loans if l['status'] == 'completed'])
        defaulted = len([l for l in self.loans if l['status'] == 'defaulted'])
        
        return {
            'name': self.name,
            'pool_balance': self.pool_balance,
            'total_loaned': total_loaned,
            'active_loans': active_loans,
            'completed_loans': completed,
            'defaulted_loans': defaulted,
            'num_applications': len(self.applications)
        }

# Create lender
lender = DigitalLender("Digital Credit Co.")

print("Digital Lending Platform Simulation:")
print(f"Initial pool balance: ${lender.pool_balance:,.2f}")

# Simulate applications
applicants = [
    ("Alice", 50000, "Education", 75000, 720, 24),
    ("Bob", 100000, "Home Improvement", 90000, 680, 36),
    ("Charlie", 25000, "Medical", 55000, 650, 12),
    ("David", 150000, "Investment", 120000, 700, 48),
    ("Eve", 30000, "Small Business", 60000, 690, 24)
]

print("\n--- Loan Applications ---")
for applicant_id, amount, purpose, income, credit_score, term in applicants:
    print(f"\nApplicant: {applicant_id}")
    print(f"  Amount: ${amount:,}")
    print(f"  Purpose: {purpose}")
    disbursed = lender.apply_for_loan(applicant_id, amount, purpose, income, credit_score, term)
    if disbursed > 0:
        print(f"  Disbursed: ${disbursed:.2f}")

print("\n--- Platform Metrics ---")
metrics = lender.get_metrics()
for k, v in metrics.items():
    print(f"  {k}: {v}")

# ----------------------------------------------------------------
# PART B: DEFI LENDING SIMULATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART B: DeFi Lending Protocol Simulation")
print("-"*60)

class DeFiLendingPool:
    def __init__(self, name: str, asset: str):
        self.name = name
        self.asset = asset
        self.total_liquidity = 0
        self.total_borrowed = 0
        self.suppliers: Dict[str, float] = {}
        self.borrowers: Dict[str, Dict] = {}
        self.utilization_rate = 0
        self.base_rate = 0.02
        self.optimal_utilization = 0.8
        self.slope1 = 0.10  # Up to optimal
        self.slope2 = 0.50  # Above optimal
        self.transactions = []
    
    def deposit(self, user: str, amount: float) -> bool:
        self.total_liquidity += amount
        self.suppliers[user] = self.suppliers.get(user, 0) + amount
        self._update_interest_rate()
        self.transactions.append({
            'type': 'deposit',
            'user': user,
            'amount': amount,
            'timestamp': time.time()
        })
        print(f"Deposited {amount} {self.asset} into {self.name}")
        return True
    
    def borrow(self, user: str, amount: float, collateral: float) -> bool:
        # Over-collateralisation: 75% LTV
        max_borrow = collateral * 0.75
        if amount > max_borrow:
            print(f"Max borrow for collateral {collateral} is {max_borrow}")
            return False
        
        if self.total_liquidity - self.total_borrowed < amount:
            print("Insufficient liquidity")
            return False
        
        self.total_borrowed += amount
        self.borrowers[user] = {
            'amount': amount,
            'collateral': collateral,
            'timestamp': time.time(),
            'last_repayment': time.time()
        }
        self._update_interest_rate()
        self.transactions.append({
            'type': 'borrow',
            'user': user,
            'amount': amount,
            'collateral': collateral,
            'timestamp': time.time()
        })
        print(f"Borrowed {amount} {self.asset} with {collateral} collateral")
        return True
    
    def repay(self, user: str, amount: float) -> bool:
        if user not in self.borrowers:
            print("No outstanding loan")
            return False
        
        current_debt = self.borrowers[user]['amount']
        if amount > current_debt:
            amount = current_debt
        
        self.borrowers[user]['amount'] -= amount
        self.total_borrowed -= amount
        
        if self.borrowers[user]['amount'] <= 0:
            del self.borrowers[user]
        
        self._update_interest_rate()
        self.transactions.append({
            'type': 'repay',
            'user': user,
            'amount': amount,
            'timestamp': time.time()
        })
        print(f"Repaid {amount} {self.asset}")
        return True
    
    def _update_interest_rate(self):
        if self.total_liquidity == 0:
            self.utilization_rate = 0
        else:
            self.utilization_rate = self.total_borrowed / self.total_liquidity
        
        if self.utilization_rate < self.optimal_utilization:
            self.current_rate = self.base_rate + (self.utilization_rate / self.optimal_utilization) * self.slope1
        else:
            excess = (self.utilization_rate - self.optimal_utilization) / (1 - self.optimal_utilization)
            self.current_rate = self.base_rate + self.slope1 + excess * self.slope2
    
    def get_metrics(self) -> Dict:
        return {
            'name': self.name,
            'asset': self.asset,
            'total_liquidity': self.total_liquidity,
            'total_borrowed': self.total_borrowed,
            'utilization': self.utilization_rate,
            'interest_rate': self.current_rate,
            'num_suppliers': len(self.suppliers),
            'num_borrowers': len(self.borrowers)
        }

# Create DeFi lending pool
defi_pool = DeFiLendingPool("DeFi Credit Pool", "ETH")

print("\nDeFi Lending Pool Simulation:")
defi_pool.deposit("Lender1", 1000)
defi_pool.deposit("Lender2", 1500)
defi_pool.deposit("Lender3", 800)

print(f"\nPool liquidity: {defi_pool.total_liquidity} ETH")

# Borrowing
defi_pool.borrow("Borrower1", 500, 800)  # 500 ETH loan with 800 ETH collateral
defi_pool.borrow("Borrower2", 300, 500)

print("\n--- Interest Rate ---")
print(f"Utilization rate: {defi_pool.utilization_rate:.2%}")
print(f"Current interest rate: {defi_pool.current_rate:.2%}")

print("\n--- Metrics ---")
metrics = defi_pool.get_metrics()
for k, v in metrics.items():
    print(f"  {k}: {v}")

# ----------------------------------------------------------------
# PART C: CREDIT SCORING COMPARISON
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART C: Credit Scoring Models Comparison")
print("-"*60)

credit_comparison = pd.DataFrame({
    'Model': ['FICO Score', 'VantageScore', 'Alternative Data', 'On-chain Score'],
    'Data Source': ['Credit Bureaus', 'Credit Bureaus', 'Alternative', 'On-chain'],
    'Range': ['300-850', '300-850', 'Varies', '0-100'],
    'Speed': ['Days', 'Days', 'Real-time', 'Real-time'],
    'Privacy': ['Limited', 'Limited', 'Enhanced', 'High'],
    'Inclusion': ['Low', 'Low', 'High', 'Very High']
})

print(credit_comparison.to_string(index=False))

# ----------------------------------------------------------------
# PART D: LENDING RISK VISUALISATION
# -----------------------------------------------------------------

print("\n" + "-"*60)
print("PART D: Lending Risk Visualisation")
print("-"*60)

# Simulate risk metrics
risk_metrics = {
    'Metric': ['Default Rate', 'Delinquency Rate', 'Recovery Rate', 'NPL Ratio', 'Credit Loss'],
    'Traditional Lending': [2.5, 4.5, 40, 3.5, 1.5],
    'FinTech Lending': [3.0, 5.5, 35, 4.2, 2.0],
    'DeFi Lending': [1.5, 3.0, 50, 2.0, 0.8]  # Lower due to over-collateralisation
}

risk_df = pd.DataFrame(risk_metrics)
print(risk_df.to_string(index=False))

# Visualise
fig, ax = plt.subplots(figsize=(10, 5))
x = np.arange(len(risk_metrics['Metric']))
width = 0.25

ax.bar(x - width, risk_metrics['Traditional Lending'], width, label='Traditional', color='blue', alpha=0.7)
ax.bar(x, risk_metrics['FinTech Lending'], width, label='FinTech', color='orange', alpha=0.7)
ax.bar(x + width, risk_metrics['DeFi Lending'], width, label='DeFi', color='green', alpha=0.7)

ax.set_xlabel('Risk Metric')
ax.set_ylabel('Percentage (%)')
ax.set_title('Lending Risk Metrics by Type')
ax.set_xticks(x)
ax.set_xticklabels(risk_metrics['Metric'], rotation=45, ha='right')
ax.legend()
ax.grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('lending_risks.png', dpi=300, bbox_inches='tight')
plt.show()
print("Lending risk chart saved as 'lending_risks.png'")

# ----------------------------------------------------------------
# PART E: LENDING PRODUCT COMPARISON
# -----------------------------------------------------------------

print("\n" + "-"*60)
print("PART E: Digital Lending Product Comparison")
print("-"*60)

lending_products = pd.DataFrame({
    'Product': ['Personal Loan', 'Mortgage', 'SME Loan', 'P2P Loan', 'DeFi Loan'],
    'Platform': ['Neobank', 'Digital Bank', 'FinTech', 'P2P Platform', 'DeFi Protocol'],
    'Amount Range': ['$1K-$50K', '$50K-$2M', '$10K-$500K', '$1K-$100K', '$100-$1M+'],
    'Interest Rate': ['6-20%', '3-7%', '8-25%', '5-15%', '2-12%'],
    'Approval Time': ['Hours', 'Days', 'Hours-Days', 'Days', 'Seconds-Minutes'],
    'Collateral': ['Sometimes', 'Required', 'Often', 'Often', 'Required']
})

print(lending_products.to_string(index=False))

# ----------------------------------------------------------------
# PART F: SUMMARY AND RECOMMENDATIONS
# -----------------------------------------------------------------

print("\n" + "="*70)
print("PART F: Summary and Recommendations")
print("="*70)

print("""
Digital Lending and Credit – Key Takeaways:

1. Digital lending automates and enhances the lending process.
2. Models: Traditional, P2P, and DeFi lending.
3. Credit scoring uses traditional (FICO) or alternative (behavioural, on-chain) data.
4. DeFi lending requires over-collateralisation and algorithmic interest rates.
5. Flash loans enable uncollateralised borrowing within a single transaction.
6. Risks: credit, liquidity, smart contract, market, regulatory, operational.
7. Key metrics: default rate, delinquency, recovery, NPL ratio, credit loss.

Recommendations:
  - Use multiple data sources for comprehensive credit assessment.
  - Implement robust collateral management for DeFi lending.
  - Monitor risk metrics continuously.
  - Ensure regulatory compliance and KYC/AML.
  - Diversify loan portfolios across borrower types.
  - Consider insurance for large loan books.
  - Use smart contract audits for DeFi lending protocols.
""")