# ===================================================================
# MODULE 10, LESSON 7: DIGITAL BANKING ECOSYSTEMS & PLATFORM ECONOMICS
# ===================================================================

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

print("="*70)
print("BANKING PLATFORM ECOSYSTEM – PARTNER ONBOARDING & REVENUE SHARING")
print("="*70)

# ----------------------------------------------------------------
# PART A: PARTNER ECOSYSTEM DEFINITION
# ----------------------------------------------------------------
print("\n" + "-"*60)
print("PART A: Partner Ecosystem Catalog")
print("-"*60)

# Define partner types and categories
partners = pd.DataFrame({
    'partner_id': [f'P{str(i).zfill(3)}' for i in range(1, 16)],
    'partner_name': [
        'Stripe', 'Adyen', 'Revolut Business', 'LendingClub', 'Plaid',
        'Zapier', 'Shopify Payments', 'Square', 'Klarna', 'Affirm',
        'TripAdvisor', 'Booking.com', 'Uber', 'DoorDash', 'Spotify'
    ],
    'category': [
        'Payments', 'Payments', 'Business Banking', 'Lending', 'Data Aggregation',
        'Automation', 'E-commerce', 'Payments', 'Buy Now Pay Later', 'Buy Now Pay Later',
        'Travel', 'Travel', 'Transport', 'Food Delivery', 'Entertainment'
    ],
    'type': [
        'Financial', 'Financial', 'Financial', 'Financial', 'Financial',
        'Non-Financial', 'Non-Financial', 'Financial', 'Financial', 'Financial',
        'Non-Financial', 'Non-Financial', 'Non-Financial', 'Non-Financial', 'Non-Financial'
    ],
    'integration_status': [
        'Active', 'Active', 'Pilot', 'Active', 'Active',
        'Active', 'Pilot', 'Active', 'Active', 'Active',
        'Onboarding', 'Onboarding', 'Active', 'Pilot', 'Active'
    ],
    'revenue_share_pct': [
        2.5, 2.8, 3.0, 1.8, 2.0,
        3.5, 2.0, 2.3, 3.2, 3.0,
        4.0, 4.5, 3.8, 3.2, 2.5
    ],
    'monthly_transactions': np.random.randint(1000, 50000, 15),
    'avg_transaction_value': np.random.uniform(20, 200, 15).round(2),
    'customer_rating': np.random.uniform(3.5, 4.9, 15).round(1)
})

print("Ecosystem Partner Catalog:")
print(partners.to_string(index=False))

# ----------------------------------------------------------------
# PART B: PLATFORM REVENUE CALCULATION
# ----------------------------------------------------------------
print("\n" + "-"*60)
print("PART B: Platform Revenue & Partner Payouts")
print("-"*60)

class PlatformRevenueEngine:
    """
    Simulates revenue generation and distribution across partners.
    """
    def __init__(self, partners_df):
        self.partners_df = partners_df.copy()
        
    def calculate_monthly_revenue(self):
        """Calculate total platform revenue and partner payouts."""
        
        # Calculate partner transaction volume
        self.partners_df['monthly_volume'] = (
            self.partners_df['monthly_transactions'] * 
            self.partners_df['avg_transaction_value']
        )
        
        # Calculate platform revenue share from partner
        self.partners_df['platform_revenue'] = (
            self.partners_df['monthly_volume'] * 
            (self.partners_df['revenue_share_pct'] / 100)
        )
        
        # Partner receives the rest
        self.partners_df['partner_payout'] = (
            self.partners_df['monthly_volume'] - 
            self.partners_df['platform_revenue']
        )
        
        # Total platform revenue
        total_platform_revenue = self.partners_df['platform_revenue'].sum()
        
        # Revenue by category
        category_revenue = self.partners_df.groupby('category')['platform_revenue'].sum().reset_index()
        category_revenue.columns = ['category', 'total_revenue']
        category_revenue = category_revenue.sort_values('total_revenue', ascending=False)
        
        return {
            'total_platform_revenue': total_platform_revenue,
            'partner_details': self.partners_df,
            'category_revenue': category_revenue
        }
    
    def print_revenue_summary(self):
        """Print revenue dashboard."""
        results = self.calculate_monthly_revenue()
        total = results['total_platform_revenue']
        category = results['category_revenue']
        
        print(f"\n💰 Monthly Platform Revenue: ${total:,.2f}")
        print(f"💰 Annualized Platform Revenue: ${total * 12:,.2f}")
        
        print("\nRevenue by Category:")
        for idx, row in category.iterrows():
            print(f"  {row['category']}: ${row['total_revenue']:,.2f} ({row['total_revenue']/total*100:.1f}%)")
        
        print("\nTop 5 Revenue-Generating Partners:")
        top_partners = results['partner_details'].nlargest(5, 'platform_revenue')
        for idx, row in top_partners.iterrows():
            print(f"  {row['partner_name']}: ${row['platform_revenue']:,.2f}")
        
        return results

# Instantiate and run
engine = PlatformRevenueEngine(partners)
revenue_results = engine.print_revenue_summary()

# ----------------------------------------------------------------
# PART C: ECOSYSTEM GROWTH SIMULATION (Network Effects)
# ----------------------------------------------------------------
print("\n" + "-"*60)
print("PART C: Ecosystem Growth Simulation (Network Effects)")
print("-"*60)

def simulate_ecosystem_growth(months=24, initial_users=10000, partner_growth_rate=0.15):
    """
    Simulates ecosystem growth with network effects.
    """
    user_base = [initial_users]
    partner_count = [len(partners)]
    revenue = [revenue_results['total_platform_revenue']]
    
    # Monthly growth rates (increase as network effects kick in)
    growth_rates = [0.05]  # Initial growth
    
    for month in range(1, months):
        # Network effect multiplier - more partners attract more users
        network_multiplier = 1 + (partner_count[-1] - len(partners)) / len(partners) * 0.1
        
        # User growth with network effects
        new_users = user_base[-1] * (0.02 + 0.03 * network_multiplier)
        user_base.append(user_base[-1] + new_users)
        
        # Partner growth (new partners join due to user base)
        new_partners = max(1, int(partner_count[-1] * partner_growth_rate * (user_base[-1] / initial_users) ** 0.5))
        partner_count.append(partner_count[-1] + new_partners)
        
        # Revenue growth (driven by users and partners)
        revenue_growth = revenue[-1] * (1 + 0.02 + 0.03 * network_multiplier)
        revenue.append(revenue_growth)
    
    return pd.DataFrame({
        'Month': list(range(1, months + 1)),
        'Users': user_base,
        'Partners': partner_count,
        'Revenue': revenue
    })

# Run simulation
growth_data = simulate_ecosystem_growth(months=36)
print("\nEcosystem Growth Projection (36 Months):")
print(growth_data[['Month', 'Users', 'Partners', 'Revenue']].head(12).to_string(index=False))

# Visualize growth
fig, axes = plt.subplots(1, 3, figsize=(15, 5))

# User Growth
axes[0].plot(growth_data['Month'], growth_data['Users'], 'b-', linewidth=2)
axes[0].set_xlabel('Months')
axes[0].set_ylabel('Active Users')
axes[0].set_title('User Base Growth (Network Effects)')
axes[0].grid(True, alpha=0.3)

# Partner Growth
axes[1].plot(growth_data['Month'], growth_data['Partners'], 'g-', linewidth=2)
axes[1].set_xlabel('Months')
axes[1].set_ylabel('Number of Partners')
axes[1].set_title('Partner Ecosystem Growth')
axes[1].grid(True, alpha=0.3)

# Revenue Growth
axes[2].plot(growth_data['Month'], growth_data['Revenue'], 'r-', linewidth=2)
axes[2].set_xlabel('Months')
axes[2].set_ylabel('Monthly Revenue ($)')
axes[2].set_title('Platform Revenue Growth')
axes[2].grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('ecosystem_growth.png', dpi=300, bbox_inches='tight')
plt.show()
print("\nEcosystem growth visualization saved as 'ecosystem_growth.png'")

# ----------------------------------------------------------------
# PART D: PARTNER ONBOARDING AUTOMATION
# ----------------------------------------------------------------
print("\n" + "-"*60)
print("PART D: Automated Partner Onboarding Workflow")
print("-"*60)

class PartnerOnboarding:
    """
    Simulates an automated partner onboarding workflow with scoring.
    """
    def __init__(self, existing_partners):
        self.existing_partners = existing_partners
        
    def score_potential_partner(self, company_name, category, revenue_share_requested, 
                               estimated_volume, integration_complexity):
        """
        Scores a potential partner based on multiple criteria.
        """
        # Criteria scoring (1-100)
        score = 0
        
        # Category attractiveness
        category_weights = {
            'Payments': 90,
            'Lending': 85,
            'Buy Now Pay Later': 85,
            'Data Aggregation': 80,
            'E-commerce': 75,
            'Travel': 70,
            'Transport': 65,
            'Entertainment': 60,
            'Food Delivery': 65,
            'Business Banking': 80,
            'Automation': 70
        }
        category_score = category_weights.get(category, 50)
        score += category_score * 0.25
        
        # Revenue share attractiveness (lower is better for platform)
        share_score = max(0, 100 - (revenue_share_requested * 10))
        score += share_score * 0.20
        
        # Revenue potential
        revenue_potential = estimated_volume * (revenue_share_requested / 100)
        potential_score = min(100, revenue_potential / 10000 * 100)
        score += potential_score * 0.30
        
        # Integration complexity (lower is better)
        complexity_score = max(0, 100 - (integration_complexity * 10))
        score += complexity_score * 0.15
        
        # Market saturation (penalize if similar partners exist)
        similar_partners = self.existing_partners[
            self.existing_partners['category'] == category
        ]
        saturation_penalty = min(20, len(similar_partners) * 5)
        score -= saturation_penalty * 0.10
        
        # Determine decision
        if score >= 70:
            decision = 'Approved'
            priority = 'High' if score >= 85 else 'Medium'
        elif score >= 50:
            decision = 'Conditional Approval'
            priority = 'Low'
        else:
            decision = 'Rejected'
            priority = 'N/A'
        
        return {
            'company': company_name,
            'category': category,
            'score': round(score, 1),
            'decision': decision,
            'priority': priority,
            'reasoning': f"Score: {score:.1f}/100. Category score: {category_score}, Revenue potential: {potential_score:.1f}"
        }

# Simulate partner onboarding
onboarding = PartnerOnboarding(partners)

potential_partners = [
    {'name': 'ClimateFinTech', 'category': 'Lending', 'share': 2.5, 'volume': 5000000, 'complexity': 4},
    {'name': 'HealthWallet', 'category': 'Payments', 'share': 3.5, 'volume': 2000000, 'complexity': 6},
    {'name': 'GreenEnergy Solutions', 'category': 'Business Banking', 'share': 2.0, 'volume': 8000000, 'complexity': 5},
    {'name': 'SocialMedia Pay', 'category': 'Payments', 'share': 4.0, 'volume': 3000000, 'complexity': 8}
]

print("Partner Onboarding Assessment:")
for partner in potential_partners:
    result = onboarding.score_potential_partner(
        partner['name'],
        partner['category'],
        partner['share'],
        partner['volume'],
        partner['complexity']
    )
    print(f"\n  {result['company']}:")
    print(f"    Decision: {result['decision']} (Priority: {result['priority']})")
    print(f"    Score: {result['score']}")
    print(f"    Reasoning: {result['reasoning']}")

# ----------------------------------------------------------------
# SECTION 5: SUMMARY FOR THE DATA PRACTITIONER
# ----------------------------------------------------------------
print("\n" + "="*70)
print("LESSON 7 SUMMARY FOR THE DATA PRACTITIONER")
print("="*70)

print("""
1. Banking is evolving from linear product providers to platform ecosystem orchestrators.
2. Platform Banks generate value through network effects – more partners attract more users, and vice versa.
3. Key architecture layers: Core Banking → API Gateway → Marketplace → Customer Experience.
4. Revenue models shift from interest income to transaction fees, subscriptions, and data monetization.
5. Data Practitioner's role includes:
   - Building the data infrastructure for partner onboarding and revenue analytics.
   - Implementing APIs for seamless partner integration.
   - Analyzing ecosystem performance metrics (growth rates, revenue distribution, network effects).
   - Ensuring data security and compliance in open ecosystems.
6. Action: Map your organization's partner ecosystem and identify gaps in your API capabilities.
""")

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