datasynth_eval/gates/

engine.rs

//! Quality gate evaluation engine.
//!
//! Evaluates generation results against configurable pass/fail criteria.

use serde::{Deserialize, Serialize};

use crate::ComprehensiveEvaluation;

/// A quality metric that can be checked by a gate.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum QualityMetric {
    /// Benford's Law Mean Absolute Deviation.
    BenfordMad,
    /// Balance sheet coherence rate (0.0–1.0).
    BalanceCoherence,
    /// Document chain integrity rate (0.0–1.0).
    DocumentChainIntegrity,
    /// Correlation preservation score (0.0–1.0).
    CorrelationPreservation,
    /// Temporal consistency score (0.0–1.0).
    TemporalConsistency,
    /// Privacy MIA AUC-ROC score.
    PrivacyMiaAuc,
    /// Data completion rate (0.0–1.0).
    CompletionRate,
    /// Duplicate rate (0.0–1.0).
    DuplicateRate,
    /// Referential integrity rate (0.0–1.0).
    ReferentialIntegrity,
    /// Intercompany match rate (0.0–1.0).
    IcMatchRate,
    /// Custom metric identified by name.
    Custom(String),
}

impl std::fmt::Display for QualityMetric {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::BenfordMad => write!(f, "benford_mad"),
            Self::BalanceCoherence => write!(f, "balance_coherence"),
            Self::DocumentChainIntegrity => write!(f, "document_chain_integrity"),
            Self::CorrelationPreservation => write!(f, "correlation_preservation"),
            Self::TemporalConsistency => write!(f, "temporal_consistency"),
            Self::PrivacyMiaAuc => write!(f, "privacy_mia_auc"),
            Self::CompletionRate => write!(f, "completion_rate"),
            Self::DuplicateRate => write!(f, "duplicate_rate"),
            Self::ReferentialIntegrity => write!(f, "referential_integrity"),
            Self::IcMatchRate => write!(f, "ic_match_rate"),
            Self::Custom(name) => write!(f, "custom:{}", name),
        }
    }
}

/// Comparison operator for threshold checks.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum Comparison {
    /// Greater than or equal to threshold.
    Gte,
    /// Less than or equal to threshold.
    Lte,
    /// Equal to threshold (with epsilon).
    Eq,
    /// Between two thresholds (inclusive). Uses `threshold` as lower and `upper_threshold` as upper.
    Between,
}

/// Strategy for handling gate failures.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum FailStrategy {
    /// Stop checking on first failure.
    FailFast,
    /// Check all gates and collect all failures.
    #[default]
    CollectAll,
}

/// A single quality gate with a metric, threshold, and comparison.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct QualityGate {
    /// Human-readable name for this gate.
    pub name: String,
    /// The metric to check.
    pub metric: QualityMetric,
    /// Threshold value for comparison.
    pub threshold: f64,
    /// Upper threshold for Between comparison.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub upper_threshold: Option<f64>,
    /// How to compare the metric value against the threshold.
    pub comparison: Comparison,
}

impl QualityGate {
    /// Create a new quality gate.
    pub fn new(
        name: impl Into<String>,
        metric: QualityMetric,
        threshold: f64,
        comparison: Comparison,
    ) -> Self {
        Self {
            name: name.into(),
            metric,
            threshold,
            upper_threshold: None,
            comparison,
        }
    }

    /// Create a gate that requires metric >= threshold.
    pub fn gte(name: impl Into<String>, metric: QualityMetric, threshold: f64) -> Self {
        Self::new(name, metric, threshold, Comparison::Gte)
    }

    /// Create a gate that requires metric <= threshold.
    pub fn lte(name: impl Into<String>, metric: QualityMetric, threshold: f64) -> Self {
        Self::new(name, metric, threshold, Comparison::Lte)
    }

    /// Create a gate that requires metric between lower and upper (inclusive).
    pub fn between(name: impl Into<String>, metric: QualityMetric, lower: f64, upper: f64) -> Self {
        Self {
            name: name.into(),
            metric,
            threshold: lower,
            upper_threshold: Some(upper),
            comparison: Comparison::Between,
        }
    }

    /// Check if an actual value passes this gate.
    pub fn check(&self, actual: f64) -> bool {
        match self.comparison {
            Comparison::Gte => actual >= self.threshold,
            Comparison::Lte => actual <= self.threshold,
            Comparison::Eq => (actual - self.threshold).abs() < 1e-9,
            Comparison::Between => {
                let upper = self.upper_threshold.unwrap_or(self.threshold);
                actual >= self.threshold && actual <= upper
            }
        }
    }
}

/// A named collection of quality gates.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GateProfile {
    /// Profile name (e.g., "strict", "default", "lenient").
    pub name: String,
    /// List of quality gates in this profile.
    pub gates: Vec<QualityGate>,
    /// Strategy for handling failures.
    #[serde(default)]
    pub fail_strategy: FailStrategy,
}

impl GateProfile {
    /// Create a new gate profile.
    pub fn new(name: impl Into<String>, gates: Vec<QualityGate>) -> Self {
        Self {
            name: name.into(),
            gates,
            fail_strategy: FailStrategy::default(),
        }
    }

    /// Set the fail strategy.
    pub fn with_fail_strategy(mut self, strategy: FailStrategy) -> Self {
        self.fail_strategy = strategy;
        self
    }
}

/// Result of checking a single gate.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GateCheckResult {
    /// Gate name.
    pub gate_name: String,
    /// Metric checked.
    pub metric: QualityMetric,
    /// Whether the gate passed.
    pub passed: bool,
    /// Actual metric value.
    pub actual_value: Option<f64>,
    /// Expected threshold.
    pub threshold: f64,
    /// Comparison used.
    pub comparison: Comparison,
    /// Human-readable message.
    pub message: String,
}

/// Overall result of evaluating all gates in a profile.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GateResult {
    /// Whether all gates passed.
    pub passed: bool,
    /// Profile name used.
    pub profile_name: String,
    /// Individual gate results.
    pub results: Vec<GateCheckResult>,
    /// Summary message.
    pub summary: String,
    /// Number of gates that passed.
    pub gates_passed: usize,
    /// Total number of gates checked.
    pub gates_total: usize,
}

/// Engine that evaluates quality gates against a comprehensive evaluation.
pub struct GateEngine;

impl GateEngine {
    /// Evaluate a comprehensive evaluation against a gate profile.
    pub fn evaluate(evaluation: &ComprehensiveEvaluation, profile: &GateProfile) -> GateResult {
        let mut results = Vec::new();
        let mut all_passed = true;

        for gate in &profile.gates {
            let (actual_value, message) = Self::extract_metric(evaluation, &gate.metric);

            let check_result = match actual_value {
                Some(value) => {
                    let passed = gate.check(value);
                    if !passed {
                        all_passed = false;
                    }
                    GateCheckResult {
                        gate_name: gate.name.clone(),
                        metric: gate.metric.clone(),
                        passed,
                        actual_value: Some(value),
                        threshold: gate.threshold,
                        comparison: gate.comparison.clone(),
                        message: if passed {
                            format!(
                                "{}: {:.4} passes {:?} {:.4}",
                                gate.name, value, gate.comparison, gate.threshold
                            )
                        } else {
                            format!(
                                "{}: {:.4} fails {:?} {:.4}",
                                gate.name, value, gate.comparison, gate.threshold
                            )
                        },
                    }
                }
                None => {
                    // Metric not available - treat as not applicable (pass)
                    GateCheckResult {
                        gate_name: gate.name.clone(),
                        metric: gate.metric.clone(),
                        passed: true,
                        actual_value: None,
                        threshold: gate.threshold,
                        comparison: gate.comparison.clone(),
                        message: format!("{}: metric not available ({})", gate.name, message),
                    }
                }
            };

            let failed = !check_result.passed;
            results.push(check_result);

            if failed && profile.fail_strategy == FailStrategy::FailFast {
                break;
            }
        }

        let gates_passed = results.iter().filter(|r| r.passed).count();
        let gates_total = results.len();

        let summary = if all_passed {
            format!(
                "All {}/{} quality gates passed (profile: {})",
                gates_passed, gates_total, profile.name
            )
        } else {
            let failed_names: Vec<_> = results
                .iter()
                .filter(|r| !r.passed)
                .map(|r| r.gate_name.as_str())
                .collect();
            format!(
                "{}/{} quality gates passed, {} failed: {} (profile: {})",
                gates_passed,
                gates_total,
                gates_total - gates_passed,
                failed_names.join(", "),
                profile.name
            )
        };

        GateResult {
            passed: all_passed,
            profile_name: profile.name.clone(),
            results,
            summary,
            gates_passed,
            gates_total,
        }
    }

    /// Extract a metric value from a comprehensive evaluation.
    fn extract_metric(
        evaluation: &ComprehensiveEvaluation,
        metric: &QualityMetric,
    ) -> (Option<f64>, String) {
        match metric {
            QualityMetric::BenfordMad => {
                let mad = evaluation.statistical.benford.as_ref().map(|b| b.mad);
                (mad, "benford analysis not available".to_string())
            }
            QualityMetric::BalanceCoherence => {
                let rate = evaluation.coherence.balance.as_ref().map(|b| {
                    if b.equation_balanced {
                        1.0
                    } else {
                        0.0
                    }
                });
                (rate, "balance sheet evaluation not available".to_string())
            }
            QualityMetric::DocumentChainIntegrity => {
                let rate = evaluation
                    .coherence
                    .document_chain
                    .as_ref()
                    .map(|d| d.p2p_completion_rate);
                (rate, "document chain evaluation not available".to_string())
            }
            QualityMetric::CorrelationPreservation => {
                // Not directly available in ComprehensiveEvaluation - return None
                (
                    None,
                    "correlation preservation metric not available".to_string(),
                )
            }
            QualityMetric::TemporalConsistency => {
                let rate = evaluation
                    .statistical
                    .temporal
                    .as_ref()
                    .map(|t| t.pattern_correlation);
                (rate, "temporal analysis not available".to_string())
            }
            QualityMetric::PrivacyMiaAuc => {
                let auc = evaluation
                    .privacy
                    .as_ref()
                    .and_then(|p| p.membership_inference.as_ref())
                    .map(|m| m.auc_roc);
                (auc, "privacy MIA evaluation not available".to_string())
            }
            QualityMetric::CompletionRate => {
                let rate = evaluation
                    .quality
                    .completeness
                    .as_ref()
                    .map(|c| c.overall_completeness);
                (rate, "completeness analysis not available".to_string())
            }
            QualityMetric::DuplicateRate => {
                let rate = evaluation
                    .quality
                    .uniqueness
                    .as_ref()
                    .map(|u| u.duplicate_rate);
                (rate, "uniqueness analysis not available".to_string())
            }
            QualityMetric::ReferentialIntegrity => {
                let rate = evaluation
                    .coherence
                    .referential
                    .as_ref()
                    .map(|r| r.overall_integrity_score);
                (
                    rate,
                    "referential integrity evaluation not available".to_string(),
                )
            }
            QualityMetric::IcMatchRate => {
                let rate = evaluation
                    .coherence
                    .intercompany
                    .as_ref()
                    .map(|ic| ic.match_rate);
                (rate, "IC matching evaluation not available".to_string())
            }
            QualityMetric::Custom(name) => (
                None,
                format!(
                    "custom metric '{}' not available in standard evaluation",
                    name
                ),
            ),
        }
    }
}

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

    fn sample_profile() -> GateProfile {
        GateProfile::new(
            "test",
            vec![
                QualityGate::lte("benford_compliance", QualityMetric::BenfordMad, 0.015),
                QualityGate::gte("completeness", QualityMetric::CompletionRate, 0.95),
            ],
        )
    }

    #[test]
    fn test_gate_check_gte() {
        let gate = QualityGate::gte("test", QualityMetric::CompletionRate, 0.95);
        assert!(gate.check(0.96));
        assert!(gate.check(0.95));
        assert!(!gate.check(0.94));
    }

    #[test]
    fn test_gate_check_lte() {
        let gate = QualityGate::lte("test", QualityMetric::BenfordMad, 0.015);
        assert!(gate.check(0.01));
        assert!(gate.check(0.015));
        assert!(!gate.check(0.016));
    }

    #[test]
    fn test_gate_check_between() {
        let gate = QualityGate::between("test", QualityMetric::DuplicateRate, 0.0, 0.05);
        assert!(gate.check(0.0));
        assert!(gate.check(0.03));
        assert!(gate.check(0.05));
        assert!(!gate.check(0.06));
    }

    #[test]
    fn test_gate_check_eq() {
        let gate = QualityGate::new("test", QualityMetric::BalanceCoherence, 1.0, Comparison::Eq);
        assert!(gate.check(1.0));
        assert!(!gate.check(0.99));
    }

    #[test]
    fn test_evaluate_empty_evaluation() {
        let evaluation = ComprehensiveEvaluation::new();
        let profile = sample_profile();
        let result = GateEngine::evaluate(&evaluation, &profile);
        // All metrics unavailable → treated as pass
        assert!(result.passed);
        assert_eq!(result.gates_total, 2);
    }

    #[test]
    fn test_fail_fast_stops_on_first_failure() {
        let evaluation = ComprehensiveEvaluation::new();
        let profile = GateProfile::new(
            "strict",
            vec![
                // This will fail because balance_coherence is not available
                // but N/A is treated as pass. Let's create a custom gate
                // that we know will fail
                QualityGate::gte(
                    "custom_gate",
                    QualityMetric::Custom("nonexistent".to_string()),
                    0.99,
                ),
                QualityGate::gte(
                    "another",
                    QualityMetric::Custom("also_nonexistent".to_string()),
                    0.99,
                ),
            ],
        )
        .with_fail_strategy(FailStrategy::FailFast);

        let result = GateEngine::evaluate(&evaluation, &profile);
        // Custom metrics unavailable are treated as pass, so both pass
        assert!(result.passed);
    }

    #[test]
    fn test_collect_all_reports_all_failures() {
        let evaluation = ComprehensiveEvaluation::new();
        let profile = GateProfile::new(
            "test",
            vec![
                QualityGate::lte("mad", QualityMetric::BenfordMad, 0.015),
                QualityGate::gte("completion", QualityMetric::CompletionRate, 0.95),
            ],
        )
        .with_fail_strategy(FailStrategy::CollectAll);

        let result = GateEngine::evaluate(&evaluation, &profile);
        assert_eq!(result.results.len(), 2);
    }

    #[test]
    fn test_gate_result_summary() {
        let evaluation = ComprehensiveEvaluation::new();
        let profile = sample_profile();
        let result = GateEngine::evaluate(&evaluation, &profile);
        assert!(result.summary.contains("test"));
    }

    #[test]
    fn test_quality_metric_display() {
        assert_eq!(QualityMetric::BenfordMad.to_string(), "benford_mad");
        assert_eq!(
            QualityMetric::BalanceCoherence.to_string(),
            "balance_coherence"
        );
        assert_eq!(
            QualityMetric::Custom("my_metric".to_string()).to_string(),
            "custom:my_metric"
        );
    }

    #[test]
    fn test_gate_profile_serialization() {
        let profile = sample_profile();
        let json = serde_json::to_string(&profile).expect("serialize");
        let deserialized: GateProfile = serde_json::from_str(&json).expect("deserialize");
        assert_eq!(deserialized.name, "test");
        assert_eq!(deserialized.gates.len(), 2);
    }
}