def calculate_refund_cost(original_amount, processing_fee_rate=0.029):
    """Calculate true cost of processing a refund"""
    
    processing_fee = original_amount * processing_fee_rate + 30  # Stripe's fee
    
    return {
        'refunded_to_customer': original_amount,
        'processing_fee_lost': processing_fee,  # Usually not returned
        'total_cost': original_amount + processing_fee,
        'chargeback_fee': 0
    }

# Example: $100 purchase
refund_cost = calculate_refund_cost(10000)  # $100.00
# Total cost: $100 + $3.20 = $103.20

def calculate_chargeback_cost(original_amount, chargeback_fee=1500):
    """Calculate cost of losing a chargeback"""
    
    return {
        'disputed_amount': original_amount,
        'chargeback_fee': chargeback_fee,  # $15 typical fee
        'total_cost': original_amount + chargeback_fee,
        'processing_fee_lost': True  # Original processing fees also lost
    }

# Example: $100 purchase
chargeback_cost = calculate_chargeback_cost(10000)
# Total cost: $100 + $15 = $115 (plus original processing fees)

def handle_complete_dispute_lifecycle():
    """All dispute events in Stripe"""

    # 1. Dispute created (chargeback filed)
    if event['type'] == 'charge.dispute.created':
        dispute = event['data']['object']
        # - Funds immediately withdrawn from your balance
        # - Chargeback fee charged ($15+)
        # - Customer already has money back from their bank
        handle_dispute_created(dispute)

    # 2. Dispute updated (evidence submitted or other changes)
    elif event['type'] == 'charge.dispute.updated':
        # Evidence was submitted or dispute status changed
        handle_dispute_updated(event['data']['object'])

    # 3. Dispute closed - final outcome
    elif event['type'] == 'charge.dispute.closed':
        dispute = event['data']['object']

        if dispute['status'] == 'lost':
            # You lost - keep the loss and chargeback fee
            handle_dispute_lost(dispute)
        elif dispute['status'] == 'won':
            # You won - disputed amount returned (keep chargeback fee)
            handle_dispute_won(dispute)
        elif dispute['status'] == 'accepted':
            # You accepted - same as lost
            handle_dispute_accepted(dispute)

def should_refund_proactively(customer_complaint, charge_details):
    """Decide whether to refund before chargeback occurs"""

    risk_factors = {
        'complaint_type': customer_complaint.get('type'),
        'charge_amount': charge_details['amount'],
        'customer_history': get_customer_dispute_history(charge_details['customer']),
        'evidence_strength': assess_evidence_strength(charge_details['id'])
    }

    # Refund proactively if:
    if (risk_factors['complaint_type'] in ['service_not_delivered', 'defective_product']
        and risk_factors['evidence_strength'] < 0.7):

        return {
            'action': 'refund',
            'reason': 'Prevent chargeback - weak evidence',
            'cost_savings': calculate_chargeback_vs_refund_cost(charge_details['amount'])
        }

    # Let dispute happen if strong evidence
    elif risk_factors['evidence_strength'] > 0.8:
        return {
            'action': 'prepare_dispute_response',
            'reason': 'Strong evidence - likely to win dispute'
        }

    return {'action': 'evaluate_manually'}

def calculate_chargeback_vs_refund_cost(amount):
    """Compare costs of refunding vs losing chargeback"""

    refund_cost = amount  # Just lose the sale amount
    chargeback_cost = amount + 1500  # Lose sale + $15 fee + dispute ratio impact

    return {
        'refund_cost': refund_cost,
        'chargeback_cost': chargeback_cost,
        'savings_by_refunding': chargeback_cost - refund_cost
    }

def automated_dispute_strategy(dispute):
    """Automated decision on how to handle disputes"""

    dispute_analysis = analyze_dispute_strength(dispute)

    if dispute_analysis['win_probability'] > 0.75:
        # High chance of winning - fight it
        evidence = gather_comprehensive_evidence(dispute['charge'])

        stripe.Dispute.modify(
            dispute['id'],
            evidence=evidence,
            submit=True  # Auto-submit evidence
        )

        return {'strategy': 'fight', 'confidence': 'high'}

    elif dispute_analysis['win_probability'] < 0.25:
        # Low chance of winning - accept it
        stripe.Dispute.modify(
            dispute['id'],
            submit=False  # Accept the dispute
        )

        return {'strategy': 'accept', 'reason': 'low_win_probability'}

    else:
        # Uncertain - manual review required
        flag_for_manual_review(dispute)
        return {'strategy': 'manual_review'}

def analyze_dispute_strength(dispute):
    """Analyze likelihood of winning dispute"""

    factors = {
        'reason_code': dispute['reason'],
        'evidence_available': check_available_evidence(dispute['charge']),
        'customer_history': get_customer_history(dispute['customer']),
        'transaction_details': get_transaction_context(dispute['charge'])
    }

    # AI/rules-based scoring
    win_probability = calculate_win_probability(factors)

    return {
        'win_probability': win_probability,
        'key_factors': factors,
        'recommended_evidence': suggest_evidence_types(dispute['reason'])
    }

def should_refund_proactively(customer_complaint, charge_details):
    """Decide whether to refund before chargeback occurs"""
    
    risk_factors = {
        'complaint_type': customer_complaint.get('type'),
        'charge_amount': charge_details['amount'],
        'customer_history': get_customer_dispute_history(charge_details['customer']),
        'evidence_strength': assess_evidence_strength(charge_details['id'])
    }
    
    # Refund proactively if:
    if (risk_factors['complaint_type'] in ['service_not_delivered', 'defective_product'] 
        and risk_factors['evidence_strength'] < 0.7):
        
        return {
            'action': 'refund',
            'reason': 'Prevent chargeback - weak evidence',
            'cost_savings': calculate_chargeback_vs_refund_cost(charge_details['amount'])
        }
    
    # Let dispute happen if strong evidence
    elif risk_factors['evidence_strength'] > 0.8:
        return {
            'action': 'prepare_dispute_response',
            'reason': 'Strong evidence - likely to win dispute'
        }
    
    return {'action': 'evaluate_manually'}

def calculate_chargeback_vs_refund_cost(amount):
    """Compare costs of refunding vs losing chargeback"""
    
    refund_cost = amount  # Just lose the sale amount
    chargeback_cost = amount + 1500  # Lose sale + $15 fee + dispute ratio impact
    
    return {
        'refund_cost': refund_cost,
        'chargeback_cost': chargeback_cost,
        'savings_by_refunding': chargeback_cost - refund_cost
    }

def automated_dispute_strategy(dispute):
    """Automated decision on how to handle disputes"""
    
    dispute_analysis = analyze_dispute_strength(dispute)
    
    if dispute_analysis['win_probability'] > 0.75:
        # High chance of winning - fight it
        evidence = gather_comprehensive_evidence(dispute['charge'])
        
        stripe.Dispute.modify(
            dispute['id'],
            evidence=evidence,
            submit=True  # Auto-submit evidence
        )
        
        return {'strategy': 'fight', 'confidence': 'high'}
    
    elif dispute_analysis['win_probability'] < 0.25:
        # Low chance of winning - accept it
        stripe.Dispute.modify(
            dispute['id'],
            submit=False  # Accept the dispute
        )
        
        return {'strategy': 'accept', 'reason': 'low_win_probability'}
    
    else:
        # Uncertain - manual review required
        flag_for_manual_review(dispute)
        return {'strategy': 'manual_review'}

def analyze_dispute_strength(dispute):
    """Analyze likelihood of winning dispute"""
    
    factors = {
        'reason_code': dispute['reason'],
        'evidence_available': check_available_evidence(dispute['charge']),
        'customer_history': get_customer_history(dispute['customer']),
        'transaction_details': get_transaction_context(dispute['charge'])
    }
    
    # AI/rules-based scoring
    win_probability = calculate_win_probability(factors)
    
    return {
        'win_probability': win_probability,
        'key_factors': factors,
        'recommended_evidence': suggest_evidence_types(dispute['reason'])
    }

def compare_all_resolution_costs(charge_amount):
    """Compare costs of different dispute resolution approaches"""
    
    chargeback_fee = 1500  # $15
    processing_fee = int(charge_amount * 0.029 + 30)  # Stripe's fee
    
    scenarios = {
        'proactive_refund': {
            'customer_gets': charge_amount,
            'you_lose': charge_amount + processing_fee,
            'chargeback_fee': 0,
            'dispute_ratio_impact': 0
        },
        
        'win_dispute': {
            'customer_gets': 0,  # They keep initial chargeback but you get it back
            'you_lose': chargeback_fee,  # Only lose the chargeback fee
            'chargeback_fee': chargeback_fee,
            'dispute_ratio_impact': 1  # Still counts toward dispute ratio
        },
        
        'lose_dispute': {
            'customer_gets': charge_amount,
            'you_lose': charge_amount + chargeback_fee + processing_fee,
            'chargeback_fee': chargeback_fee,
            'dispute_ratio_impact': 1
        }
    }
    
    return scenarios

# Example for $100 charge:
costs = compare_all_resolution_costs(10000)  # $100

def monitor_dispute_ratios():
    """Monitor dispute ratios to avoid card network penalties"""
    
    # Card networks monitor your dispute ratios
    thresholds = {
        'visa': 0.009,      # 0.9% dispute ratio threshold
        'mastercard': 0.01, # 1.0% dispute ratio threshold
        'monitoring_period': 'monthly'
    }
    
    current_ratios = calculate_current_dispute_ratios()
    
    if current_ratios['overall'] > 0.0065:  # Approaching thresholds
        # Implement aggressive refund policy
        return {
            'action': 'increase_proactive_refunds',
            'target_ratio': 0.005,
            'measures': [
                'auto_refund_service_complaints',
                'faster_customer_service_resolution', 
                'improve_product_quality_checks'
            ]
        }
    
    return {'status': 'ratios_healthy'}