「この専用機器（UTM）を入れないと取引停止になる」という高額リース営業にご注意：
本当に必要な対策の見極め方とセカンドオピニオン

#![forbid(unsafe_code)]

/// Security investment & threat coverage parameters for SME second-opinion auditing.
#[derive(Debug, Clone, Copy)]
pub struct LeaseProposalSpec {
    pub monthly_lease_jpy: u64,
    pub lease_months: u32,
    pub upfront_fee_jpy: u64,
    pub hardware_street_value_jpy: u64,
    pub tls_mitm_inspection_enabled: bool,
    pub includes_immutable_backup: bool,
    pub includes_fido2_mfa_deployment: bool,
}

#[derive(Debug, Clone, Copy)]
pub struct TrafficEnvironment {
    /// Ratio of TLS 1.3 / QUIC encrypted traffic (0.0..=1.0, typically 0.95)
    pub encrypted_traffic_ratio: f64,
    /// Ratio of remote/cloud work bypassing office perimeter (0.0..=1.0)
    pub off_premise_work_ratio: f64,
    /// Estimated Annualized Loss Expectancy before mitigation (JPY)
    pub baseline_ale_jpy: u64,
}

#[derive(Debug, Clone, Copy, PartialEq)]
pub enum AuditVerdict {
    SoundInvestment,
    OverpricedLowCoverageWarning,
    CriticalLeaseMarkupAlert,
}

#[derive(Debug, Clone, Copy)]
pub struct SecondOpinionReport {
    pub total_contract_cost_jpy: u64,
    pub markup_multiple: f64,
    pub effective_threat_coverage: f64,
    pub five_year_rosi: f64,
    pub verdict: AuditVerdict,
}

/// Computes effective threat coverage and 5-year ROSI for a proposed UTM lease contract.
pub fn evaluate_utm_lease_proposal(
    proposal: &LeaseProposalSpec,
    env: &TrafficEnvironment,
) -> SecondOpinionReport {
    let total_cost = proposal.upfront_fee_jpy
        + proposal.monthly_lease_jpy.saturating_mul(u64::from(proposal.lease_months));

    let base_hw = proposal.hardware_street_value_jpy.max(1);
    let markup_multiple = (total_cost as f64) / (base_hw as f64);

    let alpha = env.encrypted_traffic_ratio.clamp(0.0, 1.0);
    let beta = env.off_premise_work_ratio.clamp(0.0, 1.0);

    // Signature inspection accuracy on cleartext vs metadata-only SNI/IP filtering
    let p_sig = 0.88_f64;
    let p_meta = 0.12_f64;

    let perimeter_visibility = if proposal.tls_mitm_inspection_enabled {
        (1.0 - beta) * p_sig
    } else {
        (1.0 - beta) * ((1.0 - alpha) * p_sig + alpha * p_meta)
    };

    // Additive risk reduction from FIDO2 MFA and immutable ZFS backup
    let mfa_bonus = if proposal.includes_fido2_mfa_deployment { 0.42 } else { 0.0 };
    let backup_bonus = if proposal.includes_immutable_backup { 0.35 } else { 0.0 };
    let effective_coverage = (perimeter_visibility + mfa_bonus + backup_bonus).clamp(0.0, 0.99);

    let years = (f64::from(proposal.lease_months) / 12.0).max(1.0);
    let mitigated_loss = (env.baseline_ale_jpy as f64) * years * effective_coverage;
    let five_year_rosi = if total_cost > 0 {
        (mitigated_loss - (total_cost as f64)) / (total_cost as f64)
    } else {
        0.0
    };

    let verdict = if markup_multiple >= 6.0 && effective_coverage < 0.25 {
        AuditVerdict::CriticalLeaseMarkupAlert
    } else if effective_coverage < 0.40 || five_year_rosi < 0.0 {
        AuditVerdict::OverpricedLowCoverageWarning
    } else {
        AuditVerdict::SoundInvestment
    };

    SecondOpinionReport {
        total_contract_cost_jpy: total_cost,
        markup_multiple,
        effective_threat_coverage: effective_coverage,
        five_year_rosi,
        verdict,
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn detects_overpriced_uninspected_utm_lease() {
        let proposal = LeaseProposalSpec {
            monthly_lease_jpy: 38_000,
            lease_months: 60,
            upfront_fee_jpy: 0,
            hardware_street_value_jpy: 180_000,
            tls_mitm_inspection_enabled: false,
            includes_immutable_backup: false,
            includes_fido2_mfa_deployment: false,
        };
        let env = TrafficEnvironment {
            encrypted_traffic_ratio: 0.95,
            off_premise_work_ratio: 0.30,
            baseline_ale_jpy: 1_500_000,
        };
        let report = evaluate_utm_lease_proposal(&proposal, &env);
        assert_eq!(report.total_contract_cost_jpy, 2_280_000);
        assert!(report.effective_threat_coverage < 0.15);
        assert_eq!(report.verdict, AuditVerdict::CriticalLeaseMarkupAlert);
    }
}