┌─────────────────────────────────────────────────────────────────────────────┐
│                    INSURANCE INDUSTRY CHALLENGES                            │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    FRAUD                                             │   │
│  │  Insurance fraud costs $80B+ annually globally.                      │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    MANUAL PROCESSES                                  │   │
│  │  Claims processing is paper-heavy and slow.                         │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    LACK OF TRANSPARENCY                              │   │
│  │  Policyholders have limited visibility into claims.                 │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    HIGH COSTS                                        │   │
│  │  Administrative and operational costs are significant.              │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    DATA SILOS                                       │   │
│  │  Data is fragmented across different systems.                       │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                    PARAMETRIC INSURANCE FLOW                                │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  1. POLICY CREATION                                                         │
│     ┌──────────────────────────────────────────────────────────────────┐    │
│     │ • Smart contract defines parameters (e.g., rainfall > 50mm)     │    │
│     │ • Policy terms on-chain                                          │    │
│     │ • Premium paid                                                   │    │
│     └──────────────────────────────────────────────────────────────────┘    │
│                                    │                                        │
│                                    v                                        │
│  2. DATA FEED (Oracle)                                                     │
│     ┌──────────────────────────────────────────────────────────────────┐    │
│     │ • Weather data from trusted oracle                              │    │
│     │ • IoT sensor data                                               │    │
│     │ • Flight data for delays                                        │    │
│     └──────────────────────────────────────────────────────────────────┘    │
│                                    │                                        │
│                                    v                                        │
│  3. TRIGGER EVALUATION                                                     │
│     ┌──────────────────────────────────────────────────────────────────┐    │
│     │ • Smart contract evaluates condition                           │    │
│     │ • If parameter threshold met → trigger payout                  │    │
│     └──────────────────────────────────────────────────────────────────┘    │
│                                    │                                        │
│                                    v                                        │
│  4. AUTOMATIC PAYOUT                                                       │
│     ┌──────────────────────────────────────────────────────────────────┐    │
│     │ • Funds automatically transferred to policyholder              │    │
│     │ • No claims form required                                      │    │
│     │ • Instant settlement                                           │    │
│     └──────────────────────────────────────────────────────────────────┘    │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

# ===================================================================
# MODULE 3, LESSON 4: INSURANCE AND INSURTECH
# ===================================================================

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("INSURANCE AND INSURTECH – BLOCKCHAIN APPLICATIONS")
print("="*70)

# ----------------------------------------------------------------
# PART A: INSURANCE DATA GENERATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART A: Insurance Data Generation")
print("-"*60)

class InsuranceDataGenerator:
    """
    Generate realistic insurance policy and claims data.
    """
    def __init__(self):
        self.policy_types = ['Life', 'Auto', 'Home', 'Health', 'Travel', 'Flight Delay']
        self.coverages = {
            'Life': [10000, 1000000],
            'Auto': [5000, 50000],
            'Home': [50000, 500000],
            'Health': [10000, 200000],
            'Travel': [1000, 20000],
            'Flight Delay': [100, 1000]
        }
        self.regions = ['North America', 'Europe', 'Asia', 'South America', 'Africa', 'Australia']
        self.risk_factors = ['Low', 'Medium', 'High', 'Very High']
    
    def generate_policies(self, num_policies: int = 1000) -> pd.DataFrame:
        """Generate simulated insurance policies."""
        data = []
        for i in range(num_policies):
            policy_type = random.choice(self.policy_types)
            coverage_min, coverage_max = self.coverages[policy_type]
            coverage = random.uniform(coverage_min, coverage_max)
            
            policy_date = datetime.now() - timedelta(days=random.randint(1, 730))
            expiry_date = policy_date + timedelta(days=365)
            
            risk_factor = random.choices(
                self.risk_factors,
                weights=[0.3, 0.35, 0.25, 0.1]
            )[0]
            
            risk_score = {
                'Low': random.uniform(0.1, 0.3),
                'Medium': random.uniform(0.3, 0.5),
                'High': random.uniform(0.5, 0.7),
                'Very High': random.uniform(0.7, 0.9)
            }[risk_factor]
            
            data.append({
                'policy_id': f'POL-{i+1:06d}',
                'policy_type': policy_type,
                'policyholder': f'Customer_{random.randint(1, 500)}',
                'coverage_amount': round(coverage, 2),
                'annual_premium': round(coverage * risk_score * 0.05, 2),
                'region': random.choice(self.regions),
                'risk_factor': risk_factor,
                'risk_score': round(risk_score, 3),
                'start_date': policy_date,
                'expiry_date': expiry_date,
                'status': random.choices(['Active', 'Expired', 'Cancelled'], weights=[0.7, 0.2, 0.1])[0]
            })
        
        return pd.DataFrame(data)

# Generate data
data_gen = InsuranceDataGenerator()
policy_data = data_gen.generate_policies(1000)

print(f"Generated {len(policy_data)} insurance policies")
print("\nSample Policy Data:")
print(policy_data.head(10).to_string(index=False))

# ----------------------------------------------------------------
# PART B: CLAIMS SIMULATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART B: Claims Simulation")
print("-"*60)

class ClaimsSimulator:
    """
    Simulate insurance claims with blockchain verification.
    """
    def __init__(self, policy_data: pd.DataFrame):
        self.policy_data = policy_data
        self.claims = []
        self.verified_claims = []
        self.fraud_detected = 0
    
    def generate_claim(self, policy_id: str, claim_amount: float, description: str, is_fraud: bool = False) -> Dict:
        """Generate a claim for a policy."""
        claim = {
            'claim_id': f'CLM-{len(self.claims)+1:06d}',
            'policy_id': policy_id,
            'claim_amount': claim_amount,
            'description': description,
            'is_fraud': is_fraud,
            'status': 'Submitted',
            'submission_date': datetime.now(),
            'verified': False,
            'fraud_score': random.uniform(0, 1) if is_fraud else random.uniform(0, 0.3),
            'blockchain_hash': hashlib.sha256(f"{policy_id}{claim_amount}{datetime.now()}".encode()).hexdigest()[:16]
        }
        return claim
    
    def submit_claim(self, policy_id: str, claim_amount: float, description: str) -> Dict:
        """Submit a claim with fraud detection."""
        # Check if policy exists
        policy = self.policy_data[self.policy_data['policy_id'] == policy_id]
        if policy.empty:
            return {'error': 'Policy not found'}
        
        # Determine if claim is fraudulent (some random)
        is_fraud = random.random() < 0.08  # 8% fraud rate
        
        claim = self.generate_claim(policy_id, claim_amount, description, is_fraud)
        self.claims.append(claim)
        
        # Process claim
        result = self.process_claim(claim)
        return result
    
    def process_claim(self, claim: Dict) -> Dict:
        """Process a claim with verification."""
        # Simulate blockchain verification
        claim['verified'] = True
        
        # Fraud detection based on fraud score
        if claim['fraud_score'] > 0.7:
            claim['status'] = 'Fraud Detected'
            self.fraud_detected += 1
        elif claim['fraud_score'] > 0.4:
            claim['status'] = 'Under Review'
        else:
            claim['status'] = 'Approved'
            self.verified_claims.append(claim)
        
        return claim
    
    def get_claims_metrics(self) -> Dict:
        """Get claims statistics."""
        total_claims = len(self.claims)
        approved = len([c for c in self.claims if c['status'] == 'Approved'])
        fraud = len([c for c in self.claims if c['status'] == 'Fraud Detected'])
        review = len([c for c in self.claims if c['status'] == 'Under Review'])
        
        total_payout = sum(c['claim_amount'] for c in self.verified_claims)
        
        return {
            'total_claims': total_claims,
            'approved_claims': approved,
            'fraud_detected': fraud,
            'under_review': review,
            'total_payout': total_payout,
            'approval_rate': approved / total_claims if total_claims > 0 else 0,
            'fraud_rate': fraud / total_claims if total_claims > 0 else 0
        }

# Create claims simulator
simulator = ClaimsSimulator(policy_data)

# Submit claims
print("\nSubmitting Claims...")
for i in range(20):
    policy = policy_data.iloc[random.randint(0, len(policy_data)-1)]
    claim_amount = random.uniform(100, 5000)
    description = random.choice([
        'Accident', 'Theft', 'Natural Disaster', 'Illness', 'Flight Cancelled'
    ])
    result = simulator.submit_claim(policy['policy_id'], claim_amount, description)
    
    if 'error' not in result:
        print(f"Claim {result['claim_id']}: {result['status']} (Fraud Score: {result['fraud_score']:.2f})")

# Get metrics
print("\nClaims Metrics:")
metrics = simulator.get_claims_metrics()
for key, value in metrics.items():
    if isinstance(value, float):
        print(f"  {key}: {value:.2%}")
    else:
        print(f"  {key}: {value}")

# ----------------------------------------------------------------
# PART C: PARAMETRIC INSURANCE SIMULATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART C: Parametric Insurance Simulation")
print("-"*60)

class ParametricInsurancePolicy:
    """
    Simulated parametric insurance policy on blockchain.
    """
    def __init__(self, policy_id: str, policyholder: str, parameter: str, 
                 threshold: float, payout_amount: float, premium: float):
        self.policy_id = policy_id
        self.policyholder = policyholder
        self.parameter = parameter
        self.threshold = threshold
        self.payout_amount = payout_amount
        self.premium = premium
        self.active = True
        self.payouts = []
        self.trigger_log = []
        self.created = datetime.now()
    
    def evaluate_trigger(self, parameter_value: float) -> bool:
        """Evaluate if trigger condition is met."""
        triggered = parameter_value >= self.threshold
        if triggered:
            self.trigger_log.append({
                'parameter_value': parameter_value,
                'triggered': True,
                'timestamp': datetime.now()
            })
        return triggered
    
    def process_payout(self) -> Dict:
        """Process automatic payout."""
        if not self.active:
            return {'error': 'Policy not active'}
        
        payout = {
            'payout_id': f'PAY-{len(self.payouts)+1:06d}',
            'policy_id': self.policy_id,
            'amount': self.payout_amount,
            'timestamp': datetime.now(),
            'transaction_hash': hashlib.sha256(f"{self.policy_id}{datetime.now()}".encode()).hexdigest()[:16]
        }
        self.payouts.append(payout)
        return payout
    
    def get_summary(self) -> Dict:
        return {
            'policy_id': self.policy_id,
            'parameter': self.parameter,
            'threshold': self.threshold,
            'payout_amount': self.payout_amount,
            'active': self.active,
            'total_payouts': len(self.payouts),
            'total_paid': sum(p['amount'] for p in self.payouts)
        }

class ParametricInsurancePlatform:
    """
    Platform for parametric insurance policies.
    """
    def __init__(self):
        self.policies: List[ParametricInsurancePolicy] = []
        self.total_premiums = 0
        self.total_payouts = 0
    
    def create_policy(self, policyholder: str, parameter: str, threshold: float, 
                     payout_amount: float, premium: float) -> ParametricInsurancePolicy:
        policy_id = f'PAR-{len(self.policies)+1:06d}'
        policy = ParametricInsurancePolicy(policy_id, policyholder, parameter, threshold, payout_amount, premium)
        self.policies.append(policy)
        self.total_premiums += premium
        print(f"Policy Created: {policy_id} ({parameter} > {threshold})")
        return policy
    
    def process_event(self, policy_id: str, parameter_value: float) -> Dict:
        """Process an event and trigger payout if condition met."""
        policy = next((p for p in self.policies if p.policy_id == policy_id), None)
        if not policy:
            return {'error': 'Policy not found'}
        
        if policy.evaluate_trigger(parameter_value):
            payout = policy.process_payout()
            self.total_payouts += payout['amount']
            print(f"Payout triggered! {policy_id}: {payout['amount']} paid")
            return payout
        else:
            print(f"Event processed: {parameter_value:.2f} < {policy.threshold} - No payout")
            return {'triggered': False, 'parameter_value': parameter_value}
    
    def get_metrics(self) -> Dict:
        total_policies = len(self.policies)
        policies_with_payout = len([p for p in self.policies if len(p.payouts) > 0])
        total_payout_amount = sum(p['amount'] for policy in self.policies for p in policy.payouts)
        
        return {
            'total_policies': total_policies,
            'policies_with_payout': policies_with_payout,
            'total_premiums': self.total_premiums,
            'total_payouts': self.total_payouts,
            'loss_ratio': self.total_payouts / self.total_premiums if self.total_premiums > 0 else 0
        }

# Create parametric insurance platform
param_platform = ParametricInsurancePlatform()

# Create policies
param_platform.create_policy(
    policyholder="Farmer_Johnson",
    parameter="Rainfall (mm)",
    threshold=50,
    payout_amount=10000,
    premium=500
)

param_platform.create_policy(
    policyholder="Airline_A",
    parameter="Flight Delay (minutes)",
    threshold=120,
    payout_amount=300,
    premium=30
)

param_platform.create_policy(
    policyholder="Crop_Corp",
    parameter="Temperature (Celsius)",
    threshold=35,
    payout_amount=15000,
    premium=750
)

print("\nProcessing Events...")

# Simulate events
events = [
    ('PAR-000001', 45),   # Below threshold
    ('PAR-000001', 60),   # Above threshold → payout
    ('PAR-000002', 150),  # Above threshold → payout
    ('PAR-000003', 32),   # Below threshold
    ('PAR-000003', 38),   # Above threshold → payout
]

for policy_id, value in events:
    result = param_platform.process_event(policy_id, value)

print("\nParametric Insurance Metrics:")
metrics = param_platform.get_metrics()
for key, value in metrics.items():
    if isinstance(value, float):
        print(f"  {key}: {value:.2f}")
    else:
        print(f"  {key}: {value}")

# ----------------------------------------------------------------
# PART D: INSURANCE EFFICIENCY VISUALISATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART D: Insurance Efficiency Visualisation")
print("-"*60)

# Efficiency comparison data
efficiency_data = {
    'Metric': [
        'Claims Processing Time (days)',
        'Claims Fraud Rate (%)',
        'Customer Satisfaction',
        'Operational Cost (% of premium)',
        'Policy Issuance Time (hours)',
        'Data Transparency Score'
    ],
    'Traditional': [30, 12, 70, 25, 48, 40],
    'Blockchain-Enabled': [2, 4, 88, 12, 2, 85]
}

efficiency_df = pd.DataFrame(efficiency_data)

print("Efficiency Improvement:")
print(efficiency_df.to_string(index=False))

# Visualise
fig, ax = plt.subplots(figsize=(12, 6))

x = np.arange(len(efficiency_data['Metric']))
width = 0.35

ax.bar(x - width/2, efficiency_data['Traditional'], width, label='Traditional', color='red', alpha=0.7)
ax.bar(x + width/2, efficiency_data['Blockchain-Enabled'], width, label='Blockchain-Enabled', color='green', alpha=0.7)

ax.set_xlabel('Metric')
ax.set_ylabel('Value')
ax.set_title('Insurance Efficiency: Traditional vs Blockchain')
ax.set_xticks(x)
ax.set_xticklabels(efficiency_data['Metric'], rotation=45, ha='right')
ax.legend()
ax.grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('insurance_efficiency.png', dpi=300, bbox_inches='tight')
plt.show()
print("Insurance efficiency chart saved as 'insurance_efficiency.png'")

# ----------------------------------------------------------------
# PART E: INSURANCE USE CASES AND BENEFITS
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART E: Insurance Use Cases and Benefits")
print("-"*60)

use_cases = pd.DataFrame({
    'Use Case': [
        'Flight Delay Insurance',
        'Crop Insurance',
        'Travel Insurance',
        'Health Insurance',
        'Auto Insurance',
        'DeFi Protocol Insurance'
    ],
    'Parameter': [
        'Flight delay minutes',
        'Rainfall/temperature',
        'Flight cancellation',
        'Medical event',
        'Accident/claim',
        'Smart contract exploit'
    ],
    'Automation Level': [
        'High',
        'High',
        'High',
        'Medium',
        'Medium',
        'High'
    ],
    'Blockchain Benefit': [
        'Instant payout',
        'Transparent triggers',
        'Fraud reduction',
        'Data privacy',
        'Immutable records',
        'Trustless coverage'
    ]
})

print(use_cases.to_string(index=False))

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

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

print("""
Insurance and InsurTech with Blockchain – Key Takeaways:

1. InsurTech uses technology to innovate insurance processes.
2. Blockchain addresses fraud, manual processes, and lack of transparency.
3. Parametric insurance uses smart contracts for automatic payouts.
4. Claims processing is automated and transparent on blockchain.
5. Fraud detection is enhanced through immutable records.
6. Key players: Nexus Mutual, Etherisc, InsurAce, traditional insurers.
7. Benefits: faster claims, reduced fraud, lower costs, better user experience.

Recommendations:
  - Start with parametric insurance products.
  - Integrate IoT and oracle data for trigger events.
  - Build transparent claims processes.
  - Ensure regulatory compliance.
  - Educate customers on blockchain benefits.
  - Partner with trusted data providers.
  - Consider hybrid models (on-chain + off-chain) for scalability.
""")