import numpy as np
import pandas as pd
import time
from typing import Dict, List, Optional
from dataclasses import dataclass, field
from collections import defaultdict
import uuid

class BNPLDataGenerator:
    """Generate synthetic BNPL transaction data."""
    
    @staticmethod
    def generate_transactions(n_transactions=20000):
        np.random.seed(42)
        
        order_amount = np.random.lognormal(4.5, 1.0, n_transactions).clip(10, 2000)
        merchant_category = np.random.choice(
            ['fashion', 'electronics', 'beauty', 'home', 'sports', 'travel'],
            n_transactions, p=[0.30, 0.20, 0.15, 0.15, 0.10, 0.10]
        )
        
        consumer_age = np.random.normal(32, 10, n_transactions).clip(18, 70)
        credit_score = np.random.normal(680, 80, n_transactions).clip(300, 850)
        prior_purchases = np.random.poisson(5, n_transactions)
        
        log_odds = (
            -2.0
            + 0.003 * (credit_score - 650)
            - 0.02 * (consumer_age - 30)
            - 0.1 * prior_purchases
            - 0.001 * order_amount
            + np.random.randn(n_transactions) * 0.3
        )
        
        prob_default = 1 / (1 + np.exp(-log_odds))
        defaulted = np.random.binomial(1, prob_default)
        
        approved = np.random.binomial(1, 0.7, n_transactions)
        
        data = pd.DataFrame({
            'order_amount': order_amount,
            'merchant_category': merchant_category,
            'consumer_age': consumer_age,
            'credit_score': credit_score,
            'prior_purchases': prior_purchases,
            'defaulted': defaulted,
            'approved': approved
        })
        
        return data

class BNPLDecisionEngine:
    """Real-time BNPL credit decisioning."""
    
    def __init__(self):
        self.approval_threshold = 0.6
        self.max_order_amount = 2000
        self.rejection_rate_target = 0.30
        
    def evaluate_application(self, application: dict) -> dict:
        risk_score = self._calculate_risk_score(application)
        
        approved = risk_score < self.approval_threshold
        max_amount = self._calculate_max_amount(application, risk_score)
        
        if application.get('order_amount', 0) > max_amount:
            approved = False
        
        return {
            'approved': approved,
            'risk_score': risk_score,
            'max_amount': max_amount,
            'decision_time_ms': 50,
            'reason': self._get_decision_reason(risk_score, approved)
        }
    
    def _calculate_risk_score(self, application: dict) -> float:
        credit_score = application.get('credit_score', 650)
        age = application.get('consumer_age', 30)
        prior_purchases = application.get('prior_purchases', 0)
        order_amount = application.get('order_amount', 100)
        
        credit_factor = max(0, min(1, (credit_score - 500) / 350))
        age_factor = max(0, min(1, (age - 18) / 50))
        loyalty_factor = min(prior_purchases / 10, 1.0)
        amount_factor = max(0, min(1, order_amount / 1000))
        
        risk_score = (
            0.4 * (1 - credit_factor) +
            0.2 * (1 - age_factor) +
            0.15 * (1 - loyalty_factor) +
            0.25 * amount_factor +
            np.random.randn() * 0.05
        )
        
        return max(0, min(1, risk_score))
    
    def _calculate_max_amount(self, application: dict, risk_score: float) -> float:
        base_amount = 500
        credit_multiplier = application.get('credit_score', 650) / 850
        loyalty_multiplier = 1 + min(application.get('prior_purchases', 0) * 0.05, 0.5)
        
        max_amount = base_amount * credit_multiplier * loyalty_multiplier * (1 - risk_score)
        
        return min(max_amount, self.max_order_amount)
    
    def _get_decision_reason(self, risk_score: float, approved: bool) -> str:
        if approved:
            if risk_score < 0.3:
                return "Low risk - full amount approved"
            else:
                return "Moderate risk - approved with reduced limit"
        else:
            if risk_score > 0.8:
                return "High risk - application declined"
            else:
                return "Does not meet approval criteria"

class InstallmentManager:
    """Manage BNPL installment payments."""
    
    def __init__(self):
        self.installments: Dict[str, dict] = {}
        
    def create_installment_plan(self, order_id: str, total_amount: float,
                               n_payments: int = 4, frequency_days: int = 14) -> dict:
        plan_id = f"PLAN_{uuid.uuid4().hex[:8].upper()}"
        
        payment_amount = total_amount / n_payments
        
        schedule = []
        for i in range(n_payments):
            schedule.append({
                'payment_number': i + 1,
                'amount': payment_amount,
                'due_date': time.time() + (i + 1) * frequency_days * 86400,
                'status': 'pending',
                'late_fee': 0
            })
        
        plan = {
            'plan_id': plan_id,
            'order_id': order_id,
            'total_amount': total_amount,
            'n_payments': n_payments,
            'payment_amount': payment_amount,
            'schedule': schedule,
            'status': 'active',
            'created_at': time.time()
        }
        
        self.installments[plan_id] = plan
        return plan
    
    def make_payment(self, plan_id: str, payment_number: int) -> dict:
        plan = self.installments[plan_id]
        
        for payment in plan['schedule']:
            if payment['payment_number'] == payment_number:
                if payment['status'] == 'paid':
                    return {'success': False, 'reason': 'already_paid'}
                
                payment['status'] = 'paid'
                payment['paid_at'] = time.time()
                
                all_paid = all(p['status'] == 'paid' for p in plan['schedule'])
                if all_paid:
                    plan['status'] = 'completed'
                
                return {
                    'success': True,
                    'payment': payment,
                    'remaining_balance': sum(
                        p['amount'] for p in plan['schedule'] if p['status'] != 'paid'
                    )
                }
        
        return {'success': False, 'reason': 'payment_not_found'}
    
    def apply_late_fee(self, plan_id: str, payment_number: int, fee: float = 8.0) -> dict:
        plan = self.installments[plan_id]
        
        for payment in plan['schedule']:
            if payment['payment_number'] == payment_number:
                if payment['status'] == 'pending' and time.time() > payment['due_date']:
                    payment['late_fee'] = fee
                    payment['status'] = 'late'
                    return {'success': True, 'late_fee': fee}
        
        return {'success': False}

class MerchantDashboard:
    """Merchant analytics and settlement."""
    
    def __init__(self):
        self.merchant_transactions: Dict[str, List[dict]] = defaultdict(list)
        self.settlements: Dict[str, List[dict]] = defaultdict(list)
        
    def record_transaction(self, merchant_id: str, transaction: dict):
        self.merchant_transactions[merchant_id].append(transaction)
    
    def get_merchant_analytics(self, merchant_id: str) -> dict:
        transactions = self.merchant_transactions[merchant_id]
        
        if not transactions:
            return {'total_volume': 0, 'transaction_count': 0}
        
        total_volume = sum(t['amount'] for t in transactions)
        avg_order = total_volume / len(transactions)
        
        conversion_boost = np.random.uniform(1.15, 1.30)
        
        return {
            'total_volume': total_volume,
            'transaction_count': len(transactions),
            'avg_order_value': avg_order,
            'estimated_conversion_boost': conversion_boost,
            'merchant_fee_earned': total_volume * 0.04
        }
    
    def calculate_settlement(self, merchant_id: str, period_start: float,
                            period_end: float) -> dict:
        transactions = [
            t for t in self.merchant_transactions[merchant_id]
            if period_start <= t['timestamp'] <= period_end
        ]
        
        gross_volume = sum(t['amount'] for t in transactions)
        merchant_fee_rate = 0.04
        merchant_fee = gross_volume * merchant_fee_rate
        net_settlement = gross_volume - merchant_fee
        
        return {
            'merchant_id': merchant_id,
            'gross_volume': gross_volume,
            'merchant_fee': merchant_fee,
            'net_settlement': net_settlement,
            'transaction_count': len(transactions)
        }

class BNPLPlatform:
    """Complete BNPL platform."""
    
    def __init__(self):
        self.decision_engine = BNPLDecisionEngine()
        self.installment_manager = InstallmentManager()
        self.merchant_dashboard = MerchantDashboard()
        self.orders: Dict[str, dict] = {}
        
    def checkout(self, consumer_id: str, merchant_id: str, 
                order_amount: float, application_data: dict) -> dict:
        decision = self.decision_engine.evaluate_application(application_data)
        
        if not decision['approved']:
            return {
                'status': 'declined',
                'reason': decision['reason'],
                'risk_score': decision['risk_score']
            }
        
        order_id = f"ORD_{uuid.uuid4().hex[:8].upper()}"
        
        plan = self.installment_manager.create_installment_plan(order_id, order_amount)
        
        order = {
            'order_id': order_id,
            'consumer_id': consumer_id,
            'merchant_id': merchant_id,
            'amount': order_amount,
            'plan_id': plan['plan_id'],
            'status': 'active',
            'timestamp': time.time()
        }
        
        self.orders[order_id] = order
        
        self.merchant_dashboard.record_transaction(merchant_id, {
            'order_id': order_id,
            'amount': order_amount,
            'timestamp': time.time()
        })
        
        return {
            'status': 'approved',
            'order_id': order_id,
            'plan_id': plan['plan_id'],
            'payment_schedule': plan['schedule'],
            'risk_score': decision['risk_score']
        }

# Example usage
if __name__ == "__main__":
    data = BNPLDataGenerator.generate_transactions(15000)
    
    print(f"Generated {len(data)} transactions")
    print(f"Default rate: {data['defaulted'].mean()*100:.1f}%")
    print(f"Approval rate: {data['approved'].mean()*100:.1f}%")
    
    platform = BNPLPlatform()
    
    applications = [
        {'credit_score': 720, 'consumer_age': 28, 'prior_purchases': 5, 'order_amount': 150},
        {'credit_score': 580, 'consumer_age': 22, 'prior_purchases': 0, 'order_amount': 500},
        {'credit_score': 680, 'consumer_age': 35, 'prior_purchases': 10, 'order_amount': 80},
        {'credit_score': 750, 'consumer_age': 45, 'prior_purchases': 20, 'order_amount': 300},
    ]
    
    print("\nCheckout Results:")
    for i, app in enumerate(applications):
        result = platform.checkout(
            f"CONSUMER_{i}", "MERCHANT_001", app['order_amount'], app
        )
        status = "APPROVED" if result['status'] == 'approved' else "DECLINED"
        print(f"  ${app['order_amount']:.0f} (Score: {app['credit_score']}): {status}")
    
    merchant_analytics = platform.merchant_dashboard.get_merchant_analytics("MERCHANT_001")
    print(f"\nMerchant Analytics:")
    print(f"  Total Volume: ${merchant_analytics['total_volume']:,.2f}")
    print(f"  Transactions: {merchant_analytics['transaction_count']}")
    print(f"  Conversion Boost: {merchant_analytics['estimated_conversion_boost']*100-100:.1f}%")
    
    settlement = platform.merchant_dashboard.calculate_settlement(
        "MERCHANT_001", 0, time.time()
    )
    print(f"\nSettlement:")
    print(f"  Gross: ${settlement['gross_volume']:,.2f}")
    print(f"  Fee: ${settlement['merchant_fee']:,.2f}")
    print(f"  Net: ${settlement['net_settlement']:,.2f}")