┌─────────────────────────────────────────────────────────────────────────────┐
│                    EMBEDDED FINANCE ECOSYSTEM                             │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    PLATFORM                                          │   │
│  │  (E-commerce, ride-sharing, SaaS, etc.)                            │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    BAAS PROVIDER                                    │   │
│  │  (Banking infrastructure and licences)                             │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    EMBEDDED FINANCE PRODUCTS                        │   │
│  │  Payments | Lending | Cards | Insurance | Investing                │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    END CUSTOMER                                     │   │
│  │  (Seamless financial services within the platform)                 │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                    BAAS BUSINESS MODEL                                    │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    BAAS PROVIDER (BANK)                             │   │
│  │  (Licences, infrastructure, compliance)                            │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    BAAS PLATFORM                                    │   │
│  │  (APIs, SDKs, white-label products)                                │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    BAAS CUSTOMERS                                  │   │
│  │  (Fintechs, neobanks, non-financial platforms)                     │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    END CUSTOMERS                                    │   │
│  │  (Consumers and businesses using BAAS-powered products)            │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                    BAAS TECHNOLOGY STACK                                  │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    BAAS API LAYER                                   │   │
│  │  Account APIs, Payment APIs, Card APIs, KYC APIs                   │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    CORE BANKING                                     │   │
│  │  Account management, transaction processing, ledger                │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    COMPLIANCE                                      │   │
│  │  KYC, AML, transaction monitoring, reporting                       │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    INFRASTRUCTURE                                  │   │
│  │  Cloud hosting, security, identity management                      │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    DATA & ANALYTICS                               │   │
│  │  Customer data, transaction data, analytics                        │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

# ===================================================================
# MODULE 7, LESSON 4: EMBEDDED FINANCE AND BAAS
# ===================================================================

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("EMBEDDED FINANCE AND BANKING-AS-A-SERVICE (BAAS)")
print("="*70)

# ----------------------------------------------------------------
# PART A: BAAS ECOSYSTEM MAPPING
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART A: BaaS Ecosystem Mapping")
print("-"*60)

baas_ecosystem = {
    "1. BaaS Providers (Banks)": {
        "Examples": ["Solarisbank", "Cross River Bank", "Marqeta", "Synapse"],
        "Role": "Provide banking licences, infrastructure, and compliance."
    },
    "2. BaaS Platform": {
        "Examples": ["Railsbank", "Unit", "Swan", "Finix"],
        "Role": "Provide API infrastructure and white-label products."
    },
    "3. BaaS Customers": {
        "Examples": ["Neobanks", "Fintechs", "E-commerce platforms", "SaaS companies"],
        "Role": "Build financial products using BaaS infrastructure."
    },
    "4. End Customers": {
        "Examples": ["Consumers", "Businesses"],
        "Role": "Use financial products within their preferred platforms."
    },
    "5. Regulators": {
        "Examples": ["FCA", "OCC", "EBA"],
        "Role": "Oversee and regulate BaaS activities."
    }
}

print("BaaS Ecosystem:")
for component, details in baas_ecosystem.items():
    print(f"\n{component}:")
    print(f"  Examples: {', '.join(details['Examples'])}")
    print(f"  Role: {details['Role']}")

# ----------------------------------------------------------------
# PART B: BAAS PRODUCT CATALOGUE
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART B: BaaS Product Catalogue")
print("-"*60)

baas_products = pd.DataFrame({
    'Product': [
        'White-label Current Accounts',
        'White-label Savings Accounts',
        'White-label Debit Cards',
        'White-label Credit Cards',
        'Payment Processing',
        'Lending Products',
        'KYC/AML Services',
        'Card Issuing'
    ],
    'Category': [
        'Accounts', 'Accounts', 'Cards', 'Cards',
        'Payments', 'Lending', 'Compliance', 'Cards'
    ],
    'Target Customers': [
        'Fintechs, Neobanks', 'Fintechs', 'Platforms', 'Fintechs',
        'E-commerce', 'Lending Platforms', 'All', 'Fintechs'
    ],
    'Revenue Model': [
        'Fee per account', 'Fee per account', 'Transaction fee', 'Transaction fee',
        'Transaction fee', 'Interest', 'Per-user fee', 'Per-card fee'
    ]
})

print("BaaS Product Catalogue:")
print(baas_products.to_string(index=False))

# ----------------------------------------------------------------
# PART C: SIMULATED BAAS PLATFORM
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART C: Simulated BaaS Platform")
print("-"*60)

class BaaSPlatform:
    """Simulate a BaaS platform for embedded finance."""
    
    def __init__(self):
        self.clients = {}
        self.accounts = {}
        self.transactions = {}
        self.cards = {}
        self.kyc_records = {}
    
    def onboard_client(self, client_id, name, type):
        """Onboard a BaaS client."""
        self.clients[client_id] = {
            'name': name,
            'type': type,
            'onboarded': datetime.now().isoformat(),
            'status': 'Active'
        }
        return client_id
    
    def create_account(self, client_id, customer_id, account_type, initial_balance=0):
        """Create an account for a client's customer."""
        if client_id not in self.clients:
            return {'error': 'Client not found'}
        
        account_id = f"ACC_{len(self.accounts) + 1:06d}"
        self.accounts[account_id] = {
            'client_id': client_id,
            'customer_id': customer_id,
            'type': account_type,
            'balance': initial_balance,
            'created': datetime.now().isoformat()
        }
        return account_id
    
    def issue_card(self, client_id, customer_id, card_type):
        """Issue a card for a client's customer."""
        if client_id not in self.clients:
            return {'error': 'Client not found'}
        
        card_id = f"CARD_{len(self.cards) + 1:06d}"
        self.cards[card_id] = {
            'client_id': client_id,
            'customer_id': customer_id,
            'type': card_type,
            'status': 'Active',
            'issued': datetime.now().isoformat()
        }
        return card_id
    
    def process_payment(self, client_id, from_account, to_account, amount):
        """Process a payment between accounts."""
        if client_id not in self.clients:
            return {'error': 'Client not found'}
        
        if from_account not in self.accounts:
            return {'error': 'From account not found'}
        if to_account not in self.accounts:
            return {'error': 'To account not found'}
        
        if self.accounts[from_account]['balance'] < amount:
            return {'error': 'Insufficient funds'}
        
        # Process payment
        self.accounts[from_account]['balance'] -= amount
        self.accounts[to_account]['balance'] += amount
        
        tx_id = f"TX_{len(self.transactions) + 1:06d}"
        self.transactions[tx_id] = {
            'client_id': client_id,
            'from_account': from_account,
            'to_account': to_account,
            'amount': amount,
            'timestamp': datetime.now().isoformat()
        }
        
        return {
            'transaction_id': tx_id,
            'status': 'Completed',
            'amount': amount
        }
    
    def verify_kyc(self, client_id, customer_id, verification_data):
        """Verify KYC for a customer."""
        if client_id not in self.clients:
            return {'error': 'Client not found'}
        
        # Simulate KYC verification
        is_verified = np.random.random() > 0.05
        status = 'Verified' if is_verified else 'Failed'
        
        self.kyc_records[customer_id] = {
            'client_id': client_id,
            'status': status,
            'verified_at': datetime.now().isoformat()
        }
        
        return {'customer_id': customer_id, 'status': status}
    
    def get_platform_stats(self):
        """Get platform statistics."""
        return {
            'clients': len(self.clients),
            'accounts': len(self.accounts),
            'cards': len(self.cards),
            'transactions': len(self.transactions),
            'kyc_records': len(self.kyc_records)
        }

# Create BaaS platform
baas = BaaSPlatform()

# Onboard clients
baas.onboard_client('CLIENT001', 'FinTechX', 'Neobank')
baas.onboard_client('CLIENT002', 'E-CommerceY', 'E-commerce')
baas.onboard_client('CLIENT003', 'SaaSZ', 'SaaS')

# Create accounts
baas.create_account('CLIENT001', 'CUST001', 'Current', 1000)
baas.create_account('CLIENT001', 'CUST002', 'Savings', 5000)
baas.create_account('CLIENT002', 'CUST003', 'Current', 2000)

# Issue cards
baas.issue_card('CLIENT001', 'CUST001', 'Debit')
baas.issue_card('CLIENT002', 'CUST003', 'Debit')

# Process payments
baas.process_payment('CLIENT001', 'ACC_000001', 'ACC_000002', 100)
baas.process_payment('CLIENT002', 'ACC_000003', 'ACC_000001', 50)

print("BaaS Platform Initialised:")
stats = baas.get_platform_stats()
for key, value in stats.items():
    print(f"  {key}: {value}")

# ----------------------------------------------------------------
# PART D: EMBEDDED FINANCE USE CASES
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART D: Embedded Finance Use Cases")
print("-"*60)

use_cases = pd.DataFrame({
    'Use Case': [
        'E-commerce BNPL',
        'SaaS Revenue Financing',
        'Ride-sharing Payments',
        'Healthcare Financing',
        'Retail Store Cards',
        'Platform Expense Cards',
        'Travel Insurance'
    ],
    'Platform Type': [
        'E-commerce', 'SaaS', 'Mobility', 'Healthcare', 'Retail', 'SaaS', 'Travel'
    ],
    'Product': [
        'BNPL', 'Revenue-based Financing', 'Payments', 'Medical Financing', 'Credit Cards', 'Expense Cards', 'Insurance'
    ],
    'BAAS Provider': [
        'FintechX', 'FintechX', 'Payment Provider', 'FintechX', 'FintechX', 'FintechX', 'Insurance Provider'
    ]
})

print("Embedded Finance Use Cases:")
print(use_cases.to_string(index=False))

# ----------------------------------------------------------------
# PART E: BAAS METRICS DASHBOARD
# ----------------------------------------------------------------

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

baas_metrics = pd.DataFrame({
    'Metric': [
        'BaaS Clients',
        'Accounts Created',
        'Cards Issued',
        'Transaction Volume',
        'KYC Verification Rate',
        'API Availability',
        'API Response Time',
        'Client Retention'
    ],
    'Current Value': [
        '25',
        '12,500',
        '8,200',
        '$50M/month',
        '95%',
        '99.8%',
        '120ms',
        '92%'
    ],
    'Target Value': [
        '50+',
        '25,000+',
        '15,000+',
        '$100M/month',
        '> 98%',
        '> 99.95%',
        '< 100ms',
        '> 95%'
    ],
    'Status': ['🟡', '🟡', '🟡', '🟡', '🟡', '🟡', '🟡', '🟡']
})

print("BaaS Metrics Dashboard:")
print(baas_metrics.to_string(index=False))

# ----------------------------------------------------------------
# PART F: BAAS ROADMAP
# ----------------------------------------------------------------

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

roadmap = {
    "Phase 1 (0-6 months) – Foundation": {
        "Focus": "Build BaaS foundation.",
        "Activities": [
            "Develop BaaS API platform.",
            "Obtain banking licences or partnerships.",
            "Build core banking infrastructure.",
            "Implement compliance and KYC."
        ],
        "Success Metrics": ["BaaS platform live", "5+ clients onboarded"]
    },
    "Phase 2 (6-12 months) – Scale": {
        "Focus": "Scale BaaS capabilities.",
        "Activities": [
            "Launch white-label accounts and cards.",
            "Expand product catalogue.",
            "Build partner ecosystem.",
            "Scale infrastructure."
        ],
        "Success Metrics": ["10+ clients", "1000+ accounts"]
    },
    "Phase 3 (12-24 months) – Expansion": {
        "Focus": "Expand BaaS products.",
        "Activities": [
            "Launch lending and credit products.",
            "Enable embedded finance for new verticals.",
            "Build developer platform.",
            "Expand geographically."
        ],
        "Success Metrics": ["New products launched", "Revenue > $10M"]
    },
    "Phase 4 (24+ months) – Leadership": {
        "Focus": "Industry-leading BaaS.",
        "Activities": [
            "Lead embedded finance innovation.",
            "Build global BaaS capabilities.",
            "Establish BaaS ecosystem.",
            "Achieve industry leadership."
        ],
        "Success Metrics": ["Industry-leading BaaS", "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: SUMMARY AND RECOMMENDATIONS
# ----------------------------------------------------------------

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

print("""
Embedded Finance and Banking-as-a-Service – Key Takeaways:

1. Embedded finance integrates financial services into non-financial platforms.
2. BaaS provides banking infrastructure and licences to non-bank businesses.
3. BaaS ecosystem: BaaS providers → BaaS platform → BaaS customers → end customers.
4. Key products: accounts, cards, payments, lending, compliance.
5. Use cases: e-commerce BNPL, SaaS revenue financing, ride-sharing payments.
6. Key metrics: clients, accounts, cards, transaction volume, KYC rate.
7. Roadmap: foundation → scale → expansion → leadership.

Recommendations:
  - Build BaaS API platform.
  - Obtain banking licences or partnerships.
  - Launch white-label accounts and cards.
  - Expand into lending and credit products.
  - Build partner ecosystem for embedded finance.
  - Scale infrastructure for growth.
""")

print("="*70)
print("END OF LESSON 4 – MODULE 7")
print("="*70)