┌─────────────────────────────────────────────────────────────────────────────┐
│                    STABLECOIN TYPES                                         │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  1. FIAT-BACKED STABLECOINS                                                 │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Backed 1:1 by fiat currency (USD, EUR)                           │   │
│  │ • Held in bank accounts by issuer                                  │   │
│  │ • Examples: USDC, USDT, EURC                                      │   │
│  │ • Pros: Simple, transparent (if audited)                          │   │
│  │ • Cons: Centralised, regulatory risk, counterparty risk          │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  2. CRYPTO-BACKED STABLECOINS                                               │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Backed by cryptocurrency collateral                              │   │
│  │ • Over-collateralised to absorb volatility                         │   │
│  │ • Examples: DAI, sUSD                                             │   │
│  │ • Pros: Decentralised, transparent                                 │   │
│  │ • Cons: Capital inefficient, liquidation risk                     │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  3. ALGORITHMIC STABLECOINS                                                 │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Maintain peg algorithmically without backing                     │   │
│  │ • Use supply/demand mechanisms                                     │   │
│  │ • Examples: UST (failed), FRAX, LUNA (failed)                    │   │
│  │ • Pros: Fully decentralised, capital efficient                    │   │
│  │ • Cons: Complex, death spiral risk, unproven                     │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  4. COMMODITY-BACKED STABLECOINS                                            │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Backed by physical commodities (gold, silver, oil)               │   │
│  │ • Examples: PAXG, XAUT                                             │   │
│  │ • Pros: Exposure to real assets                                    │   │
│  │ • Cons: Storage costs, centralised custody                        │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                    DAI STABLECOIN MECHANISM                                 │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  1. USER DEPOSITS COLLATERAL                                                │
│     ┌──────────────────────────────────────────────────────────────────┐    │
│     │ Deposit 1.5 ETH (value $3000) into Maker Vault                 │    │
│     │ Mint up to $2000 DAI (66% LTV)                                 │    │
│     └──────────────────────────────────────────────────────────────────┘    │
│                                    │                                        │
│                                    v                                        │
│  2. MAINTENANCE OF COLLATERAL RATIO                                        │
│     ┌──────────────────────────────────────────────────────────────────┐    │
│     │ Collateralisation Ratio = Collateral Value / DAI Minted        │    │
│     │ Minimum = 150%                                                 │    │
│     │ If ratio drops → liquidation                                   │    │
│     └──────────────────────────────────────────────────────────────────┘    │
│                                    │                                        │
│                                    v                                        │
│  3. REPAY LOAN AND UNLOCK COLLATERAL                                       │
│     ┌──────────────────────────────────────────────────────────────────┐    │
│     │ Repay DAI + Stability Fee (interest)                           │    │
│     │ Unlock ETH collateral                                           │    │
│     └──────────────────────────────────────────────────────────────────┘    │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                    STABLECOIN PAYMENT ECOSYSTEM                             │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  MERCHANT                      CONSUMER                                     │
│       │                            │                                        │
│       v                            v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    PAYMENT PROCESSOR                                  │   │
│  │  • Accepts stablecoin payments                                       │   │
│  │  • Converts to fiat (optional)                                      │   │
│  │  • Provides checkout interface                                      │   │
│  │  • Examples: BitPay, Coinbase Commerce                              │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    BLOCKCHAIN NETWORK                                 │   │
│  │  • Settlement layer                                                  │   │
│  │  • Stellar, Ethereum, Solana, etc.                                 │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    STABLECOIN ISSUER                                 │   │
│  │  • Mint and burn stablecoins                                        │   │
│  │  • Manage reserves                                                  │   │
│  │  • Ensure compliance                                                │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

# ===================================================================
# MODULE 2, LESSON 4: STABLECOINS AND PAYMENT SYSTEMS
# ===================================================================

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

print("="*70)
print("STABLECOINS AND PAYMENT SYSTEMS")
print("="*70)

# ----------------------------------------------------------------
# PART A: FIAT-BACKED STABLECOIN SIMULATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART A: Fiat-Backed Stablecoin Simulation")
print("-"*60)

class FiatBackedStablecoin:
    def __init__(self, name: str, symbol: str, peg_currency: str = "USD"):
        self.name = name
        self.symbol = symbol
        self.peg_currency = peg_currency
        self.reserves = 0
        self.supply = 0
        self.balances: Dict[str, float] = {}
        self.transactions = []
        self.is_collateralized = True
    
    def mint(self, user: str, amount: float, deposit: float) -> bool:
        """Mint stablecoins in exchange for fiat deposit."""
        if deposit < amount:
            print("Insufficient deposit")
            return False
        
        self.reserves += deposit
        self.supply += amount
        self.balances[user] = self.balances.get(user, 0) + amount
        
        self.transactions.append({
            'type': 'mint',
            'user': user,
            'amount': amount,
            'deposit': deposit,
            'timestamp': time.time()
        })
        print(f"Minted {amount} {self.symbol} for {user}")
        return True
    
    def burn(self, user: str, amount: float) -> Optional[float]:
        """Burn stablecoins and redeem fiat."""
        if self.balances.get(user, 0) < amount:
            print(f"Insufficient balance for {user}")
            return None
        
        # 1:1 redemption
        redemption = amount
        self.balances[user] -= amount
        self.supply -= amount
        self.reserves -= redemption
        
        self.transactions.append({
            'type': 'burn',
            'user': user,
            'amount': amount,
            'redemption': redemption,
            'timestamp': time.time()
        })
        print(f"Burned {amount} {self.symbol}, redeemed {redemption} {self.peg_currency}")
        return redemption
    
    def transfer(self, sender: str, recipient: str, amount: float) -> bool:
        if self.balances.get(sender, 0) < amount:
            print(f"Insufficient balance for {sender}")
            return False
        
        self.balances[sender] -= amount
        self.balances[recipient] = self.balances.get(recipient, 0) + amount
        
        self.transactions.append({
            'type': 'transfer',
            'from': sender,
            'to': recipient,
            'amount': amount,
            'timestamp': time.time()
        })
        print(f"Transferred {amount} {self.symbol} from {sender} to {recipient}")
        return True
    
    def get_balance(self, user: str) -> float:
        return self.balances.get(user, 0)
    
    def get_reserve_ratio(self) -> float:
        if self.supply == 0:
            return 1.0
        return self.reserves / self.supply
    
    def get_metrics(self) -> Dict:
        return {
            'name': self.name,
            'symbol': self.symbol,
            'supply': self.supply,
            'reserves': self.reserves,
            'reserve_ratio': self.get_reserve_ratio(),
            'num_holders': len([b for b in self.balances.values() if b > 0]),
            'total_transactions': len(self.transactions)
        }

# Create stablecoin
usdc = FiatBackedStablecoin("Digital Dollar", "USDD")

print("Stablecoin Simulation:")
usdc.mint("Alice", 1000, 1000)
usdc.mint("Bob", 500, 500)
usdc.mint("Charlie", 2000, 2000)

print("\n--- Transfers ---")
usdc.transfer("Alice", "Bob", 200)
usdc.transfer("Bob", "Charlie", 100)

print("\n--- Redemption ---")
usdc.burn("Charlie", 500)

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

# ----------------------------------------------------------------
# PART B: CRYPTO-BACKED STABLECOIN SIMULATION (DAI-style)
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART B: Crypto-Backed Stablecoin Simulation")
print("-"*60)

class CryptoBackedStablecoin:
    def __init__(self, name: str, symbol: str, collateral_asset: str = "ETH"):
        self.name = name
        self.symbol = symbol
        self.collateral_asset = collateral_asset
        self.vaults: Dict[str, Dict] = {}
        self.supply = 0
        self.balances: Dict[str, float] = {}
        self.price_oracle: Dict[str, float] = {collateral_asset: 2000}  # Price in USD
        self.liquidation_threshold = 0.75  # Max LTV
        self.stability_fee = 0.02  # 2% annual
        self.transactions = []
    
    def set_price(self, asset: str, price: float):
        self.price_oracle[asset] = price
    
    def get_collateral_value(self, asset: str, amount: float) -> float:
        return amount * self.price_oracle.get(asset, 0)
    
    def create_vault(self, user: str, collateral_amount: float, mint_amount: float) -> bool:
        # Check LTV
        collateral_value = self.get_collateral_value(self.collateral_asset, collateral_amount)
        ltv = mint_amount / collateral_value
        
        if ltv > self.liquidation_threshold:
            print(f"LTV {ltv:.2%} exceeds threshold {self.liquidation_threshold:.2%}")
            return False
        
        self.vaults[user] = {
            'collateral': collateral_amount,
            'debt': mint_amount,
            'created_at': time.time(),
            'ltv': ltv
        }
        self.supply += mint_amount
        self.balances[user] = self.balances.get(user, 0) + mint_amount
        
        self.transactions.append({
            'type': 'create_vault',
            'user': user,
            'collateral': collateral_amount,
            'minted': mint_amount,
            'ltv': ltv,
            'timestamp': time.time()
        })
        print(f"Created vault for {user}: {collateral_amount} {self.collateral_asset} collateral, minted {mint_amount} {self.symbol}")
        return True
    
    def repay(self, user: str, amount: float) -> bool:
        if user not in self.vaults:
            print("No vault found")
            return False
        if self.balances.get(user, 0) < amount:
            print("Insufficient balance")
            return False
        
        repayment = min(amount, self.vaults[user]['debt'])
        self.balances[user] -= repayment
        self.vaults[user]['debt'] -= repayment
        self.supply -= repayment
        
        self.transactions.append({
            'type': 'repay',
            'user': user,
            'amount': repayment,
            'timestamp': time.time()
        })
        print(f"Repaid {repayment} {self.symbol}")
        return True
    
    def check_liquidations(self) -> List[str]:
        """Check all vaults for liquidation risk."""
        liquidated = []
        for user, vault in self.vaults.items():
            collateral_value = self.get_collateral_value(self.collateral_asset, vault['collateral'])
            ltv = vault['debt'] / collateral_value if collateral_value > 0 else 1
            vault['ltv'] = ltv
            
            if ltv > self.liquidation_threshold:
                liquidated.append(user)
                # Liquidate: seize collateral, burn debt
                vault['collateral'] *= 0.9  # 10% penalty
                self.supply -= vault['debt']
                vault['debt'] = 0
                print(f"Liquidated vault for {user}")
        
        return liquidated
    
    def get_balance(self, user: str) -> float:
        return self.balances.get(user, 0)
    
    def get_metrics(self) -> Dict:
        total_collateral = sum(v['collateral'] for v in self.vaults.values())
        total_debt = sum(v['debt'] for v in self.vaults.values())
        avg_ltv = total_debt / (total_collateral * self.price_oracle.get(self.collateral_asset, 1)) if total_collateral > 0 else 0
        
        return {
            'name': self.name,
            'symbol': self.symbol,
            'supply': self.supply,
            'num_vaults': len(self.vaults),
            'total_collateral': total_collateral,
            'total_debt': total_debt,
            'avg_ltv': avg_ltv,
            'collateral_price': self.price_oracle.get(self.collateral_asset, 0)
        }

# Create stablecoin
dai = CryptoBackedStablecoin("Digital Reserve", "DRC")

print("\nCrypto-Backed Stablecoin Simulation:")
print("ETH Price: $2000")

# Create vaults
dai.create_vault("Alice", 1.5, 1500)  # 1.5 ETH collateral, mint 1500 DRC
dai.create_vault("Bob", 2.0, 2000)    # 2.0 ETH collateral, mint 2000 DRC

print(f"\nDRC Balances:")
print(f"Alice: {dai.get_balance('Alice')} DRC")
print(f"Bob: {dai.get_balance('Bob')} DRC")

# Simulate price drop
print("\n--- Price Drop ---")
dai.set_price("ETH", 1600)
print(f"ETH Price: $1600")

# Check liquidations
liquidated = dai.check_liquidations()
print(f"Liquidated vaults: {liquidated if liquidated else 'None'}")

# Repay some debt
dai.repay("Bob", 500)

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

# ----------------------------------------------------------------
# PART C: STABLECOIN COMPARISON DASHBOARD
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART C: Stablecoin Comparison Dashboard")
print("-"*60)

stablecoin_comparison = pd.DataFrame({
    'Stablecoin': ['USDC', 'USDT', 'DAI', 'BUSD', 'FRAX', 'PAXG'],
    'Type': ['Fiat-backed', 'Fiat-backed', 'Crypto-backed', 'Fiat-backed', 'Algorithmic', 'Commodity-backed'],
    'Underlying': ['USD', 'USD+', 'ETH/USDC', 'USD', 'USDC', 'Gold'],
    'Decentralisation': ['Low', 'Low', 'High', 'Low', 'Medium', 'Low'],
    'Transparency': ['High', 'Low', 'Very High', 'Medium', 'Medium', 'High'],
    'Audit Frequency': ['Monthly', 'Quarterly', 'Real-time', 'Monthly', 'Monthly', 'Monthly'],
    'Market Cap (B)': [30, 100, 5, 20, 1, 0.5]
})

print(stablecoin_comparison.to_string(index=False))

# Visualise market caps
fig, ax = plt.subplots(figsize=(10, 5))
colors = ['#2ecc71', '#3498db', '#f39c12', '#e74c3c', '#9b59b6', '#1abc9c']
ax.barh(stablecoin_comparison['Stablecoin'], stablecoin_comparison['Market Cap (B)'], color=colors, alpha=0.7)
ax.set_xlabel('Market Cap (Billion USD)')
ax.set_title('Stablecoin Market Cap Comparison')
ax.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig('stablecoin_market_cap.png', dpi=300, bbox_inches='tight')
plt.show()
print("Stablecoin market cap chart saved as 'stablecoin_market_cap.png'")

# ----------------------------------------------------------------
# PART D: PAYMENT SYSTEM WITH STABLECOINS
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART D: Payment System with Stablecoins")
print("-"*60)

class PaymentSystem:
    def __init__(self, name: str, stablecoin: FiatBackedStablecoin):
        self.name = name
        self.stablecoin = stablecoin
        self.merchants: Dict[str, Dict] = {}
        self.payments = []
        self.fee_rate = 0.005  # 0.5% processing fee
    
    def register_merchant(self, merchant_id: str, name: str, wallet_address: str):
        self.merchants[merchant_id] = {
            'name': name,
            'wallet': wallet_address,
            'total_volume': 0,
            'total_tx': 0
        }
        print(f"Merchant {name} registered")
    
    def process_payment(self, customer: str, merchant_id: str, amount: float) -> bool:
        if merchant_id not in self.merchants:
            print("Merchant not found")
            return False
        
        merchant = self.merchants[merchant_id]
        
        # Deduct fee
        fee = amount * self.fee_rate
        merchant_amount = amount - fee
        
        # Transfer from customer to merchant
        if self.stablecoin.transfer(customer, merchant['wallet'], merchant_amount):
            # Pay fee to system wallet (simulated)
            self.payments.append({
                'customer': customer,
                'merchant': merchant['name'],
                'amount': amount,
                'fee': fee,
                'merchant_amount': merchant_amount,
                'timestamp': time.time()
            })
            merchant['total_volume'] += merchant_amount
            merchant['total_tx'] += 1
            print(f"Payment processed: ${amount:.2f} (fee: ${fee:.2f})")
            return True
        return False
    
    def get_payment_stats(self) -> Dict:
        total_volume = sum(p['amount'] for p in self.payments)
        total_fees = sum(p['fee'] for p in self.payments)
        return {
            'total_payments': len(self.payments),
            'total_volume': total_volume,
            'total_fees': total_fees,
            'avg_payment': total_volume / len(self.payments) if self.payments else 0,
            'merchants': len(self.merchants)
        }

# Create payment system
usdc = FiatBackedStablecoin("Digital Dollar", "USDD")
# Pre-fund some users
usdc.mint("Alice", 5000, 5000)
usdc.mint("Bob", 10000, 10000)

payments = PaymentSystem("StablePay", usdc)

# Register merchants
payments.register_merchant("M001", "E-Shop", "0xMerchant1")
payments.register_merchant("M002", "FreelanceHub", "0xMerchant2")

print("\n--- Payments ---")
payments.process_payment("Alice", "M001", 250)
payments.process_payment("Bob", "M002", 750)
payments.process_payment("Alice", "M001", 100)

print("\n--- Payment Stats ---")
stats = payments.get_payment_stats()
for k, v in stats.items():
    print(f"  {k}: {v}")

# ----------------------------------------------------------------
# PART E: STABLECOIN RISK ANALYSIS
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART E: Stablecoin Risk Analysis")
print("-"*60)

risk_analysis = {
    "USDC": {
        "Type": "Fiat-backed",
        "Risks": ["Counterparty", "Regulatory", "Banking"],
        "Risk Score": 3,
        "Recommendation": "Low risk; use for payments and reserves"
    },
    "USDT": {
        "Type": "Fiat-backed",
        "Risks": ["Counterparty", "Reserve transparency", "Regulatory"],
        "Risk Score": 4,
        "Recommendation": "Use with caution; monitor transparency"
    },
    "DAI": {
        "Type": "Crypto-backed",
        "Risks": ["Collateral volatility", "Liquidation", "Oracle"],
        "Risk Score": 3,
        "Recommendation": "Use in DeFi; understand liquidation risks"
    },
    "FRAX": {
        "Type": "Algorithmic",
        "Risks": ["Algorithm failure", "De-peg", "Market sentiment"],
        "Risk Score": 5,
        "Recommendation": "High risk; limited use"
    },
    "UST (failed)": {
        "Type": "Algorithmic",
        "Risks": ["Death spiral", "Systemic failure"],
        "Risk Score": 9,
        "Recommendation": "Avoid; learn from collapse"
    }
}

for stablecoin, details in risk_analysis.items():
    print(f"\n{stablecoin.upper()}:")
    print(f"  Type: {details['Type']}")
    print(f"  Risks: {', '.join(details['Risks'])}")
    print(f"  Risk Score: {details['Risk Score']}/10")
    print(f"  Recommendation: {details['Recommendation']}")

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

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

print("""
Stablecoins and Payment Systems – Key Takeaways:

1. Stablecoins provide price stability for crypto transactions.
2. Types: fiat-backed, crypto-backed, algorithmic, commodity-backed.
3. Major stablecoins: USDC (transparent, regulated), USDT (largest), DAI (decentralised).
4. Fiat-backed: simple but centralised; crypto-backed: decentralised but capital inefficient.
5. Algorithmic stablecoins are risky (UST collapse is a cautionary tale).
6. Stablecoin payments offer speed, low cost, and programmability.
7. Risks: de-peg, counterparty, regulatory, collateral, algorithmic.

Recommendations:
  - Use audited, transparent stablecoins for payments.
  - Understand the backing mechanism before using.
  - Diversify stablecoin holdings across types.
  - Monitor regulatory developments.
  - Consider insurance for large stablecoin holdings.
  - Avoid algorithmic stablecoins with unproven mechanisms.
  - Keep up with de-pegging events and market conditions.
""")