┌─────────────────────────────────────────────────────────────────────────────┐
│                    FUTURE PAYMENTS LANDSCAPE                              │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    CBDCS                                            │   │
│  │  Central Bank Digital Currencies – government-issued digital money  │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    INSTANT PAYMENTS                                 │   │
│  │  Real-time, 24/7 payments (FedNow, UPI, SEPA Instant)              │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    PROGRAMMABLE MONEY                               │   │
│  │  Smart contracts, conditional payments, automated transfers         │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    EMBEDDED PAYMENTS                                │   │
│  │  Payments integrated into platforms (e-commerce, mobility)          │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    CRYPTO PAYMENTS                                  │   │
│  │  Stablecoins, cryptocurrencies, DeFi payments                      │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

# ===================================================================
# MODULE 9, LESSON 5: THE FUTURE OF PAYMENTS
# ===================================================================

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from datetime import datetime, timedelta
import warnings
warnings.filterwarnings('ignore')

print("="*70)
print("THE FUTURE OF PAYMENTS – CBDCS, INSTANT PAYMENTS, AND PROGRAMMABLE MONEY")
print("="*70)

# ----------------------------------------------------------------
# PART A: PAYMENT LANDSCAPE EVOLUTION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART A: Payment Landscape Evolution")
print("-"*60)

payment_evolution = pd.DataFrame({
    'Era': ['Traditional', 'Electronic', 'Digital', 'Real-Time', 'Programmable'],
    'Key Innovations': [
        'Cash, Cheques',
        'Cards, ATMs',
        'Online, Mobile',
        'Instant, 24/7',
        'Smart, Conditional'
    ],
    'Speed': ['Days', 'Days', 'Minutes', 'Seconds', 'Instant'],
    'Availability': ['Business hours', 'Limited', '24/7', '24/7', '24/7'],
    'Key Players': ['Banks', 'Banks + Networks', 'Banks + Fintechs', 'Fintechs + Banks', 'Platforms + AI']
})

print("Payment Landscape Evolution:")
print(payment_evolution.to_string(index=False))

# ----------------------------------------------------------------
# PART B: CBDC READINESS ASSESSMENT
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART B: CBDC Readiness Assessment")
print("-"*60)

cbdc_readiness = pd.DataFrame({
    'Dimension': ['Technology', 'Regulatory', 'Infrastructure', 'Customer Readiness', 'Risk Management'],
    'Current Score (1-5)': [3, 2, 3, 3, 2],
    'Target Score (1-5)': [5, 5, 5, 5, 5],
    'Gap': [2, 3, 2, 2, 3]
})

print("CBDC Readiness Assessment:")
print(cbdc_readiness.to_string(index=False))

# Visualise
fig, ax = plt.subplots(figsize=(10, 6))
dimensions = cbdc_readiness['Dimension'].tolist()
current = cbdc_readiness['Current Score (1-5)'].tolist()
target = cbdc_readiness['Target Score (1-5)'].tolist()

x = np.arange(len(dimensions))
width = 0.35

ax.barh(x - width/2, current, width, label='Current', color='blue', alpha=0.7)
ax.barh(x + width/2, target, width, label='Target', color='green', alpha=0.7)

ax.set_yticks(x)
ax.set_yticklabels(dimensions)
ax.set_xlabel('Maturity Score (1-5)')
ax.set_title('CBDC Readiness Assessment')
ax.legend()
ax.grid(True, alpha=0.3, axis='x')

plt.tight_layout()
plt.savefig('cbdc_readiness.png', dpi=300, bbox_inches='tight')
plt.show()
print("CBDC readiness visualisation saved as 'cbdc_readiness.png'")

# ----------------------------------------------------------------
# PART C: INSTANT PAYMENT ADOPTION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART C: Instant Payment Adoption")
print("-"*60)

instant_payments = pd.DataFrame({
    'System': ['FedNow (US)', 'UPI (India)', 'Faster Payments (UK)', 'SEPA Instant (EU)', 'PIX (Brazil)'],
    'Year Launched': [2023, 2016, 2008, 2017, 2020],
    'Volume (M/month)': [10, 10000, 200, 500, 3000],
    'Growth (%)': [50, 30, 15, 20, 40],
    'Status': ['Growing', 'Mature', 'Mature', 'Growing', 'Growing']
})

print("Instant Payment Systems:")
print(instant_payments.to_string(index=False))

# Visualise
fig, ax = plt.subplots(figsize=(10, 6))
instant_payments_sorted = instant_payments.sort_values('Volume (M/month)', ascending=True)
ax.barh(instant_payments_sorted['System'], instant_payments_sorted['Volume (M/month)'], color='teal', alpha=0.7)
ax.set_xlabel('Volume (M/month)')
ax.set_title('Instant Payment Volume by System')
ax.grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('instant_payment_volume.png', dpi=300, bbox_inches='tight')
plt.show()
print("Instant payment volume visualisation saved as 'instant_payment_volume.png'")

# ----------------------------------------------------------------
# PART D: PROGRAMMABLE MONEY USE CASES
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART D: Programmable Money Use Cases")
print("-"*60)

programmable_use_cases = pd.DataFrame({
    'Use Case': [
        'Supply Chain Payments',
        'Subscription Payments',
        'Escrow Payments',
        'Government Benefits',
        'Insurance Claims',
        'Payroll Automation'
    ],
    'Description': [
        'Payment upon delivery confirmation',
        'Automated recurring payments',
        'Payment upon condition fulfilment',
        'Targeted, conditional payments',
        'Automated claim payments',
        'Automated salary payments'
    ],
    'Benefit': [
        'Reduced risk',
        'Convenience',
        'Trust',
        'Efficiency',
        'Speed',
        'Efficiency'
    ],
    'Maturity': ['Growing', 'Mature', 'Growing', 'Emerging', 'Growing', 'Mature']
})

print("Programmable Money Use Cases:")
print(programmable_use_cases.to_string(index=False))

# ----------------------------------------------------------------
# PART E: PAYMENTS INNOVATION METRICS
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART E: Payments Innovation Metrics Dashboard")
print("-"*60)

payments_metrics = pd.DataFrame({
    'Metric': [
        'Instant Payment Adoption',
        'CBDC Readiness Score',
        'Programmable Money Capability',
        'Embedded Payment Integration',
        'Crypto Payment Adoption',
        'Real-Time Payment Volume',
        'Payment Innovation Index',
        'Cross-Border Payment Speed'
    ],
    'Current Value': [
        '35%',
        '2.5/5',
        '2/5',
        '25%',
        '5%',
        '15%',
        '3/5',
        '2-3 days'
    ],
    'Target Value': [
        '> 80%',
        '> 4.5/5',
        '> 4/5',
        '> 60%',
        '> 25%',
        '> 40%',
        '> 4.5/5',
        '< 1 hour'
    ],
    'Status': ['🔴', '🔴', '🔴', '🔴', '🔴', '🔴', '🔴', '🔴']
})

print("Payments Innovation Metrics Dashboard:")
print(payments_metrics.to_string(index=False))

# ----------------------------------------------------------------
# PART F: PAYMENTS INNOVATION ROADMAP
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART F: Payments Innovation Roadmap")
print("-"*60)

roadmap = {
    "Phase 1 (0-12 months) – Foundation": {
        "Focus": "Build payments innovation foundation.",
        "Activities": [
            "Integrate instant payment systems.",
            "Assess CBDC readiness.",
            "Build programmable money capabilities.",
            "Develop embedded payment strategy."
        ],
        "Success Metrics": ["Instant payment integration", "CBDC readiness > 3.0"]
    },
    "Phase 2 (12-24 months) – Scale": {
        "Focus": "Scale payments innovation.",
        "Activities": [
            "Scale instant payment adoption.",
            "Launch programmable money products.",
            "Implement embedded payments.",
            "Build crypto payment capabilities."
        ],
        "Success Metrics": ["Instant payment adoption > 50%", "Programmable money products launched"]
    },
    "Phase 3 (24-36 months) – Advanced": {
        "Focus": "Advanced payments innovation.",
        "Activities": [
            "Launch CBDC integration.",
            "Scale programmable money.",
            "Implement cross-border instant payments.",
            "Achieve payments leadership."
        ],
        "Success Metrics": ["CBDC integration", "Cross-border instant payments"]
    },
    "Phase 4 (36+ months) – Leadership": {
        "Focus": "Industry-leading payments.",
        "Activities": [
            "Lead payments innovation.",
            "Build global payments capabilities.",
            "Achieve industry leadership.",
            "Continuous improvement."
        ],
        "Success Metrics": ["Industry-leading payments", "Continuous innovation"]
    }
}

for phase, details in roadmap.items():
    print(f"\n{phase}:")
    print(f"  Focus: {details['Focus']}")
    print("  Activities:")
    for activity in details['Activities']:
        print(f"    • {activity}")
    print("  Success Metrics:")
    for metric in details['Success Metrics']:
        print(f"    • {metric}")

# ----------------------------------------------------------------
# PART G: SIMULATED CBDC TRANSACTION FLOW
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART G: Simulated CBDC Transaction Flow")
print("-"*60)

class CBDCTransaction:
    """Simulate a CBDC transaction flow."""
    
    def __init__(self):
        self.transactions = []
        self.central_bank_ledger = {}
    
    def issue_cbdc(self, customer_id, amount):
        """Issue CBDC to a customer."""
        if customer_id not in self.central_bank_ledger:
            self.central_bank_ledger[customer_id] = 0
        self.central_bank_ledger[customer_id] += amount
        return {
            'type': 'Issue',
            'customer': customer_id,
            'amount': amount,
            'balance': self.central_bank_ledger[customer_id]
        }
    
    def transfer_cbdc(self, from_customer, to_customer, amount):
        """Transfer CBDC between customers."""
        if from_customer not in self.central_bank_ledger:
            return {'error': 'Sender not found'}
        if to_customer not in self.central_bank_ledger:
            self.central_bank_ledger[to_customer] = 0
        
        if self.central_bank_ledger[from_customer] < amount:
            return {'error': 'Insufficient balance'}
        
        self.central_bank_ledger[from_customer] -= amount
        self.central_bank_ledger[to_customer] += amount
        
        transaction = {
            'type': 'Transfer',
            'from': from_customer,
            'to': to_customer,
            'amount': amount,
            'timestamp': datetime.now().isoformat()
        }
        self.transactions.append(transaction)
        return transaction
    
    def program_cbdc(self, customer_id, amount, condition):
        """Program a CBDC with a condition."""
        if customer_id not in self.central_bank_ledger:
            return {'error': 'Customer not found'}
        
        if self.central_bank_ledger[customer_id] < amount:
            return {'error': 'Insufficient balance'}
        
        # Simulate programming logic
        programmed = {
            'type': 'Programmed',
            'customer': customer_id,
            'amount': amount,
            'condition': condition,
            'status': 'Active',
            'timestamp': datetime.now().isoformat()
        }
        self.transactions.append(programmed)
        return programmed
    
    def execute_programmed(self, customer_id, condition):
        """Execute a programmed CBDC transaction."""
        # Find programmed CBDC
        for tx in self.transactions:
            if tx.get('type') == 'Programmed' and tx['customer'] == customer_id and tx['condition'] == condition:
                # Execute
                tx['status'] = 'Executed'
                self.central_bank_ledger[customer_id] -= tx['amount']
                return {
                    'status': 'Executed',
                    'amount': tx['amount'],
                    'condition': condition
                }
        return {'error': 'No matching programmed CBDC found'}

# Test CBDC simulation
cbdc = CBDCTransaction()

# Issue CBDC
cbdc.issue_cbdc('CUST001', 1000)
cbdc.issue_cbdc('CUST002', 500)
print("CBDC Issued:")
print(f"  Customer 1: {cbdc.central_bank_ledger['CUST001']}")
print(f"  Customer 2: {cbdc.central_bank_ledger['CUST002']}")

# Transfer CBDC
cbdc.transfer_cbdc('CUST001', 'CUST002', 200)
print("\nCBDC Transfer:")
print(f"  Customer 1: {cbdc.central_bank_ledger['CUST001']}")
print(f"  Customer 2: {cbdc.central_bank_ledger['CUST002']}")

# Program CBDC
cbdc.program_cbdc('CUST002', 100, 'Delivery Confirmation')
print("\nCBDC Programmed:")
print(f"  Customer 2: {cbdc.central_bank_ledger['CUST002']}")

# Execute programmed CBDC
result = cbdc.execute_programmed('CUST002', 'Delivery Confirmation')
print("\nProgrammed CBDC Executed:")
print(f"  Result: {result}")

# ----------------------------------------------------------------
# PART H: SUMMARY AND RECOMMENDATIONS
# ----------------------------------------------------------------

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

print("""
The Future of Payments – Key Takeaways:

1. Payments are evolving from cash to programmable money.
2. CBDCs are digital currencies issued by central banks (retail, wholesale, hybrid).
3. Instant payments enable real-time, 24/7/365 transactions.
4. Programmable money enables conditional, automated, and smart payments.
5. Embedded payments integrate payments into platforms.
6. Crypto payments (stablecoins) enable fast, low-cost cross-border payments.
7. Key metrics: instant payment adoption, CBDC readiness, programmable money capability.
8. Roadmap: foundation → scale → advanced → leadership.

Recommendations:
  - Integrate instant payment systems.
  - Assess CBDC readiness and prepare for integration.
  - Build programmable money capabilities.
  - Develop embedded payment products.
  - Monitor crypto payment developments.
  - Continuously innovate payment products.
""")

print("="*70)
print("END OF LESSON 5 – MODULE 9")
print("="*70)