┌─────────────────────────────────────────────────────────────────────────────┐
│                        PAYMENTS VALUE CHAIN                               │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                         CUSTOMER                                    │   │
│  │  (Payer/Receiver)                                                   │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                      PAYMENT INITIATION                             │   │
│  │  (Payment request)                                                  │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    PAYMENT PROCESSING                               │   │
│  │  (Validation, authorisation, routing)                               │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                      CLEARING & SETTLEMENT                          │   │
│  │  (Funds transfer between financial institutions)                    │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    PAYMENT RECEIPT                                 │   │
│  │  (Funds received, confirmation)                                    │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                    REAL-TIME PAYMENTS INFRASTRUCTURE                       │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌─────────────┐    ┌─────────────┐    ┌─────────────┐                    │
│  │  Payer's    │    │  Payment    │    │  Payee's    │                    │
│  │  Bank       │ ←→ │  System     │ ←→ │  Bank       │                    │
│  │  (Sender)   │    │  (RTP)      │    │  (Receiver) │                    │
│  └─────────────┘    └─────────────┘    └─────────────┘                    │
│        │                  │                  │                             │
│        v                  v                  v                             │
│  ┌─────────────┐    ┌─────────────┐    ┌─────────────┐                    │
│  │  Customer   │    │  Real-Time  │    │  Customer   │                    │
│  │  (Payer)    │    │  Clearing   │    │  (Payee)    │                    │
│  └─────────────┘    └─────────────┘    └─────────────┘                    │
│                                                                             │
│  Key Features:                                                              │
│  • 24/7 availability                                                        │
│  • Instant settlement (seconds)                                            │
│  • Confirmation to both parties                                            │
│  • Rich data capabilities                                                  │
│  • ISO 20022 messaging                                                    │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                    OPEN BANKING PAYMENT FLOW                              │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌─────────────┐    ┌─────────────┐    ┌─────────────┐                    │
│  │  Customer   │    │  Merchant   │    │  Payment    │                    │
│  │  (Payer)    │ ─→ │  (Payee)    │ ─→ │  Initiation │                    │
│  └─────────────┘    └─────────────┘    │  Service    │                    │
│                                         │  (TPP)      │                    │
│                                         └─────────────┘                    │
│                                               │                             │
│                                               v                             │
│                                         ┌─────────────┐                    │
│                                         │  Customer's │                    │
│                                         │  Bank       │                    │
│                                         │  (API)      │                    │
│                                         └─────────────┘                    │
│                                               │                             │
│                                               v                             │
│                                         ┌─────────────┐                    │
│                                         │  Payment    │                    │
│                                         │  Received   │                    │
│                                         └─────────────┘                    │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

# ===================================================================
# MODULE 1, LESSON 5: DIGITAL PAYMENTS AND TRANSACTIONS
# ===================================================================

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("DIGITAL PAYMENTS AND TRANSACTIONS")
print("="*70)

# ----------------------------------------------------------------
# PART A: PAYMENT METHOD ADOPTION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART A: Payment Method Adoption")
print("-"*60)

# Define payment methods and adoption data
payment_methods = ['Cash', 'Cards', 'Digital Wallets', 'P2P Apps', 'Real-Time Payments', 
                   'Cryptocurrency', 'BNPL', 'Open Banking Payments']
adoption_2024 = [30, 85, 55, 45, 35, 15, 25, 10]
adoption_2028 = [20, 80, 70, 60, 50, 30, 40, 25]
growth_rate = [(adoption_2028[i] - adoption_2024[i]) / adoption_2024[i] * 100 for i in range(len(adoption_2024))]

payment_df = pd.DataFrame({
    'Payment Method': payment_methods,
    'Adoption 2024 (%)': adoption_2024,
    'Adoption 2028 (%)': adoption_2028,
    'Growth (%)': growth_rate
}).sort_values('Growth (%)', ascending=False)

print("Payment Method Adoption Forecast:")
print(payment_df.to_string(index=False))

# Visualise
fig, ax = plt.subplots(figsize=(12, 8))
x = np.arange(len(payment_methods))
width = 0.35

bars1 = ax.bar(x - width/2, adoption_2024, width, label='2024', color='blue', alpha=0.7)
bars2 = ax.bar(x + width/2, adoption_2028, width, label='2028', color='green', alpha=0.7)

ax.set_xlabel('Payment Method')
ax.set_ylabel('Adoption (%)')
ax.set_title('Payment Method Adoption: 2024 vs 2028')
ax.set_xticks(x)
ax.set_xticklabels(payment_methods, rotation=45, ha='right')
ax.legend()
ax.grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('payment_adoption.png', dpi=300, bbox_inches='tight')
plt.show()
print("Payment adoption visualisation saved as 'payment_adoption.png'")

# ----------------------------------------------------------------
# PART B: TRANSACTION VOLUME ANALYSIS
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART B: Transaction Volume Analysis")
print("-"*60)

# Simulate transaction data
np.random.seed(42)
n_transactions = 10000

transaction_data = pd.DataFrame({
    'transaction_id': range(1, n_transactions+1),
    'amount': np.random.lognormal(3.5, 1.2, n_transactions).clip(1, 10000),
    'date': [datetime(2024, 1, 1) + timedelta(days=np.random.randint(0, 365)) for _ in range(n_transactions)],
    'payment_method': np.random.choice(payment_methods, n_transactions, 
                                      p=[0.10, 0.30, 0.20, 0.12, 0.08, 0.03, 0.07, 0.05]),
    'merchant_category': np.random.choice(['Retail', 'E-commerce', 'Food & Beverage', 
                                           'Travel', 'Utilities', 'Healthcare', 'Entertainment'], n_transactions),
    'status': np.random.choice(['Completed', 'Pending', 'Failed', 'Refunded'], n_transactions, 
                              p=[0.85, 0.05, 0.05, 0.05])
})

print(f"Generated {n_transactions} transactions.")
print(transaction_data.head())

# Summary by payment method
method_summary = transaction_data.groupby('payment_method').agg({
    'amount': ['count', 'sum', 'mean', 'std']
}).round(2)
method_summary.columns = ['Count', 'Total Amount', 'Average Amount', 'Std Amount']
method_summary = method_summary.sort_values('Total Amount', ascending=False)

print("\nPayment Method Summary:")
print(method_summary)

# Visualise volume by method
fig, axes = plt.subplots(1, 2, figsize=(14, 6))

ax = axes[0]
method_counts = transaction_data['payment_method'].value_counts()
ax.pie(method_counts.values, labels=method_counts.index, autopct='%1.1f%%', startangle=90)
ax.set_title('Transaction Volume by Payment Method')

ax = axes[1]
method_amounts = transaction_data.groupby('payment_method')['amount'].sum().sort_values(ascending=False)
ax.bar(method_amounts.index, method_amounts.values, color='teal', alpha=0.7)
ax.set_xlabel('Payment Method')
ax.set_ylabel('Total Amount ($)')
ax.set_title('Total Transaction Value by Payment Method')
ax.tick_params(axis='x', rotation=45)

plt.tight_layout()
plt.savefig('transaction_analysis.png', dpi=300, bbox_inches='tight')
plt.show()
print("Transaction analysis visualisation saved as 'transaction_analysis.png'")

# ----------------------------------------------------------------
# PART C: PAYMENT PERFORMANCE METRICS
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART C: Payment Performance Metrics")
print("-"*60)

# Calculate performance metrics
total_transactions = len(transaction_data)
completed = len(transaction_data[transaction_data['status'] == 'Completed'])
pending = len(transaction_data[transaction_data['status'] == 'Pending'])
failed = len(transaction_data[transaction_data['status'] == 'Failed'])
refunded = len(transaction_data[transaction_data['status'] == 'Refunded'])

performance_metrics = {
    'Metric': [
        'Total Transactions',
        'Success Rate',
        'Failure Rate',
        'Refund Rate',
        'Average Transaction Value',
        'Total Transaction Value',
        'Peak Hour'
    ],
    'Value': [
        f"{total_transactions:,}",
        f"{completed/total_transactions*100:.2f}%",
        f"{failed/total_transactions*100:.2f}%",
        f"{refunded/total_transactions*100:.2f}%",
        f"${transaction_data['amount'].mean():.2f}",
        f"${transaction_data['amount'].sum():,.2f}",
        f"{transaction_data['date'].dt.hour.mode()[0]}:00"
    ]
}

performance_df = pd.DataFrame(performance_metrics)
print("Payment Performance Metrics:")
print(performance_df.to_string(index=False))

# ----------------------------------------------------------------
# PART D: PAYMENT COST ANALYSIS
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART D: Payment Cost Analysis")
print("-"*60)

# Define cost structures for different payment methods
payment_costs = {
    'Cash': {'Fixed': 0.05, 'Variable': 0.005, 'Interchange': 0},
    'Cards': {'Fixed': 0.10, 'Variable': 0.015, 'Interchange': 0.015},
    'Digital Wallets': {'Fixed': 0.08, 'Variable': 0.01, 'Interchange': 0.01},
    'P2P Apps': {'Fixed': 0.05, 'Variable': 0.005, 'Interchange': 0},
    'Real-Time Payments': {'Fixed': 0.03, 'Variable': 0.002, 'Interchange': 0},
    'Cryptocurrency': {'Fixed': 0.50, 'Variable': 0.02, 'Interchange': 0},
    'BNPL': {'Fixed': 0.15, 'Variable': 0.025, 'Interchange': 0.02},
    'Open Banking Payments': {'Fixed': 0.02, 'Variable': 0.001, 'Interchange': 0}
}

# Calculate costs for sample transactions
sample_transactions = transaction_data.sample(1000)
sample_transactions['fixed_cost'] = sample_transactions['payment_method'].map(lambda x: payment_costs[x]['Fixed'])
sample_transactions['variable_cost'] = sample_transactions['amount'] * sample_transactions['payment_method'].map(lambda x: payment_costs[x]['Variable'])
sample_transactions['interchange'] = sample_transactions['amount'] * sample_transactions['payment_method'].map(lambda x: payment_costs[x]['Interchange'])
sample_transactions['total_cost'] = sample_transactions['fixed_cost'] + sample_transactions['variable_cost'] + sample_transactions['interchange']
sample_transactions['cost_percentage'] = sample_transactions['total_cost'] / sample_transactions['amount'] * 100

cost_summary = sample_transactions.groupby('payment_method').agg({
    'amount': ['mean', 'sum'],
    'total_cost': ['sum', 'mean'],
    'cost_percentage': 'mean'
}).round(4)
cost_summary.columns = ['Avg Amount', 'Total Amount', 'Total Cost', 'Avg Cost', 'Avg Cost %']

print("Payment Cost Analysis:")
print(cost_summary.sort_values('Total Cost', ascending=False))

# ----------------------------------------------------------------
# PART E: REAL-TIME PAYMENT SCENARIO
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART E: Real-Time Payment Scenario")
print("-"*60)

# Simulate a real-time payment flow
def simulate_rtp_flow(payer, payee, amount, reference):
    """Simulate a real-time payment flow."""
    steps = [
        {"step": "1. Payment Initiation", "status": "✅ Completed", "timestamp": "00:00:00"},
        {"step": "2. Authentication (SCA)", "status": "✅ Completed", "timestamp": "00:00:01"},
        {"step": "3. Authorisation", "status": "✅ Completed", "timestamp": "00:00:02"},
        {"step": "4. Validation", "status": "✅ Completed", "timestamp": "00:00:03"},
        {"step": "5. Settlement", "status": "✅ Completed", "timestamp": "00:00:04"},
        {"step": "6. Confirmation", "status": "✅ Completed", "timestamp": "00:00:05"},
    ]
    
    return {
        "payer": payer,
        "payee": payee,
        "amount": amount,
        "reference": reference,
        "status": "Settled",
        "timestamp": "00:00:05",
        "steps": steps
    }

rtp_result = simulate_rtp_flow(
    payer="Customer: John Doe",
    payee="Merchant: TechStore",
    amount=249.99,
    reference="INV-2024-001"
)

print("Real-Time Payment Flow:")
print(f"Payer: {rtp_result['payer']}")
print(f"Payee: {rtp_result['payee']}")
print(f"Amount: ${rtp_result['amount']:.2f}")
print(f"Reference: {rtp_result['reference']}")
print(f"Status: {rtp_result['status']}")
print(f"Timestamp: {rtp_result['timestamp']}")
print("\nStep-by-Step:")
for step in rtp_result['steps']:
    print(f"  {step['step']} - {step['status']} at {step['timestamp']}")

# ----------------------------------------------------------------
# PART F: PAYMENT STRATEGY RECOMMENDATIONS
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART F: Payment Strategy Recommendations")
print("-"*60)

strategies = {
    "1. Embrace Real-Time Payments": {
        "Action": "Integrate with FedNow/instant payment schemes.",
        "Priority": "High",
        "Timeline": "Now"
    },
    "2. Digital Wallet Integration": {
        "Action": "Enable Apple Pay, Google Pay, and merchant wallets.",
        "Priority": "High",
        "Timeline": "Now"
    },
    "3. Open Banking Payments": {
        "Action": "Implement payment initiation and AIS APIs.",
        "Priority": "High",
        "Timeline": "6 months"
    },
    "4. BNPL Integration": {
        "Action": "Partner with BNPL providers.",
        "Priority": "Medium",
        "Timeline": "12 months"
    },
    "5. Blockchain/Crypto": {
        "Action": "Explore stablecoin and CBDC integration.",
        "Priority": "Medium",
        "Timeline": "18 months"
    },
    "6. Fraud Prevention": {
        "Action": "Implement AI-driven fraud detection.",
        "Priority": "High",
        "Timeline": "Now"
    },
    "7. Payment Analytics": {
        "Action": "Build real-time payment analytics dashboard.",
        "Priority": "Medium",
        "Timeline": "6 months"
    }
}

print("Payment Strategy Recommendations:")
for strategy, details in strategies.items():
    print(f"\n{strategy}:")
    print(f"  Action: {details['Action']}")
    print(f"  Priority: {details['Priority']}")
    print(f"  Timeline: {details['Timeline']}")

# ----------------------------------------------------------------
# PART G: SUMMARY AND RECOMMENDATIONS
# ----------------------------------------------------------------

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

print("""
Digital Payments – Key Takeaways:

1. Payments have evolved from cash to real-time, digital payments.
2. Key payment types: cards, digital wallets, P2P, real-time, crypto, BNPL.
3. Payments infrastructure includes gateways, processors, card networks, and clearing houses.
4. Open banking enables payment initiation and account information sharing.
5. Emerging technologies include blockchain, CBDCs, and invisible payments.
6. Regulatory landscape includes PSD2, SCA, AML/KYC, and data protection.
7. Payment strategy must balance innovation, cost, and compliance.

Recommendations:
  - Prioritise real-time payments and digital wallet integration.
  - Implement open banking payment initiation.
  - Invest in AI-powered fraud detection.
  - Build payment analytics capabilities.
  - Explore BNPL and cryptocurrency opportunities.
  - Ensure regulatory compliance (SCA, AML/KYC).
""")

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