def expected_annual_loss(threat_scenarios):
    """
    Bereken het verwachte jaarlijkse verlies over de dreigingsscenario's heen.
 
    Elk scenario heeft:
    - frequency: verwacht aantal keer per jaar
    - impact: kosten per voorval
    - current_mitigation: fractie die door bestaande controls wordt gemitigeerd (0-1)
    """
    total_eal = 0
 
    for scenario in threat_scenarios:
        residual_frequency = (
            scenario["frequency"] *
            (1 - scenario["current_mitigation"])
        )
        scenario_eal = residual_frequency * scenario["impact"]
        total_eal += scenario_eal
 
        scenario["expected_annual_loss"] = scenario_eal
 
    return {
        "total_expected_annual_loss": total_eal,
        "scenarios": threat_scenarios
    }
 
# Voorbeeld van dreigingsscenario's voor een AI-chatbot
scenarios = [
    {
        "name": "Prompt injection data exfiltration",
        "frequency": 12,          # 12 geslaagde pogingen per jaar
        "impact": 250_000,        # Gemiddelde kosten per incident
        "current_mitigation": 0.7  # 70% momenteel gemitigeerd
    },
    {
        "name": "Jailbreak producing harmful content",
        "frequency": 50,
        "impact": 50_000,
        "current_mitigation": 0.85
    },
    {
        "name": "Training data extraction",
        "frequency": 2,
        "impact": 1_000_000,
        "current_mitigation": 0.5
    },
    {
        "name": "Reputational incident (viral AI failure)",
        "frequency": 4,
        "impact": 500_000,
        "current_mitigation": 0.6
    }
]
 
result = expected_annual_loss(scenarios)
# Totale EAL = som van het ongemitigeerde risico over alle scenario's

def calculate_rosi(defense_investment):
    """
    Bereken de Return on Security Investment.
 
    ROSI = (Risicoreductie - Verdedigingskosten) / Verdedigingskosten
    """
    # Jaarlijks risico vóór de verdediging
    risk_before = defense_investment["annual_risk_before"]
 
    # Jaarlijks risico na de verdediging (risico * (1 - effectiviteit))
    risk_after = risk_before * (1 - defense_investment["effectiveness"])
 
    # Jaarlijkse risicoreductie
    risk_reduction = risk_before - risk_after
 
    # Jaarlijkse verdedigingskosten (geamortiseerde implementatie + operationeel)
    annual_cost = (
        defense_investment["implementation_cost"] /
        defense_investment["amortization_years"] +
        defense_investment["annual_operational_cost"]
    )
 
    rosi = (risk_reduction - annual_cost) / annual_cost
 
    return {
        "rosi": rosi,
        "rosi_percent": rosi * 100,
        "risk_reduction": risk_reduction,
        "annual_cost": annual_cost,
        "payback_period_months": (
            defense_investment["implementation_cost"] /
            (risk_reduction / 12)
            if risk_reduction > 0 else float('inf')
        ),
        "recommendation": "invest" if rosi > 0 else "reconsider"
    }
 
# Voorbeeld: het uitrollen van een prompt shield evalueren
prompt_shield = {
    "annual_risk_before": 1_500_000,  # Jaarlijks risico door injection
    "effectiveness": 0.75,            # Blokkeert 75% van de aanvallen
    "implementation_cost": 200_000,   # Eenmalige engineering
    "annual_operational_cost": 50_000, # Hosting, onderhoud
    "amortization_years": 3           # Amortiseer de implementatie
}
 
result = calculate_rosi(prompt_shield)
# risk_reduction = 1.125.000
# annual_cost = 66.667 + 50.000 = 116.667
# ROSI = (1.125.000 - 116.667) / 116.667 = 8,64 = 864%

def compare_defenses(defense_options, total_budget):
    """
    Vergelijk meerdere verdedigingsopties en adviseer de optimale verdeling.
    """
    analyzed = []
 
    for name, defense in defense_options.items():
        rosi = calculate_rosi(defense)
        analyzed.append({
            "name": name,
            "rosi": rosi["rosi"],
            "risk_reduction": rosi["risk_reduction"],
            "annual_cost": rosi["annual_cost"],
            "efficiency": rosi["risk_reduction"] / rosi["annual_cost"]
        })
 
    # Sorteer op efficiëntie (risicoreductie per dollar)
    analyzed.sort(key=lambda x: x["efficiency"], reverse=True)
 
    # Greedy verdeling: investeer eerst in de meest efficiënte verdedigingen
    remaining_budget = total_budget
    selected = []
 
    for defense in analyzed:
        if defense["annual_cost"] <= remaining_budget:
            selected.append(defense)
            remaining_budget -= defense["annual_cost"]
 
    return {
        "selected_defenses": selected,
        "total_risk_reduction": sum(d["risk_reduction"] for d in selected),
        "total_cost": total_budget - remaining_budget,
        "remaining_budget": remaining_budget,
        "ranked_options": analyzed
    }

def red_team_roi(engagement_cost, findings):
    """
    Bereken de ROI van een red team-engagement.
 
    findings: lijst van kwetsbaarheden met geschatte impact
    """
    total_risk_identified = sum(
        finding["estimated_annual_impact"] *
        finding["exploitation_probability"]
        for finding in findings
    )
 
    # Ga ervan uit dat 70% van de bevindingen wordt verholpen
    remediation_rate = 0.7
    risk_mitigated = total_risk_identified * remediation_rate
 
    roi = (risk_mitigated - engagement_cost) / engagement_cost
 
    return {
        "engagement_cost": engagement_cost,
        "vulnerabilities_found": len(findings),
        "total_risk_identified": total_risk_identified,
        "risk_mitigated": risk_mitigated,
        "roi": roi,
        "roi_percent": roi * 100,
        "cost_per_vulnerability": engagement_cost / max(len(findings), 1)
    }