Insurance Tech: Digital Transformation in Insurance

from dataclasses import dataclass
from datetime import datetime, date
from typing import Optional, List
from enum import Enum
import uuid

class PolicyStatus(Enum):
    QUOTE = "quote"
    ACTIVE = "active"
    EXPIRED = "expired"
    CANCELLED = "cancelled"
    PENDING = "pending"

class CoverageType(Enum):
    AUTO = "auto"
    HOME = "home"
    LIFE = "life"
    HEALTH = "health"
    COMMERCIAL = "commercial"

@dataclass
class Coverage:
    coverage_id: str
    coverage_type: CoverageType
    limit: float
    deductible: float
    premium: float
    terms: dict
    
    def __post_init__(self):
        if not self.coverage_id:
            self.coverage_id = str(uuid.uuid4())

@dataclass
class Policy:
    policy_number: str
    policy_holder: dict
    coverages: List[Coverage]
    effective_date: date
    expiration_date: date
    status: PolicyStatus
    premium_total: float
    payment_schedule: str  # monthly, quarterly, annual
    
    def __post_init__(self):
        if not self.policy_number:
            self.policy_number = self._generate_policy_number()
    
    def _generate_policy_number(self) -> str:
        prefix = "POL"
        timestamp = datetime.now().strftime("%Y%m%d")
        random_suffix = str(uuid.uuid4())[:6].upper()
        return f"{prefix}-{timestamp}-{random_suffix}"


class PolicyAdministrationSystem:
    def __init__(self, rating_engine, document_service, integration_layer):
        self.rating = rating_engine
        self.documents = document_service
        self.integrations = integration_layer
    
    def create_quote(self, quote_request: dict) -> Policy:
        """Generate a quoted policy based on risk assessment."""
        # Calculate premium using rating engine
        rated_premium = self.rating.calculate_premium(quote_request)
        
        # Create coverage objects
        coverages = []
        for cov in quote_request.get('coverages', []):
            coverage = Coverage(
                coverage_id="",
                coverage_type=CoverageType[cov['type'].upper()],
                limit=cov['limit'],
                deductible=cov.get('deductible', 0),
                premium=cov['premium'],  # from rating
                terms=cov.get('terms', {})
            )
            coverages.append(coverage)
        
        # Create policy object (quote status)
        policy = Policy(
            policy_number="",
            policy_holder=quote_request['holder'],
            coverages=coverages,
            effective_date=datetime.strptime(
                quote_request['effective_date'], '%Y-%m-%d'
            ).date(),
            expiration_date=datetime.strptime(
                quote_request['effective_date'], '%Y-%m-%d'
            ).date(),
            status=PolicyStatus.QUOTE,
            premium_total=sum(c.premium for c in coverages),
            payment_schedule=quote_request.get('payment_schedule', 'annual')
        )
        
        # Generate quote documents
        self.documents.generate_quote_documents(policy)
        
        return policy
    
    def issue_policy(self, policy: Policy) -> Policy:
        """Convert quote to issued policy."""
        if policy.status != PolicyStatus.QUOTE:
            raise ValueError("Can only issue policies in QUOTE status")
        
        # Update status
        policy.status = PolicyStatus.ACTIVE
        
        # Create policy documents
        self.documents.generate_policy_documents(policy)
        
        # Register with reinsurance systems (if applicable)
        if self._requires_reinsurance(policy):
            self.integrations.notify_reinsurance(policy)
        
        # Setup billing
        self._setup_billing(policy)
        
        return policy
    
    def process_endorsement(self, policy: Policy, changes: dict) -> Policy:
        """Process policy changes (endorsements)."""
        endorsement_type = changes.get('type')
        
        if endorsement_type == 'coverage_change':
            # Add, remove, or modify coverage
            return self._handle_coverage_change(policy, changes)
        elif endorsement_type == 'holder_change':
            # Update policyholder information
            return self._handle_holder_change(policy, changes)
        elif endorsement_type == 'address_change':
            # Update location/risk address
            return self._handle_address_change(policy, changes)
    
    def cancel_policy(self, policy: Policy, reason: str, effective_date: date = None) -> Policy:
        """Cancel policy and calculate refunds."""
        if policy.status != PolicyStatus.ACTIVE:
            raise ValueError("Can only cancel ACTIVE policies")
        
        # Calculate pro-rata refund
        refund = self._calculate_cancellation_refund(policy, effective_date)
        
        # Process refund
        if refund > 0:
            self._process_refund(policy, refund)
        
        policy.status = PolicyStatus.CANCELLED
        
        # Generate cancellation documents
        self.documents.generate_cancellation_notice(policy, reason, refund)
        
        return policy

class RatingEngine:
    def __init__(self, actuarial_models, external_data_sources):
        self.models = actuarial_models
        self.external_data = external_data_sources
    
    def calculate_premium(self, risk_data: dict) -> dict:
        """Calculate premium based on risk assessment."""
        base_rate = self._get_base_rate(risk_data['coverage_type'])
        
        # Apply rating factors
        factors = {
            'age': self._get_age_factor(risk_data.get('driver_age')),
            'location': self._get_location_factor(risk_data.get('zip_code')),
            'coverage_limits': self._get_limit_factor(risk_data.get('coverage_limits')),
            'deductible': self._get_deductible_factor(risk_data.get('deductible')),
            'claims_history': self._get_claims_factor(risk_data.get('prior_claims')),
            'credit_score': self._get_credit_factor(risk_data.get('credit_score'))
        }
        
        # Calculate final premium
        final_premium = base_rate
        for factor_name, factor_value in factors.items():
            final_premium *= factor_value
        
        return {
            'base_premium': base_rate,
            'final_premium': round(final_premium, 2),
            'factors': factors,
            'annual_premium': final_premium,
            'monthly_premium': round(final_premium / 12, 2)
        }
    
    def _get_base_rate(self, coverage_type: str) -> float:
        """Get base rate for coverage type."""
        base_rates = {
            'auto': 800,
            'home': 1200,
            'life': 500,
            'health': 300,
            'commercial': 2500
        }
        return base_rates.get(coverage_type, 1000)
    
    def _get_age_factor(self, age: int) -> float:
        """Calculate age-based rating factor."""
        if age is None:
            return 1.0
        
        if age < 25:
            return 2.5  # Young drivers highest risk
        elif age < 35:
            return 1.3
        elif age < 65:
            return 1.0
        elif age < 75:
            return 1.4
        else:
            return 2.0
    
    def _get_location_factor(self, zip_code: str) -> float:
        """Calculate location-based rating factor."""
        # In production, use actual territory mappings
        # This is simplified
        urban_areas = ['10001', '90001', '60601']
        
        if zip_code[:5] in urban_areas:
            return 1.3  # Higher risk in urban areas
        return 1.0
    
    def _get_credit_factor(self, credit_score: int) -> float:
        """Calculate credit-based rating factor."""
        if credit_score >= 800:
            return 0.7
        elif credit_score >= 700:
            return 0.85
        elif credit_score >= 600:
            return 1.0
        elif credit_score >= 500:
            return 1.3
        else:
            return 1.6


class UnderwritingEngine:
    def __init__(self, rules_engine, ml_models, external_services):
        self.rules = rules_engine
        self.ml_models = ml_models
        self.external = external_services
    
    def evaluate_application(self, application: dict) -> UnderwritingDecision:
        """Evaluate insurance application."""
        risk_score = 0
        auto_refer = False
        auto_decline = False
        reasons = []
        
        # Rule-based checks
        rule_result = self.rules.evaluate(application)
        if rule_result.decline:
            auto_decline = True
            reasons.extend(rule_result.decline_reasons)
        if rule_result.refer:
            auto_refer = True
            reasons.extend(rule_result.refer_reasons)
        
        # ML model scoring
        if not auto_decline:
            ml_score = self.ml_models['risk_predictor'].predict(
                self._prepare_features(application)
            )
            risk_score = ml_score['probability']
            
            if ml_score['probability'] > 0.8:
                auto_decline = True
                reasons.append("High risk score from ML model")
            elif ml_score['probability'] > 0.6:
                auto_refer = True
                reasons.append("Manual review recommended")
        
        # External data verification
        if not auto_decline:
            verification = await self.external.verify_identity(application)
            if not verification['verified']:
                auto_refer = True
                reasons.append("Identity verification failed")
        
        # Final decision
        if auto_decline:
            return UnderwritingDecision(
                approved=False,
                decision='decline',
                risk_score=risk_score,
                reasons=reasons
            )
        elif auto_refer:
            return UnderwritingDecision(
                approved=True,
                decision='refer',
                risk_score=risk_score,
                reasons=reasons,
                referral_notes='Manual review required'
            )
        else:
            return UnderwritingDecision(
                approved=True,
                decision='approve',
                risk_score=risk_score,
                reasons=reasons
            )

class ClaimsProcessingSystem:
    def __init__(self, document_processor, fraud_detector, settlement_engine):
        self.document_processor = document_processor
        self.fraud_detector = fraud_detector
        self.settlement = settlement_engine
    
    async def submit_claim(self, claim_data: dict) -> Claim:
        """Submit new insurance claim."""
        # Create claim record
        claim = Claim(
            claim_id=str(uuid.uuid4()),
            policy_number=claim_data['policy_number'],
            claim_type=claim_data['type'],
            incident_date=claim_data['incident_date'],
            reported_date=datetime.now(),
            description=claim_data['description'],
            estimated_amount=claim_data.get('estimated_amount', 0),
            status=ClaimStatus.SUBMITTED
        )
        
        # Process supporting documents
        documents = await self.document_processor.extract_claim_documents(
            claim_data.get('document_urls', [])
        )
        claim.supporting_documents = documents
        
        # Initial fraud screening
        fraud_result = await self.fraud_detector.screen(claim)
        claim.fraud_score = fraud_result['score']
        claim.fraud_flags = fraud_result['flags']
        
        if fraud_result['high_risk']:
            claim.status = ClaimStatus.FRAUD_INVESTIGATION
        else:
            claim.status = ClaimStatus.IN_REVIEW
        
        return claim
    
    async def assess_claim(self, claim: Claim) -> ClaimAssessment:
        """Assess claim and determine coverage and payment."""
        # Verify policy is active and covers claim type
        policy = await self._get_policy(claim.policy_number)
        
        if policy.status != PolicyStatus.ACTIVE:
            return ClaimAssessment(
                claim_id=claim.claim_id,
                covered=False,
                reason="Policy not active",
                amount=0
            )
        
        # Check coverage for claim type
        coverage = self._get_coverage_for_claim(policy, claim.claim_type)
        
        if coverage is None:
            return ClaimAssessment(
                claim_id=claim.claim_id,
                covered=False,
                reason=f"No {claim.claim_type} coverage on policy",
                amount=0
            )
        
        # Calculate claim amount
        assessed_amount = await self._calculate_claim_amount(claim, coverage)
        
        # Apply deductible
        final_amount = max(0, assessed_amount - coverage.deductible)
        
        # Check policy limits
        if final_amount > coverage.limit:
            final_amount = coverage.limit
        
        return ClaimAssessment(
            claim_id=claim.claim_id,
            covered=True,
            reason="Claim approved",
            amount=final_amount,
            deductible_applied=coverage.deductible,
            coverage_limit=coverage.limit,
            breakdown=await self._get_coverage_breakdown(claim)
        )
    
    async def settle_claim(self, claim: Claim, assessment: ClaimAssessment) -> Settlement:
        """Process claim settlement and payment."""
        if not assessment.covered:
            claim.status = ClaimStatus.DENIED
            raise ClaimDeniedException(assessment.reason)
        
        # Create settlement record
        settlement = await self.settlement.create_settlement(
            claim_id=claim.claim_id,
            amount=assessment.amount,
            payee=claim.policy_holder
        )
        
        # Process payment
        payment_result = await self.settlement.process_payment(settlement)
        
        claim.status = ClaimStatus.PAID
        claim.settlement_amount = assessment.amount
        claim.settlement_date = datetime.now()
        
        return settlement


class DocumentProcessor:
    """Extract information from claim documents using OCR and NLP."""
    
    def __init__(self, ocr_service, nlp_model):
        self.ocr = ocr_service
        self.nlp = nlp_model
    
    async def extract_claim_documents(self, document_urls: List[str]) -> List[ClaimDocument]:
        """Extract and parse claim documents."""
        documents = []
        
        for url in document_urls:
            # Extract text using OCR
            text = await self.ocr.extract_text(url)
            
            # Parse important fields using NLP
            extracted = self.nlp.extract_fields(text, fields=[
                'date_of_loss',
                'description',
                'estimated_amount',
                'police_report_number',
                'repair_estimate'
            ])
            
            documents.append(ClaimDocument(
                url=url,
                document_type=self._classify_document(text),
                extracted_text=text,
                extracted_fields=extracted,
                confidence=self._calculate_confidence(extracted)
            ))
        
        return documents

class TelematicsProcessor:
    def __init__(self, vehicle_api, scoring_model):
        self.vehicle = vehicle_api
        self.scoring = scoring_model
    
    async def process_trip_data(self, vehicle_id: str, trips: List[Trip]) -> TelematicsScore:
        """Process driving behavior data and calculate score."""
        all_trips = []
        
        for trip in trips:
            trip_features = {
                'hard_brakes': trip.hard_brake_count,
                'hard_accels': trip.hard_accel_count,
                'speeding_events': trip.speeding_violations,
                'night_driving': trip.night_driving_minutes,
                'total_miles': trip.distance,
                'avg_speed': trip.average_speed,
                'max_speed': trip.max_speed,
                'phone_distraction': trip.phone_interaction_count
            }
            all_trips.append(trip_features)
        
        # Aggregate features over policy period
        aggregate = self._aggregate_features(all_trips)
        
        # Calculate score using ML model
        score = self.scoring.calculate_score(aggregate)
        
        # Determine discount eligibility
        discount = self._calculate_discount(score)
        
        return TelematicsScore(
            vehicle_id=vehicle_id,
            policy_period=aggregate['period'],
            driving_score=score['score'],
            score_category=score['category'],  # excellent, good, fair, poor
            discount_percent=discount,
            driving_summary=aggregate,
            risk_factors=score['risk_factors']
        )
    
    def _aggregate_features(self, trips: List[dict]) -> dict:
        """Aggregate trip features into policy period metrics."""
        total_trips = len(trips)
        
        return {
            'period': f"{trips[0]['date']} to {trips[-1]['date']}" if trips else None,
            'total_trips': total_trips,
            'total_miles': sum(t['total_miles'] for t in trips),
            'avg_hard_brakes_per_1000mi': (
                sum(t['hard_brakes'] for t in trips) / 
                max(1, sum(t['total_miles'] for t in trips)) * 1000
            ),
            'avg_hard_accels_per_1000mi': (
                sum(t['hard_accels'] for t in trips) /
                max(1, sum(t['total_miles'] for t in trips)) * 1000
            ),
            'percent_night_driving': (
                sum(t['night_driving'] for t in trips) /
                max(1, sum(t['total_miles'] for t in trips)) * 100
            ),
            'percent_speeding': (
                sum(t['speeding_events'] for t in trips) /
                max(1, total_trips) * 100
            ),
            'avg_speed': sum(t['avg_speed'] for t in trips) / max(1, total_trips),
            'max_speed_observed': max(t['max_speed'] for t in trips) if trips else 0
        }
    
    def _calculate_discount(self, score: dict) -> float:
        """Calculate premium discount based on driving score."""
        category_discounts = {
            'excellent': 30,
            'good': 20,
            'fair': 10,
            'poor': 0
        }
        
        return category_discounts.get(score['category'], 0)

class EmbeddedInsurancePlatform:
    def __init__(self, policy_admin, distribution_api, commission_tracker):
        self.policy_admin = policy_admin
        self.distribution = distribution_api
        self.commissions = commission_tracker
    
    def create_embedded_product(
        self,
        host_product: str,
        coverage_template: dict,
        pricing_rules: dict
    ) -> EmbeddedProduct:
        """Create an embedded insurance product for a partner."""
        product = EmbeddedProduct(
            product_id=str(uuid.uuid4()),
            host_product=host_product,
            coverage_template=coverage_template,
            pricing_rules=pricing_rules,
            commission_rate=pricing_rules.get('commission', 0.15)
        )
        
        return product
    
    async def quote_embedded(
        self,
        product: EmbeddedProduct,
        context: dict
    ) -> EmbeddedQuote:
        """Generate instant quote for embedded context."""
        # Extract pricing factors from context
        price_factors = self._extract_pricing_factors(
            product.pricing_rules,
            context
        )
        
        # Calculate premium
        base_premium = product.coverage_template['base_premium']
        final_premium = base_premium
        
        for factor, multiplier in price_factors.items():
            final_premium *= multiplier
        
        return EmbeddedQuote(
            quote_id=str(uuid.uuid4()),
            product_id=product.product_id,
            premium=round(final_premium, 2),
            coverage_summary=product.coverage_template['summary'],
            factors_applied=price_factors,
            valid_until=datetime.now() + timedelta(minutes=30)
        )
    
    async def bind_embedded(
        self,
        quote: EmbeddedQuote,
        insured_data: dict,
        payment: dict
    ) -> Policy:
        """Bind coverage and issue policy."""
        # Verify quote is still valid
        if quote.valid_until < datetime.now():
            raise QuoteExpiredException()
        
        # Create full policy application
        application = {
            'coverage_type': quote.product_id,
            'holder': insured_data,
            'effective_date': date.today(),
            'coverages': [{
                'type': quote.product_id,
                'limit': quote.coverage_summary['limit'],
                'deductible': quote.coverage_summary.get('deductible', 0),
                'premium': quote.premium
            }]
        }
        
        # Issue policy
        policy = self.policy_admin.create_quote(application)
        policy = self.policy_admin.issue_policy(policy)
        
        # Track commission for partner
        self.commissions.record_sale(
            partner_id=quote.product_id,
            policy_id=policy.policy_number,
            premium=quote.premium
        )
        
        return policy
    
    def _extract_pricing_factors(
        self,
        rules: dict,
        context: dict
    ) -> dict:
        """Extract pricing factors from purchase context."""
        factors = {}
        
        # Example: E-commerce context
        if context.get('purchase_price'):
            value_factor = min(context['purchase_price'] / 1000, 3.0)
            factors['value_multiplier'] = value_factor
        
        # Example: Travel context
        if context.get('trip_duration_days'):
            duration_factor = 1 + (context['trip_duration_days'] / 30)
            factors['duration_multiplier'] = duration_factor
        
        # Example: Host context (Airbnb-style)
        if context.get('property_value'):
            factors['property_factor'] = context['property_value'] / 500000
        
        return factors