// Tokenisation sécurisée côté client
const stripe = Stripe('pk_live_...');
const elements = stripe.elements();

const cardElement = elements.create('card', {
  style: {
    base: {
      fontSize: '16px',
      color: '#424770',
      '::placeholder': { color: '#aab7c4' }
    }
  }
});

// Collecte sécurisée des données
async function handlePayment(paymentIntent) {
  const {error, paymentMethod} = await stripe.createPaymentMethod({
    type: 'card',
    card: cardElement,
    billing_details: {
      name: customerName,
      email: customerEmail,
      address: billingAddress
    }
  });

  if (error) {
    handlePaymentError(error);
  } else {
    processPayment(paymentMethod.id);
  }
}

# Architecture microservices pour paiements
class PaymentProcessor:
    def __init__(self):
        self.fraud_detector = FraudDetector()
        self.risk_engine = RiskEngine()
        self.vault = TokenVault()
        self.gateway = PaymentGateway()
    
    async def process_payment(self, payment_request):
        # 1. Validation et normalisation
        validated_request = self.validate_payment_data(payment_request)
        
        # 2. Détection de fraude
        fraud_score = await self.fraud_detector.analyze(validated_request)
        
        # 3. Routing intelligent
        gateway = self.select_optimal_gateway(validated_request, fraud_score)
        
        # 4. Traitement du paiement
        result = await gateway.process(validated_request)
        
        # 5. Post-processing
        await self.handle_payment_result(result)
        
        return result

class GatewayRouter:
    def __init__(self):
        self.gateways = {
            'stripe': StripeGateway(),
            'adyen': AdyenGateway(), 
            'braintree': BraintreeGateway(),
            'cybersource': CyberSourceGateway()
        }
        
    def route_payment(self, payment_data):
        # Facteurs de routing
        factors = {
            'amount': payment_data.amount,
            'currency': payment_data.currency,
            'customer_location': payment_data.billing_address.country,
            'card_type': payment_data.card_type,
            'merchant_category': payment_data.merchant_category,
            'historical_performance': self.get_gateway_performance()
        }
        
        # Algorithme de sélection
        if factors['currency'] == 'EUR' and factors['customer_location'] in ['FR', 'DE', 'NL']:
            return self.gateways['adyen']  # Meilleur en Europe
        elif factors['amount'] > 500 and factors['card_type'] == 'AMEX':
            return self.gateways['cybersource']  # Meilleur pour high-value
        elif factors['customer_location'] == 'US':
            return self.gateways['stripe']  # Optimisé US
        else:
            return self.select_best_performing_gateway(factors)

# Infrastructure ségrégée
networks:
  cardholder_data_environment:
    subnet: "10.0.1.0/24"
    access: restricted
    logging: comprehensive
    encryption: required
    
  non_cde:
    subnet: "10.0.2.0/24"  
    access: standard
    
security:
  encryption:
    at_rest: AES-256
    in_transit: TLS 1.3
    key_management: HSM
    
  access_control:
    authentication: multi_factor
    authorization: role_based
    session_timeout: 15_minutes
    
  monitoring:
    log_retention: 1_year
    real_time_alerts: enabled
    intrusion_detection: enabled

// Tokenisation côté client (Stripe Elements)
class SecurePaymentHandler {
    constructor(publishableKey) {
        this.stripe = Stripe(publishableKey);
        this.elements = this.stripe.elements();
    }
    
    async createPaymentMethod(cardData, billingDetails) {
        const { paymentMethod, error } = await this.stripe.createPaymentMethod({
            type: 'card',
            card: this.cardElement,
            billing_details: billingDetails
        });
        
        if (error) {
            throw new PaymentSecurityError(error.message);
        }
        
        // Le token peut être stocké de manière sécurisée
        return {
            token: paymentMethod.id,
            fingerprint: paymentMethod.card.fingerprint,
            last4: paymentMethod.card.last4,
            brand: paymentMethod.card.brand
        };
    }
    
    async processRecurringPayment(customerId, paymentMethodId, amount) {
        // Utilisation du token pour paiements récurrents
        return await this.stripe.paymentIntents.create({
            amount: amount * 100,
            currency: 'eur',
            customer: customerId,
            payment_method: paymentMethodId,
            confirmation_method: 'manual',
            confirm: true
        });
    }
}

import numpy as np
from sklearn.ensemble import IsolationForest, RandomForestClassifier
from datetime import datetime, timedelta

class FraudDetectionEngine:
    def __init__(self):
        self.models = {
            'anomaly_detector': IsolationForest(contamination=0.1),
            'classification_model': RandomForestClassifier(n_estimators=100),
            'velocity_checker': VelocityChecker(),
            'geolocation_analyzer': GeolocationAnalyzer()
        }
        
    def extract_features(self, transaction):
        """Extraction des features pour ML"""
        return {
            # Transaction features
            'amount': transaction.amount,
            'amount_log': np.log(transaction.amount + 1),
            'hour_of_day': transaction.created_at.hour,
            'day_of_week': transaction.created_at.weekday(),
            'is_weekend': transaction.created_at.weekday() >= 5,
            
            # Card features
            'card_type': self.encode_card_type(transaction.card_type),
            'card_country': self.encode_country(transaction.card_country),
            
            # Customer features
            'customer_age_days': (datetime.now() - transaction.customer_created).days,
            'customer_transaction_count': self.get_customer_tx_count(transaction.customer_id),
            'customer_avg_amount': self.get_customer_avg_amount(transaction.customer_id),
            
            # Behavioral features
            'amount_vs_avg': transaction.amount / (self.get_customer_avg_amount(transaction.customer_id) + 1),
            'time_since_last_tx': self.get_time_since_last_tx(transaction.customer_id),
            'velocity_1h': self.get_velocity(transaction.customer_id, hours=1),
            'velocity_24h': self.get_velocity(transaction.customer_id, hours=24),
            
            # Geolocation features
            'billing_shipping_distance': self.calculate_distance(
                transaction.billing_address, transaction.shipping_address
            ),
            'ip_country_match': transaction.ip_country == transaction.billing_country,
            'location_risk_score': self.get_location_risk(transaction.ip_address)
        }
    
    async def analyze_transaction(self, transaction):
        """Analyse complète d'une transaction"""
        features = self.extract_features(transaction)
        
        # 1. Détection d'anomalies
        anomaly_score = self.models['anomaly_detector'].decision_function([list(features.values())])[0]
        
        # 2. Classification ML
        fraud_probability = self.models['classification_model'].predict_proba([list(features.values())])[0][1]
        
        # 3. Vérifications de vélocité
        velocity_flags = await self.models['velocity_checker'].check(transaction)
        
        # 4. Analyse géolocalisation
        geo_risk = await self.models['geolocation_analyzer'].analyze(transaction)
        
        # Score final
        final_score = (
            anomaly_score * 0.3 +
            fraud_probability * 0.4 +
            velocity_flags.risk_score * 0.2 +
            geo_risk.risk_score * 0.1
        )
        
        return FraudAnalysisResult(
            risk_score=final_score,
            recommendation=self.get_recommendation(final_score),
            flags=velocity_flags.flags + geo_risk.flags,
            explanation=self.generate_explanation(features, final_score)
        )
    
    def get_recommendation(self, score):
        """Recommandation basée sur le score de risque"""
        if score > 0.8:
            return 'DECLINE'
        elif score > 0.6:
            return 'MANUAL_REVIEW' 
        elif score > 0.4:
            return 'CHALLENGE'  # 3DS, SMS verification, etc.
        else:
            return 'APPROVE'

class SmartRetryEngine:
    def __init__(self):
        self.retry_rules = {
            'insufficient_funds': {
                'max_retries': 3,
                'backoff': 'exponential',
                'base_delay': 300,  # 5 minutes
                'max_delay': 3600   # 1 hour
            },
            'processor_unavailable': {
                'max_retries': 5,
                'backoff': 'linear',
                'base_delay': 30,
                'alternative_gateways': True
            },
            'card_declined': {
                'max_retries': 1,
                'alternative_payment_methods': True
            }
        }
    
    async def process_with_retry(self, payment_request):
        last_error = None
        
        for attempt in range(1, self.get_max_retries(payment_request) + 1):
            try:
                # Sélection du gateway optimal pour cette tentative
                gateway = self.select_gateway_for_attempt(payment_request, attempt)
                
                # Traitement du paiement
                result = await gateway.process(payment_request)
                
                if result.success:
                    await self.log_successful_retry(payment_request, attempt, gateway)
                    return result
                    
                last_error = result.error
                
                # Analyser si retry est pertinent
                if not self.should_retry(result.error, attempt):
                    break
                
                # Délai avant retry
                delay = self.calculate_retry_delay(result.error, attempt)
                await asyncio.sleep(delay)
                
            except Exception as e:
                last_error = e
                await self.log_retry_error(payment_request, attempt, e)
        
        # Tous les retries ont échoué
        return PaymentResult(success=False, error=last_error)
    
    def select_gateway_for_attempt(self, payment_request, attempt):
        """Sélection intelligente du gateway selon la tentative"""
        if attempt == 1:
            return self.get_primary_gateway(payment_request)
        else:
            # Utiliser des gateways alternatifs pour les retries
            return self.get_alternative_gateway(payment_request, attempt)

class DynamicRouter:
    def __init__(self):
        self.performance_tracker = PerformanceTracker()
        self.cost_calculator = CostCalculator()
        
    def route_payment(self, payment_data):
        # Collecte des métriques en temps réel
        current_metrics = self.performance_tracker.get_current_metrics()
        
        routing_factors = {
            'success_rate': 0.4,    # 40% du poids
            'response_time': 0.2,   # 20% du poids  
            'cost': 0.3,            # 30% du poids
            'compliance': 0.1       # 10% du poids
        }
        
        gateway_scores = {}
        
        for gateway_id, gateway in self.gateways.items():
            metrics = current_metrics[gateway_id]
            
            # Calcul du score pondéré
            score = (
                metrics['success_rate'] * routing_factors['success_rate'] +
                (1 - metrics['avg_response_time'] / 5000) * routing_factors['response_time'] +  # Normalisation
                (1 - gateway.get_cost(payment_data) / 100) * routing_factors['cost'] +
                gateway.compliance_score * routing_factors['compliance']
            )
            
            gateway_scores[gateway_id] = score
        
        # Sélection du gateway avec le meilleur score
        best_gateway = max(gateway_scores, key=gateway_scores.get)
        
        await self.log_routing_decision(payment_data, gateway_scores, best_gateway)
        
        return self.gateways[best_gateway]

// Orchestration intelligente des méthodes de paiement
class PaymentMethodOptimizer {
    constructor() {
        this.methodPerformance = new Map();
        this.customerPreferences = new Map();
    }
    
    getOptimalMethods(customer, transaction) {
        const factors = {
            amount: transaction.amount,
            currency: transaction.currency,
            country: customer.country,
            customerSegment: customer.segment,
            deviceType: transaction.deviceType,
            timeOfDay: new Date().getHours()
        };
        
        // Méthodes disponibles par priorité optimisée
        const methods = [
            {
                type: 'card',
                priority: this.calculateCardPriority(factors),
                providers: this.getOptimalCardProviders(factors)
            },
            {
                type: 'digital_wallet',
                priority: this.calculateWalletPriority(factors),
                options: this.getAvailableWallets(factors)
            },
            {
                type: 'bank_transfer',
                priority: this.calculateBankTransferPriority(factors),
                providers: this.getBankTransferProviders(factors)
            },
            {
                type: 'buy_now_pay_later',
                priority: this.calculateBNPLPriority(factors),
                providers: this.getBNPLProviders(factors)
            }
        ];
        
        return methods.sort((a, b) => b.priority - a.priority);
    }
    
    calculateCardPriority(factors) {
        let priority = 0.7; // Base priority
        
        // Ajustements selon les facteurs
        if (factors.amount < 50) priority += 0.2;  // Meilleur pour petits montants
        if (factors.customerSegment === 'enterprise') priority += 0.1;
        if (factors.deviceType === 'desktop') priority += 0.1;
        
        // Performance historique
        const historicalPerformance = this.methodPerformance.get('card') || 0.85;
        priority *= historicalPerformance;
        
        return Math.min(priority, 1.0);
    }
    
    async optimizeCheckoutFlow(customer, transaction) {
        const optimalMethods = this.getOptimalMethods(customer, transaction);
        
        return {
            primaryMethod: optimalMethods[0],
            fallbackMethods: optimalMethods.slice(1, 3),
            uiConfiguration: {
                showSavedMethods: customer.hasSavedMethods,
                enableExpressCheckout: this.shouldEnableExpress(customer, transaction),
                defaultPaymentMethod: this.getCustomerPreference(customer.id)
            }
        };
    }
}

class MultiCurrencyProcessor:
    def __init__(self):
        self.currency_router = CurrencyRouter()
        self.fx_service = FXService()
        self.settlement_optimizer = SettlementOptimizer()
    
    async def process_international_payment(self, payment_request):
        # Détection de la devise optimale
        optimal_currency = await self.detect_optimal_currency(payment_request)
        
        # Conversion si nécessaire
        if payment_request.currency != optimal_currency:
            conversion_rate = await self.fx_service.get_rate(
                payment_request.currency, 
                optimal_currency
            )
            
            converted_amount = payment_request.amount * conversion_rate
            
            # Log de la conversion pour transparence
            await self.log_currency_conversion(
                payment_request.id,
                payment_request.currency,
                optimal_currency,
                conversion_rate
            )
            
            payment_request.original_amount = payment_request.amount
            payment_request.original_currency = payment_request.currency
            payment_request.amount = converted_amount
            payment_request.currency = optimal_currency
        
        # Sélection du gateway optimal pour cette devise
        gateway = self.currency_router.get_optimal_gateway(
            payment_request.currency,
            payment_request.merchant_country
        )
        
        return await gateway.process(payment_request)
    
    async def detect_optimal_currency(self, payment_request):
        """Détermine la devise optimale pour traitement"""
        factors = {
            'customer_country': payment_request.billing_address.country,
            'card_country': payment_request.card_country,
            'merchant_country': payment_request.merchant_country,
            'amount': payment_request.amount,
            'gateway_fees': await self.calculate_gateway_fees_by_currency(payment_request)
        }
        
        # Algorithme de sélection
        if factors['customer_country'] == factors['merchant_country']:
            return self.get_local_currency(factors['merchant_country'])
        
        # Optimisation par coûts
        cheapest_currency = min(
            factors['gateway_fees'].keys(),
            key=lambda curr: factors['gateway_fees'][curr]['total_cost']
        )
        
        return cheapest_currency

class RegionalComplianceManager {
    constructor() {
        this.regulations = {
            'EU': ['GDPR', 'PSD2', 'SCA'],
            'US': ['PCI_DSS', 'CCPA'],
            'UK': ['GDPR_UK', 'PSR', 'SCA'],
            'CA': ['PIPEDA', 'PCI_DSS']
        };
    }
    
    async enforceCompliance(payment_request) {
        const region = this.detectRegion(payment_request);
        const applicable_regulations = this.regulations[region] || [];
        
        const compliance_checks = await Promise.all(
            applicable_regulations.map(regulation => 
                this.checkCompliance(regulation, payment_request)
            )
        );
        
        const failed_checks = compliance_checks.filter(check => !check.compliant);
        
        if (failed_checks.length > 0) {
            throw new ComplianceViolationError(
                `Payment violates regulations: ${failed_checks.map(c => c.regulation).join(', ')}`,
                failed_checks
            );
        }
        
        return {
            compliant: true,
            checks_performed: compliance_checks,
            additional_requirements: this.getAdditionalRequirements(region, payment_request)
        };
    }
    
    async checkSCA(payment_request) {
        // Strong Customer Authentication pour l'Europe
        if (!this.isSCARequired(payment_request)) {
            return { compliant: true, sca_required: false };
        }
        
        const exemptions = await this.checkSCAExemptions(payment_request);
        
        if (exemptions.length > 0) {
            return { 
                compliant: true, 
                sca_required: false, 
                exemption_applied: exemptions[0] 
            };
        }
        
        // SCA requis - vérifier que l'authentification est présente
        const authentication_result = payment_request.authentication_result;
        
        if (!authentication_result || authentication_result.status !== 'Y') {
            return {
                compliant: false,
                sca_required: true,
                action_required: 'AUTHENTICATE_CUSTOMER'
            };
        }
        
        return { compliant: true, sca_required: true, authenticated: true };
    }
}

class PaymentAnalytics:
    def __init__(self):
        self.metrics_calculator = MetricsCalculator()
        self.alerting_system = AlertingSystem()
    
    def calculate_key_metrics(self, time_period='24h'):
        metrics = {}
        
        # Métriques de base
        metrics['authorization_rate'] = self.calculate_auth_rate(time_period)
        metrics['settlement_rate'] = self.calculate_settlement_rate(time_period)
        metrics['decline_rate'] = self.calculate_decline_rate(time_period)
        metrics['chargeback_rate'] = self.calculate_chargeback_rate(time_period)
        
        # Métriques financières
        metrics['total_volume'] = self.calculate_total_volume(time_period)
        metrics['average_transaction_value'] = self.calculate_avg_transaction(time_period)
        metrics['processing_costs'] = self.calculate_processing_costs(time_period)
        metrics['net_revenue'] = metrics['total_volume'] - metrics['processing_costs']
        
        # Métriques de performance
        metrics['average_processing_time'] = self.calculate_avg_processing_time(time_period)
        metrics['gateway_uptime'] = self.calculate_gateway_uptime(time_period)
        metrics['retry_success_rate'] = self.calculate_retry_success_rate(time_period)
        
        # Métriques de sécurité
        metrics['fraud_detection_rate'] = self.calculate_fraud_detection_rate(time_period)
        metrics['false_positive_rate'] = self.calculate_false_positive_rate(time_period)
        metrics['3ds_challenge_rate'] = self.calculate_3ds_challenge_rate(time_period)
        
        return metrics
    
    def generate_insights(self, metrics, historical_data):
        """Génère des insights actionables"""
        insights = []
        
        # Détection des anomalies
        if metrics['decline_rate'] > historical_data['decline_rate_avg'] * 1.5:
            insights.append({
                'type': 'WARNING',
                'metric': 'decline_rate',
                'message': 'Decline rate significantly higher than average',
                'recommended_action': 'Investigate payment processor issues'
            })
        
        # Opportunités d'optimisation
        if metrics['retry_success_rate'] < 0.3:
            insights.append({
                'type': 'OPTIMIZATION',
                'metric': 'retry_success_rate', 
                'message': 'Low retry success rate indicates suboptimal retry strategy',
                'recommended_action': 'Review and optimize retry logic'
            })
        
        # Alertes de coûts
        cost_increase = (metrics['processing_costs'] - historical_data['avg_processing_costs']) / historical_data['avg_processing_costs']
        if cost_increase > 0.2:
            insights.append({
                'type': 'COST_ALERT',
                'metric': 'processing_costs',
                'message': f'Processing costs increased by {cost_increase:.1%}',
                'recommended_action': 'Review gateway routing and fee structures'
            })
        
        return insights

class PaymentABTestFramework {
    constructor() {
        this.experiments = new Map();
        this.results_tracker = new ResultsTracker();
    }
    
    createExperiment(config) {
        const experiment = {
            id: config.id,
            name: config.name,
            hypothesis: config.hypothesis,
            variations: config.variations,
            traffic_split: config.traffic_split,
            success_metric: config.success_metric,
            start_date: new Date(),
            min_sample_size: config.min_sample_size || 1000,
            significance_level: config.significance_level || 0.95
        };
        
        this.experiments.set(config.id, experiment);
        return experiment;
    }
    
    assignVariation(user_id, experiment_id) {
        const experiment = this.experiments.get(experiment_id);
        if (!experiment) return null;
        
        // Hash-based consistent assignment
        const hash = this.hashUserId(user_id + experiment_id);
        const bucket = hash % 100;
        
        let cumulative = 0;
        for (const [variation, traffic] of Object.entries(experiment.traffic_split)) {
            cumulative += traffic;
            if (bucket < cumulative) {
                // Log assignment
                this.logAssignment(user_id, experiment_id, variation);
                return variation;
            }
        }
        
        return experiment.variations[0]; // Fallback to control
    }
    
    // Exemple d'expérimentation sur le checkout flow
    async optimizeCheckoutFlow() {
        const experiment = this.createExperiment({
            id: 'checkout_flow_v2',
            name: 'One-step vs Multi-step Checkout',
            hypothesis: 'One-step checkout will increase conversion rate',
            variations: ['control', 'one_step'],
            traffic_split: { control: 50, one_step: 50 },
            success_metric: 'payment_success_rate',
            min_sample_size: 2000
        });
        
        return experiment;
    }
    
    async analyzeResults(experiment_id) {
        const experiment = this.experiments.get(experiment_id);
        const results = await this.results_tracker.getResults(experiment_id);
        
        // Statistical significance testing
        const significance_test = this.performSignificanceTest(
            results.control,
            results.treatment,
            experiment.significance_level
        );
        
        return {
            experiment: experiment,
            results: results,
            statistical_significance: significance_test,
            recommendation: this.generateRecommendation(results, significance_test)
        };
    }
}

class SubscriptionManager:
    def __init__(self):
        self.retry_scheduler = RetryScheduler()
        self.dunning_manager = DunningManager()
        self.churn_predictor = ChurnPredictor()
        
    async def process_recurring_payment(self, subscription):
        try:
            # 1. Vérification pré-facturation
            await self.pre_billing_checks(subscription)
            
            # 2. Traitement du paiement
            payment_result = await self.charge_subscription(subscription)
            
            if payment_result.success:
                await self.handle_successful_payment(subscription, payment_result)
            else:
                await self.handle_failed_payment(subscription, payment_result)
                
        except Exception as e:
            await self.handle_billing_error(subscription, e)
    
    async def handle_failed_payment(self, subscription, payment_result):
        """Gestion intelligente des échecs de paiement récurrent"""
        
        # Analyse du type d'échec
        failure_reason = self.classify_failure(payment_result.error)
        
        retry_strategy = self.get_retry_strategy(failure_reason, subscription)
        
        if retry_strategy['should_retry']:
            # Programmer les tentatives de retry
            await self.schedule_retries(subscription, retry_strategy)
            
            # Démarrer le processus dunning
            await self.dunning_manager.start_dunning_sequence(subscription)
            
        else:
            # Échec définitif - suspendre l'abonnement
            await self.suspend_subscription(subscription, payment_result.error)
    
    def get_retry_strategy(self, failure_reason, subscription):
        """Stratégie de retry adaptée selon le type d'échec"""
        
        base_strategies = {
            'insufficient_funds': {
                'should_retry': True,
                'retry_intervals': [1, 3, 7, 14],  # jours
                'max_retries': 4,
                'dunning_email_sequence': 'soft_dunning'
            },
            'expired_card': {
                'should_retry': True,
                'retry_intervals': [1, 7, 14],
                'max_retries': 3,
                'dunning_email_sequence': 'card_update_required',
                'card_update_prompt': True
            },
            'card_declined': {
                'should_retry': True,
                'retry_intervals': [3, 7],
                'max_retries': 2,
                'dunning_email_sequence': 'payment_method_update'
            },
            'do_not_honor': {
                'should_retry': False,
                'immediate_action': 'request_new_payment_method'
            }
        }
        
        strategy = base_strategies.get(failure_reason, base_strategies['card_declined'])
        
        # Personnalisation selon l'historique client
        if subscription.customer.payment_reliability_score > 0.9:
            # Client fiable - plus de tentatives
            strategy['retry_intervals'].append(21)
            strategy['max_retries'] += 1
            
        return strategy

class DunningSequence:
    def __init__(self):
        self.email_templates = {
            'soft_reminder': 'payment_failed_soft',
            'urgent_reminder': 'payment_failed_urgent', 
            'final_notice': 'payment_failed_final',
            'service_suspension': 'service_suspended',
            'winback_offer': 'winback_special_offer'
        }
        
    async def execute_dunning_sequence(self, subscription):
        sequence = self.get_sequence_for_subscription(subscription)
        
        for step in sequence:
            await asyncio.sleep(step['delay_hours'] * 3600)
            
            # Vérifier si le paiement a réussi entre temps
            if await self.is_subscription_current(subscription):
                break
                
            await self.execute_dunning_step(subscription, step)
    
    def get_sequence_for_subscription(self, subscription):
        """Séquence adaptée selon le profil client"""
        
        if subscription.customer.lifetime_value > 1000:
            # Clients high-value - approche plus douce
            return [
                {'type': 'email', 'template': 'soft_reminder', 'delay_hours': 24},
                {'type': 'email', 'template': 'personal_outreach', 'delay_hours': 168}, # 7 jours
                {'type': 'phone_call', 'priority': 'high', 'delay_hours': 336}, # 14 jours
                {'type': 'email', 'template': 'winback_offer', 'delay_hours': 504} # 21 jours
            ]
        else:
            # Séquence standard
            return [
                {'type': 'email', 'template': 'soft_reminder', 'delay_hours': 24},
                {'type': 'email', 'template': 'urgent_reminder', 'delay_hours': 168},
                {'type': 'email', 'template': 'final_notice', 'delay_hours': 336},
                {'type': 'service_action', 'action': 'suspend', 'delay_hours': 504}
            ]
    
    async def optimize_dunning_performance(self):
        """Optimisation continue des séquences dunning"""
        
        # Analyse des performances par template
        performance_data = await self.analyze_template_performance()
        
        # A/B test des nouvelles séquences
        winning_sequences = await self.ab_test_sequences()
        
        # Mise à jour des séquences selon les résultats
        for customer_segment, sequence in winning_sequences.items():
            await self.update_sequence_for_segment(customer_segment, sequence)

class ChargebackPrevention:
    def __init__(self):
        self.early_warning_systems = {
            'visa': VisaRDRClient(),
            'mastercard': MastercardEthocaClient(),
            'amex': AmexDisputeResolutionClient()
        }
        
    async def monitor_transactions(self):
        """Monitoring en temps réel des transactions à risque"""
        
        # Récupération des alertes early warning
        alerts = await self.get_early_warning_alerts()
        
        for alert in alerts:
            transaction = await self.get_transaction(alert.transaction_id)
            
            # Analyse du risque de chargeback
            risk_score = await self.assess_chargeback_risk(transaction, alert)
            
            if risk_score > 0.8:
                # Risque élevé - action préventive
                await self.initiate_proactive_refund(transaction, alert)
            elif risk_score > 0.5:
                # Risque modéré - contacter le client
                await self.initiate_customer_outreach(transaction, alert)
            
    async def assess_chargeback_risk(self, transaction, alert):
        """Évaluation du risque de chargeback avec ML"""
        
        features = {
            # Caractéristiques transaction
            'amount': transaction.amount,
            'merchant_category': transaction.merchant_category_code,
            'transaction_age_hours': (datetime.now() - transaction.created_at).total_seconds() / 3600,
            
            # Caractéristiques client
            'customer_history_months': (datetime.now() - transaction.customer.created_at).days / 30,
            'previous_chargebacks': transaction.customer.chargeback_count,
            'customer_satisfaction_score': await self.get_customer_satisfaction(transaction.customer),
            
            # Caractéristiques alert
            'alert_type': alert.type,
            'alert_confidence': alert.confidence_score,
            'time_to_alert_hours': (alert.created_at - transaction.created_at).total_seconds() / 3600
        }
        
        # Modèle ML pour prédiction
        risk_score = self.chargeback_risk_model.predict_proba([list(features.values())])[0][1]
        
        return risk_score
    
    async def initiate_proactive_refund(self, transaction, alert):
        """Remboursement proactif pour éviter chargeback"""
        
        refund_result = await self.payment_processor.refund(
            transaction_id=transaction.id,
            amount=transaction.amount,
            reason='chargeback_prevention'
        )
        
        if refund_result.success:
            # Notification au client
            await self.send_proactive_refund_notification(transaction, refund_result)
            
            # Tracking pour améliorer le modèle
            await self.track_prevention_action(transaction, alert, 'proactive_refund', True)
        
        return refund_result

class DisputeManager:
    def __init__(self):
        self.evidence_collector = EvidenceCollector()
        self.response_generator = ResponseGenerator()
        
    async def handle_chargeback(self, chargeback):
        """Gestion automatisée des chargebacks"""
        
        # 1. Classification du chargeback
        chargeback_type = self.classify_chargeback(chargeback)
        
        # 2. Décision de contestation
        contest_decision = await self.should_contest_chargeback(chargeback, chargeback_type)
        
        if contest_decision['should_contest']:
            # 3. Collecte automatique des preuves
            evidence = await self.evidence_collector.collect_evidence(chargeback)
            
            # 4. Génération de la réponse
            response = await self.response_generator.generate_response(
                chargeback, chargeback_type, evidence
            )
            
            # 5. Soumission de la contestation
            await self.submit_dispute_response(chargeback, response)
            
        else:
            # Accept the chargeback
            await self.accept_chargeback(chargeback, contest_decision['reason'])
    
    async def should_contest_chargeback(self, chargeback, chargeback_type):
        """Décision intelligente de contestation"""
        
        factors = {
            'amount': chargeback.amount,
            'chargeback_reason': chargeback_type,
            'evidence_strength': await self.assess_evidence_strength(chargeback),
            'win_probability': await self.predict_win_probability(chargeback, chargeback_type),
            'cost_benefit_ratio': self.calculate_cost_benefit(chargeback)
        }
        
        # Règles de décision
        if factors['amount'] < 50:
            return {'should_contest': False, 'reason': 'amount_too_low'}
            
        if factors['evidence_strength'] < 0.3:
            return {'should_contest': False, 'reason': 'insufficient_evidence'}
            
        if factors['win_probability'] < 0.4:
            return {'should_contest': False, 'reason': 'low_win_probability'}
            
        if factors['cost_benefit_ratio'] < 1.5:
            return {'should_contest': False, 'reason': 'unfavorable_cost_benefit'}
        
        return {
            'should_contest': True, 
            'confidence': min(factors['win_probability'], factors['evidence_strength']),
            'factors': factors
        }