┌─────────────────────────────────────────────────────────────────────────────┐
│                    THE SUPPLY CHAIN FINANCING GAP                          │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  BUYER (Large Corporation)                                                 │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │  • Needs goods                                                       │   │
│  │  • Has cash                                                         │   │
│  │  • Wants to extend payment terms (e.g., 90 days)                    │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    THE GAP                                           │   │
│  │  • Supplier needs cash now                                          │   │
│  │  • Buyer wants to delay payment                                     │   │
│  │  • Traditional financing is expensive/slow                          │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  SUPPLIER (SME)                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │  • Delivers goods                                                    │   │
│  │  • Needs cash for operations                                        │   │
│  │  • Cannot wait 90 days for payment                                  │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  Blockchain Solution:                                                       │
│  • Digital invoice tokenisation                                            │
│  • Smart contract for automated payment                                    │
│  • Transparent supply chain visibility                                     │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                    BLOCKCHAIN BENEFITS IN SCF                               │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    TRANSPARENCY                                      │   │
│  │  All parties can view the status of invoices and payments.          │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    TRUST                                              │   │
│  │  Immutable records reduce fraud and disputes.                       │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    AUTOMATION                                        │   │
│  │  Smart contracts execute payments automatically.                   │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    EFFICIENCY                                        │   │
│  │  Reduced processing time and costs.                                 │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    FINANCIAL INCLUSION                               │   │
│  │  SMEs gain access to affordable financing.                          │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

# ===================================================================
# MODULE 3, LESSON 1: SUPPLY CHAIN FINANCE
# ===================================================================

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

print("="*70)
print("SUPPLY CHAIN FINANCE – BLOCKCHAIN APPLICATIONS")
print("="*70)

# ----------------------------------------------------------------
# PART A: SUPPLY CHAIN DATA GENERATION AND ANALYSIS
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART A: Supply Chain Data Generation and Analysis")
print("-"*60)

class SupplyChainDataGenerator:
    """
    Generate realistic supply chain transaction data.
    """
    def __init__(self):
        self.suppliers = [
            "Supplier_A", "Supplier_B", "Supplier_C", "Supplier_D", 
            "Supplier_E", "Supplier_F", "Supplier_G", "Supplier_H"
        ]
        self.buyers = [
            "Buyer_X", "Buyer_Y", "Buyer_Z", "Buyer_W"
        ]
        self.products = [
            "Electronics", "Textiles", "Chemicals", "Food_Products",
            "Pharmaceuticals", "Automotive", "Construction", "Paper"
        ]
        self.payment_terms = [30, 45, 60, 90]  # days
        self.invoice_values = [10000, 25000, 50000, 100000, 250000, 500000]
    
    def generate_invoice_data(self, num_invoices: int = 1000) -> pd.DataFrame:
        """
        Generate simulated invoice data.
        """
        data = []
        for i in range(num_invoices):
            invoice_date = datetime.now() - timedelta(days=random.randint(1, 180))
            payment_term = random.choice(self.payment_terms)
            due_date = invoice_date + timedelta(days=payment_term)
            value = random.choice(self.invoice_values) * random.uniform(0.8, 1.2)
            
            data.append({
                'invoice_id': f'INV-{i+1:06d}',
                'supplier': random.choice(self.suppliers),
                'buyer': random.choice(self.buyers),
                'product': random.choice(self.products),
                'value': round(value, 2),
                'invoice_date': invoice_date,
                'payment_term': payment_term,
                'due_date': due_date,
                'status': random.choices(
                    ['pending', 'approved', 'paid', 'disputed'],
                    weights=[0.3, 0.4, 0.2, 0.1]
                )[0],
                'discount_offered': random.choice([0, 0.01, 0.02, 0.03, 0.05])
            })
        
        return pd.DataFrame(data)

# Generate data
data_gen = SupplyChainDataGenerator()
invoice_data = data_gen.generate_invoice_data(1000)

print(f"Generated {len(invoice_data)} invoices")
print("\nSample Invoice Data:")
print(invoice_data.head(10).to_string(index=False))

# ----------------------------------------------------------------
# PART B: SUPPLY CHAIN FINANCE METRICS
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART B: Supply Chain Finance Metrics")
print("-"*60)

class SupplyChainAnalytics:
    """
    Analytics for supply chain financing.
    """
    def __init__(self, df: pd.DataFrame):
        self.df = df
        self.calculate_metrics()
    
    def calculate_metrics(self):
        """Calculate key supply chain finance metrics."""
        # Days Sales Outstanding (DSO)
        self.df['days_outstanding'] = (pd.Timestamp.now() - self.df['due_date']).dt.days
        self.df['days_outstanding'] = self.df['days_outstanding'].clip(lower=0)
        
        # Payment performance
        self.df['paid_on_time'] = (self.df['days_outstanding'] <= 0) & (self.df['status'] == 'paid')
        
        # Discount value
        self.df['discount_value'] = self.df['value'] * self.df['discount_offered']
        
        # Financing need (invoices not yet paid)
        self.df['financing_need'] = np.where(
            self.df['status'].isin(['pending', 'approved']),
            self.df['value'] - self.df['discount_value'],
            0
        )
    
    def get_summary_metrics(self) -> Dict:
        """Get summary metrics."""
        total_invoices = len(self.df)
        total_value = self.df['value'].sum()
        total_financing = self.df['financing_need'].sum()
        avg_days_outstanding = self.df['days_outstanding'].mean()
        on_time_rate = self.df['paid_on_time'].mean()
        
        return {
            'Total Invoices': total_invoices,
            'Total Value': f"${total_value:,.2f}",
            'Total Financing Need': f"${total_financing:,.2f}",
            'Average Days Outstanding': f"{avg_days_outstanding:.1f}",
            'On-Time Payment Rate': f"{on_time_rate:.1%}",
            'Potential Savings from Discounts': f"${self.df['discount_value'].sum():,.2f}"
        }
    
    def analyze_by_supplier(self) -> pd.DataFrame:
        """Analyse supplier performance."""
        return self.df.groupby('supplier').agg({
            'invoice_id': 'count',
            'value': 'sum',
            'financing_need': 'sum',
            'days_outstanding': 'mean',
            'paid_on_time': 'mean'
        }).rename(columns={
            'invoice_id': 'invoice_count',
            'value': 'total_value',
            'financing_need': 'financing_need',
            'days_outstanding': 'avg_days_outstanding',
            'paid_on_time': 'on_time_payment_rate'
        }).round(2)
    
    def analyze_by_buyer(self) -> pd.DataFrame:
        """Analyse buyer payment patterns."""
        return self.df.groupby('buyer').agg({
            'invoice_id': 'count',
            'value': 'sum',
            'days_outstanding': 'mean',
            'paid_on_time': 'mean'
        }).rename(columns={
            'invoice_id': 'invoice_count',
            'value': 'total_value',
            'days_outstanding': 'avg_days_outstanding',
            'paid_on_time': 'on_time_payment_rate'
        }).round(2)
    
    def analyze_by_product(self) -> pd.DataFrame:
        """Analyse product category financing needs."""
        return self.df.groupby('product').agg({
            'invoice_id': 'count',
            'value': 'sum',
            'financing_need': 'sum'
        }).rename(columns={
            'invoice_id': 'invoice_count',
            'value': 'total_value',
            'financing_need': 'financing_need'
        }).round(2)

# Calculate analytics
analytics = SupplyChainAnalytics(invoice_data)

# Display summary metrics
summary = analytics.get_summary_metrics()
print("\nSupply Chain Finance Summary Metrics:")
for key, value in summary.items():
    print(f"  {key}: {value}")

# ----------------------------------------------------------------
# PART C: VISUALISE SUPPLY CHAIN DATA
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART C: Supply Chain Visualisation")
print("-"*60)

# Create visualisations
fig, axes = plt.subplots(2, 2, figsize=(14, 10))

# 1. Financing need by supplier
ax1 = axes[0, 0]
supplier_metrics = analytics.analyze_by_supplier()
top_suppliers = supplier_metrics.nlargest(5, 'financing_need')
ax1.bar(top_suppliers.index, top_suppliers['financing_need'], color='teal', alpha=0.7)
ax1.set_title('Top 5 Suppliers by Financing Need')
ax1.set_ylabel('Financing Need ($)')
ax1.set_xlabel('Supplier')
ax1.grid(True, alpha=0.3)

# 2. Average days outstanding by buyer
ax2 = axes[0, 1]
buyer_metrics = analytics.analyze_by_buyer()
ax2.barh(buyer_metrics.index, buyer_metrics['avg_days_outstanding'], color='orange', alpha=0.7)
ax2.set_title('Average Days Outstanding by Buyer')
ax2.set_xlabel('Days Outstanding')
ax2.set_ylabel('Buyer')
ax2.grid(True, alpha=0.3)

# 3. On-time payment rate by buyer
ax3 = axes[1, 0]
ax3.bar(buyer_metrics.index, buyer_metrics['on_time_payment_rate'], color='green', alpha=0.7)
ax3.set_title('On-Time Payment Rate by Buyer')
ax3.set_ylabel('On-Time Rate')
ax3.set_xlabel('Buyer')
ax3.axhline(y=buyer_metrics['on_time_payment_rate'].mean(), color='red', linestyle='--', label='Average')
ax3.legend()
ax3.grid(True, alpha=0.3)

# 4. Product category financing need
ax4 = axes[1, 1]
product_metrics = analytics.analyze_by_product()
top_products = product_metrics.nlargest(5, 'financing_need')
ax4.pie(top_products['financing_need'], labels=top_products.index, autopct='%1.1f%%', startangle=90)
ax4.set_title('Financing Need by Product Category')

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

# ----------------------------------------------------------------
# PART D: INVOICE FINANCING SIMULATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART D: Invoice Financing Simulation")
print("-"*60)

class InvoiceFinancingPlatform:
    """
    Simulate an invoice financing platform with blockchain features.
    """
    def __init__(self, discount_rate: float = 0.05):
        self.discount_rate = discount_rate
        self.invoices = []
        self.funded_invoices = []
        self.profit = 0
    
    def add_invoice(self, supplier: str, buyer: str, amount: float, due_date: datetime, discount_offered: float = 0.0):
        invoice = {
            'id': f"INV-{len(self.invoices)+1:06d}",
            'supplier': supplier,
            'buyer': buyer,
            'amount': amount,
            'due_date': due_date,
            'discount_offered': discount_offered,
            'status': 'available',
            'days_to_maturity': (due_date - datetime.now()).days
        }
        self.invoices.append(invoice)
        return invoice['id']
    
    def finance_invoice(self, invoice_id: str) -> Dict:
        """Finance an invoice (like a blockchain-based factoring)."""
        invoice = next((inv for inv in self.invoices if inv['id'] == invoice_id), None)
        if not invoice or invoice['status'] != 'available':
            return {'success': False, 'message': 'Invoice not available'}
        
        # Calculate financing amount
        days_to_maturity = max(0, invoice['days_to_maturity'])
        financing_fee = invoice['amount'] * self.discount_rate * (days_to_maturity / 365)
        financing_amount = invoice['amount'] - financing_fee
        
        # Apply supplier discount if offered
        if invoice['discount_offered'] > 0:
            financing_amount = financing_amount * (1 - invoice['discount_offered'])
        
        # Update invoice
        invoice['status'] = 'funded'
        invoice['financing_amount'] = financing_amount
        invoice['financing_fee'] = financing_fee
        invoice['financed_date'] = datetime.now()
        
        self.funded_invoices.append(invoice)
        self.profit += financing_fee
        
        return {
            'success': True,
            'invoice_id': invoice_id,
            'financing_amount': financing_amount,
            'fee': financing_fee,
            'supplier': invoice['supplier'],
            'buyer': invoice['buyer']
        }
    
    def get_platform_metrics(self) -> Dict:
        total_available = sum(inv['amount'] for inv in self.invoices if inv['status'] == 'available')
        total_funded = sum(inv['amount'] for inv in self.funded_invoices)
        avg_fee_rate = self.profit / total_funded if total_funded > 0 else 0
        
        return {
            'Total Invoices Available': len([i for i in self.invoices if i['status'] == 'available']),
            'Total Funded': len(self.funded_invoices),
            'Available Financing': f"${total_available:,.2f}",
            'Funded Amount': f"${total_funded:,.2f}",
            'Platform Profit': f"${self.profit:,.2f}",
            'Average Fee Rate': f"{avg_fee_rate:.2%}"
        }

# Create platform
platform = InvoiceFinancingPlatform(discount_rate=0.08)

# Add invoices from data
for _, row in invoice_data.head(20).iterrows():
    platform.add_invoice(
        supplier=row['supplier'],
        buyer=row['buyer'],
        amount=row['value'],
        due_date=row['due_date'],
        discount_offered=row['discount_offered']
    )

# Finance some invoices
print("Invoice Financing Simulation:")
for inv_id in platform.invoices[:10]:
    result = platform.finance_invoice(inv_id['id'])
    if result['success']:
        print(f"\nFinanced Invoice {result['invoice_id']}:")
        print(f"  Supplier: {result['supplier']}")
        print(f"  Buyer: {result['buyer']}")
        print(f"  Amount: ${result['financing_amount']:,.2f}")
        print(f"  Fee: ${result['fee']:,.2f}")

# Platform metrics
print("\nPlatform Metrics:")
metrics = platform.get_platform_metrics()
for key, value in metrics.items():
    print(f"  {key}: {value}")

# ----------------------------------------------------------------
# PART E: BLOCKCHAIN BENEFIT ANALYSIS
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART E: Blockchain Benefit Analysis for Supply Chain Finance")
print("-"*60)

benefit_analysis = pd.DataFrame({
    'Benefit': [
        'Reduced Fraud Risk',
        'Faster Settlement',
        'Lower Costs',
        'Increased Transparency',
        'Better Trust',
        'Automated Payments',
        'SME Access to Capital',
        'Supply Chain Visibility'
    ],
    'Traditional Impact': [
        'High fraud risk',
        '5-10 days',
        '3-5% fees',
        'Limited visibility',
        'Low trust',
        'Manual process',
        'Limited access',
        'Poor visibility'
    ],
    'Blockchain Impact': [
        'Near-zero fraud risk',
        '1-2 hours',
        '1-2% fees',
        'Full visibility',
        'High trust',
        'Smart contracts',
        'Broad access',
        'Real-time visibility'
    ],
    'Improvement (%)': [90, 80, 60, 95, 85, 95, 80, 90]
})

print(benefit_analysis.to_string(index=False))

# Visualise improvements
fig, ax = plt.subplots(figsize=(10, 6))
ax.barh(benefit_analysis['Benefit'], benefit_analysis['Improvement (%)'], color='blue', alpha=0.7)
ax.set_xlabel('Improvement (%)')
ax.set_title('Blockchain Impact on Supply Chain Finance')
ax.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig('blockchain_benefits.png', dpi=300, bbox_inches='tight')
plt.show()
print("Blockchain benefits chart saved as 'blockchain_benefits.png'")

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

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

print("""
Supply Chain Finance with Blockchain – Key Takeaways:

1. Supply chain finance optimises cash flow between buyers and suppliers.
2. Blockchain addresses key SCF challenges: fraud, trust, transparency, automation.
3. Key applications: invoice financing, inventory financing, dynamic discounting.
4. Smart contracts automate payment execution and reduce disputes.
5. Key players: IBM Food Trust, TradeLens, VeChain, Komgo.
6. Benefits: reduced fraud, faster settlement, lower costs, SME access.
7. On-chain visibility enables real-time tracking and analytics.

Recommendations:
  - Start with a pilot project on a single supply chain segment.
  - Focus on high-impact use cases (high-value goods, complex supply chains).
  - Ensure all participants can access the blockchain platform.
  - Integrate with existing ERP and financial systems.
  - Consider regulatory and compliance requirements.
  - Build governance and dispute resolution mechanisms.
  - Use smart contracts for automatic payment execution.
""")