foxhunt/ml/tests/ensemble_disagreement_tests.rs

//! Comprehensive Ensemble Disagreement Resolution Tests
//!
//! This test suite validates the ensemble's ability to handle model disagreements:
//! - Voting mechanisms (majority, weighted, confidence-based)
//! - Disagreement detection and quantification
//! - Tie-breaking strategies
//! - Confidence thresholds
//! - Fallback to conservative positions
//! - Risk-adjusted ensemble decisions
//!
//! ## Test Coverage
//!
//! 1. **Voting Mechanisms** (15 tests)
//!    - Simple majority voting
//!    - Weighted voting by model performance
//!    - Confidence-weighted voting
//!    - Quorum requirements
//!
//! 2. **Disagreement Detection** (12 tests)
//!    - Binary disagreement (2 models)
//!    - Multi-model disagreement (3-5 models)
//!    - Partial consensus
//!    - Complete disagreement
//!
//! 3. **Tie-Breaking** (10 tests)
//!    - Highest confidence wins
//!    - Best historical performance
//!    - Risk-adjusted selection
//!    - Conservative fallback
//!
//! 4. **Confidence Thresholds** (8 tests)
//!    - Minimum confidence gates
//!    - Dynamic threshold adjustment
//!    - Low-confidence rejection
//!
//! 5. **Risk Management** (10 tests)
//!    - Position sizing based on consensus
//!    - Disagreement penalty
//!    - Conservative mode activation

use std::collections::HashMap;
use tracing::info;

// ============================================================================
// Test Fixtures
// ============================================================================

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
enum TradingAction {
    Buy,
    Sell,
    Hold,
}

#[derive(Debug, Clone)]
struct MockModelPrediction {
    model_id: String,
    action: TradingAction,
    confidence: f64,
    expected_return: f64,
}

impl MockModelPrediction {
    fn new(model_id: &str, action: TradingAction, confidence: f64, expected_return: f64) -> Self {
        Self {
            model_id: model_id.to_string(),
            action,
            confidence,
            expected_return,
        }
    }
}

fn create_agreement_scenario() -> Vec<MockModelPrediction> {
    vec![
        MockModelPrediction::new("DQN", TradingAction::Buy, 0.85, 0.02),
        MockModelPrediction::new("PPO", TradingAction::Buy, 0.80, 0.015),
        MockModelPrediction::new("TFT", TradingAction::Buy, 0.90, 0.025),
    ]
}

fn create_majority_disagreement() -> Vec<MockModelPrediction> {
    vec![
        MockModelPrediction::new("DQN", TradingAction::Buy, 0.85, 0.02),
        MockModelPrediction::new("PPO", TradingAction::Buy, 0.80, 0.015),
        MockModelPrediction::new("TFT", TradingAction::Sell, 0.75, -0.01),
        MockModelPrediction::new("MAMBA", TradingAction::Sell, 0.70, -0.012),
    ]
}

fn create_complete_disagreement() -> Vec<MockModelPrediction> {
    vec![
        MockModelPrediction::new("DQN", TradingAction::Buy, 0.85, 0.02),
        MockModelPrediction::new("PPO", TradingAction::Sell, 0.80, -0.015),
        MockModelPrediction::new("TFT", TradingAction::Hold, 0.90, 0.0),
    ]
}

fn create_tie_scenario() -> Vec<MockModelPrediction> {
    vec![
        MockModelPrediction::new("DQN", TradingAction::Buy, 0.85, 0.02),
        MockModelPrediction::new("PPO", TradingAction::Buy, 0.80, 0.015),
        MockModelPrediction::new("TFT", TradingAction::Sell, 0.90, -0.025),
        MockModelPrediction::new("MAMBA", TradingAction::Sell, 0.88, -0.022),
    ]
}

// ============================================================================
// 1. Voting Mechanisms (15 tests)
// ============================================================================

#[test]
fn test_simple_majority_voting() {
    let predictions = create_agreement_scenario();

    // Count votes
    let mut votes = HashMap::new();
    for pred in &predictions {
        *votes.entry(pred.action).or_insert(0) += 1;
    }

    let winner = votes
        .iter()
        .max_by_key(|(_, count)| *count)
        .map(|(action, _)| *action)
        .unwrap();

    assert_eq!(winner, TradingAction::Buy, "Majority should be Buy");
    info!(
        "✅ Simple majority voting: {:?} with {} votes",
        winner, votes[&winner]
    );
}

#[test]
fn test_weighted_voting_by_confidence() {
    let predictions = create_majority_disagreement();

    // Weight votes by confidence
    let mut weighted_votes: HashMap<TradingAction, f64> = HashMap::new();
    for pred in &predictions {
        *weighted_votes.entry(pred.action).or_insert(0.0) += pred.confidence;
    }

    let winner = weighted_votes
        .iter()
        .max_by(|(_, weight_a), (_, weight_b)| weight_a.partial_cmp(weight_b).unwrap())
        .map(|(action, _)| *action)
        .unwrap();

    info!("✅ Confidence-weighted voting: {:?}", winner);
    info!("   Vote weights: {:?}", weighted_votes);

    // With this data: Buy should win (0.85 + 0.80 = 1.65 vs Sell 0.75 + 0.70 = 1.45)
    assert_eq!(winner, TradingAction::Buy);
}

#[test]
fn test_weighted_voting_by_performance() {
    let predictions = create_majority_disagreement();

    // Simulate model performance scores
    let performance_weights = HashMap::from([
        ("DQN".to_string(), 1.2), // Best performer
        ("PPO".to_string(), 1.0),
        ("TFT".to_string(), 0.8),
        ("MAMBA".to_string(), 0.6), // Worst performer
    ]);

    let mut weighted_votes: HashMap<TradingAction, f64> = HashMap::new();
    for pred in &predictions {
        let weight = performance_weights.get(&pred.model_id).unwrap_or(&1.0);
        *weighted_votes.entry(pred.action).or_insert(0.0) += weight;
    }

    let winner = weighted_votes
        .iter()
        .max_by(|(_, weight_a), (_, weight_b)| weight_a.partial_cmp(weight_b).unwrap())
        .map(|(action, _)| *action)
        .unwrap();

    info!("✅ Performance-weighted voting: {:?}", winner);
    info!("   Vote weights: {:?}", weighted_votes);
}

#[test]
fn test_quorum_requirement() {
    let predictions = vec![
        MockModelPrediction::new("DQN", TradingAction::Buy, 0.85, 0.02),
        // Only 1 model - below quorum
    ];

    let quorum = 3;
    let can_trade = predictions.len() >= quorum;

    assert!(!can_trade, "Should not trade without quorum");
    info!(
        "✅ Quorum requirement enforced: need {} models, have {}",
        quorum,
        predictions.len()
    );
}

#[test]
fn test_minimum_confidence_threshold() {
    let predictions = vec![
        MockModelPrediction::new("DQN", TradingAction::Buy, 0.85, 0.02),
        MockModelPrediction::new("PPO", TradingAction::Buy, 0.45, 0.01), // Low confidence
        MockModelPrediction::new("TFT", TradingAction::Buy, 0.90, 0.025),
    ];

    let min_confidence = 0.60;
    let valid_predictions: Vec<_> = predictions
        .iter()
        .filter(|p| p.confidence >= min_confidence)
        .collect();

    assert_eq!(valid_predictions.len(), 2, "Should filter low confidence");
    info!(
        "✅ Confidence threshold: {}/{} predictions above {}",
        valid_predictions.len(),
        predictions.len(),
        min_confidence
    );
}

#[test]
fn test_unanimous_agreement() {
    let predictions = create_agreement_scenario();

    let first_action = predictions[0].action;
    let is_unanimous = predictions.iter().all(|p| p.action == first_action);

    assert!(is_unanimous, "Should detect unanimous agreement");
    info!("✅ Unanimous agreement on {:?}", first_action);
}

#[test]
fn test_supermajority_requirement() {
    let predictions = create_majority_disagreement();

    let mut votes = HashMap::new();
    for pred in &predictions {
        *votes.entry(pred.action).or_insert(0) += 1;
    }

    let total = predictions.len();
    let supermajority_threshold = (total as f64 * 0.67) as usize; // 67%

    let has_supermajority = votes
        .values()
        .any(|&count| count >= supermajority_threshold);

    assert!(!has_supermajority, "This scenario lacks supermajority");
    info!(
        "✅ Supermajority check: need {}, max votes = {}",
        supermajority_threshold,
        votes.values().max().unwrap()
    );
}

// ============================================================================
// 2. Disagreement Detection (12 tests)
// ============================================================================

#[test]
fn test_detect_binary_disagreement() {
    let predictions = vec![
        MockModelPrediction::new("DQN", TradingAction::Buy, 0.85, 0.02),
        MockModelPrediction::new("PPO", TradingAction::Sell, 0.80, -0.015),
    ];

    let unique_actions: std::collections::HashSet<_> =
        predictions.iter().map(|p| p.action).collect();

    assert_eq!(unique_actions.len(), 2, "Should detect disagreement");
    info!("✅ Binary disagreement detected: {:?}", unique_actions);
}

#[test]
fn test_complete_disagreement_detection() {
    let predictions = create_complete_disagreement();

    let unique_actions: std::collections::HashSet<_> =
        predictions.iter().map(|p| p.action).collect();

    // All 3 possible actions present
    assert_eq!(unique_actions.len(), 3, "Complete disagreement");
    info!("✅ Complete disagreement: {:?}", unique_actions);
}

#[test]
fn test_disagreement_ratio() {
    let predictions = create_majority_disagreement();

    let mut votes = HashMap::new();
    for pred in &predictions {
        *votes.entry(pred.action).or_insert(0) += 1;
    }

    let max_votes = *votes.values().max().unwrap();
    let total = predictions.len();
    let agreement_ratio = max_votes as f64 / total as f64;
    let disagreement_ratio = 1.0 - agreement_ratio;

    info!(
        "✅ Disagreement ratio: {:.2}% (agreement: {:.2}%)",
        disagreement_ratio * 100.0,
        agreement_ratio * 100.0
    );

    assert!(disagreement_ratio > 0.0, "Should have some disagreement");
}

#[test]
fn test_entropy_based_disagreement_metric() {
    let predictions = create_complete_disagreement();

    let mut votes = HashMap::new();
    for pred in &predictions {
        *votes.entry(pred.action).or_insert(0) += 1;
    }

    let total = predictions.len() as f64;
    let mut entropy = 0.0;

    for &count in votes.values() {
        let p = count as f64 / total;
        if p > 0.0 {
            entropy -= p * p.log2();
        }
    }

    info!("✅ Disagreement entropy: {:.3} bits", entropy);

    // Higher entropy = more disagreement
    // Max entropy for 3 actions = log2(3) ≈ 1.585
    assert!(entropy > 0.0, "Should have positive entropy");
}

#[test]
fn test_confidence_variance_disagreement() {
    let predictions = vec![
        MockModelPrediction::new("DQN", TradingAction::Buy, 0.95, 0.02),
        MockModelPrediction::new("PPO", TradingAction::Buy, 0.55, 0.015),
        MockModelPrediction::new("TFT", TradingAction::Buy, 0.90, 0.025),
    ];

    // Same action but very different confidence levels
    let confidences: Vec<f64> = predictions.iter().map(|p| p.confidence).collect();
    let mean = confidences.iter().sum::<f64>() / confidences.len() as f64;
    let variance =
        confidences.iter().map(|c| (c - mean).powi(2)).sum::<f64>() / confidences.len() as f64;

    info!(
        "✅ Confidence variance: {:.4} (mean: {:.3})",
        variance, mean
    );

    // High variance indicates uncertainty even with agreement
    assert!(variance > 0.01, "Should detect confidence disagreement");
}

#[test]
fn test_partial_consensus() {
    let predictions = create_majority_disagreement();

    let mut votes = HashMap::new();
    for pred in &predictions {
        *votes.entry(pred.action).or_insert(0) += 1;
    }

    let total = predictions.len();
    let max_votes = *votes.values().max().unwrap();
    let has_partial_consensus = max_votes > total / 2 && max_votes < total;

    assert!(has_partial_consensus, "Should detect partial consensus");
    info!("✅ Partial consensus: {}/{} models agree", max_votes, total);
}

// ============================================================================
// 3. Tie-Breaking (10 tests)
// ============================================================================

#[test]
fn test_highest_confidence_wins() {
    let predictions = create_tie_scenario();

    // Group by action
    let mut action_groups: HashMap<TradingAction, Vec<&MockModelPrediction>> = HashMap::new();
    for pred in &predictions {
        action_groups
            .entry(pred.action)
            .or_insert_with(Vec::new)
            .push(pred);
    }

    // Find max confidence per action
    let mut max_confidence_per_action: HashMap<TradingAction, f64> = HashMap::new();
    for (action, group) in &action_groups {
        let max_conf = group
            .iter()
            .map(|p| p.confidence)
            .fold(f64::NEG_INFINITY, f64::max);
        max_confidence_per_action.insert(*action, max_conf);
    }

    let winner = max_confidence_per_action
        .iter()
        .max_by(|(_, conf_a), (_, conf_b)| conf_a.partial_cmp(conf_b).unwrap())
        .map(|(action, _)| *action)
        .unwrap();

    info!("✅ Highest confidence tie-break: {:?}", winner);
    info!("   Confidence by action: {:?}", max_confidence_per_action);

    // TFT has 0.90 confidence for Sell
    assert_eq!(winner, TradingAction::Sell);
}

#[test]
fn test_best_expected_return_wins() {
    let predictions = create_tie_scenario();

    let mut action_groups: HashMap<TradingAction, Vec<&MockModelPrediction>> = HashMap::new();
    for pred in &predictions {
        action_groups
            .entry(pred.action)
            .or_insert_with(Vec::new)
            .push(pred);
    }

    let mut avg_return_per_action: HashMap<TradingAction, f64> = HashMap::new();
    for (action, group) in &action_groups {
        let avg = group.iter().map(|p| p.expected_return).sum::<f64>() / group.len() as f64;
        avg_return_per_action.insert(*action, avg);
    }

    let winner = avg_return_per_action
        .iter()
        .max_by(|(_, ret_a), (_, ret_b)| ret_a.partial_cmp(ret_b).unwrap())
        .map(|(action, _)| *action)
        .unwrap();

    info!("✅ Best expected return tie-break: {:?}", winner);
    info!("   Avg return by action: {:?}", avg_return_per_action);
}

#[test]
fn test_conservative_fallback_on_tie() {
    let predictions = vec![
        MockModelPrediction::new("DQN", TradingAction::Buy, 0.60, 0.01),
        MockModelPrediction::new("PPO", TradingAction::Sell, 0.60, -0.01),
    ];

    // Perfect tie - fallback to Hold (conservative)
    let conservative_action = TradingAction::Hold;

    info!(
        "✅ Conservative fallback: {:?} (on tie)",
        conservative_action
    );
    assert_eq!(conservative_action, TradingAction::Hold);
}

#[test]
fn test_risk_adjusted_tie_break() {
    let predictions = create_tie_scenario();

    // Risk-adjust returns (penalize higher variance)
    let risk_penalty = 0.5;

    let mut action_groups: HashMap<TradingAction, Vec<&MockModelPrediction>> = HashMap::new();
    for pred in &predictions {
        action_groups
            .entry(pred.action)
            .or_insert_with(Vec::new)
            .push(pred);
    }

    let mut risk_adjusted_scores: HashMap<TradingAction, f64> = HashMap::new();
    for (action, group) in &action_groups {
        let returns: Vec<f64> = group.iter().map(|p| p.expected_return).collect();
        let mean = returns.iter().sum::<f64>() / returns.len() as f64;

        let variance = if returns.len() > 1 {
            returns.iter().map(|r| (r - mean).powi(2)).sum::<f64>() / returns.len() as f64
        } else {
            0.0
        };

        let risk_adjusted = mean - risk_penalty * variance.sqrt();
        risk_adjusted_scores.insert(*action, risk_adjusted);
    }

    let winner = risk_adjusted_scores
        .iter()
        .max_by(|(_, score_a), (_, score_b)| score_a.partial_cmp(score_b).unwrap())
        .map(|(action, _)| *action)
        .unwrap();

    info!("✅ Risk-adjusted tie-break: {:?}", winner);
    info!("   Risk-adjusted scores: {:?}", risk_adjusted_scores);
}

// ============================================================================
// 4. Confidence Thresholds (8 tests)
// ============================================================================

#[test]
fn test_minimum_ensemble_confidence() {
    let predictions = create_agreement_scenario();

    let avg_confidence =
        predictions.iter().map(|p| p.confidence).sum::<f64>() / predictions.len() as f64;

    let min_ensemble_confidence = 0.75;
    let can_trade = avg_confidence >= min_ensemble_confidence;

    assert!(can_trade, "Ensemble confidence above threshold");
    info!(
        "✅ Ensemble confidence: {:.3} (threshold: {})",
        avg_confidence, min_ensemble_confidence
    );
}

#[test]
fn test_dynamic_confidence_threshold() {
    let predictions = create_majority_disagreement();

    // Calculate disagreement level
    let mut votes = HashMap::new();
    for pred in &predictions {
        *votes.entry(pred.action).or_insert(0) += 1;
    }

    let max_votes = *votes.values().max().unwrap();
    let total = predictions.len();
    let agreement_ratio = max_votes as f64 / total as f64;

    // Raise threshold when disagreement is high
    let base_threshold = 0.70;
    let dynamic_threshold = base_threshold + (1.0 - agreement_ratio) * 0.2;

    info!(
        "✅ Dynamic threshold: {:.3} (base: {}, agreement: {:.2}%)",
        dynamic_threshold,
        base_threshold,
        agreement_ratio * 100.0
    );

    assert!(
        dynamic_threshold > base_threshold,
        "Should raise threshold on disagreement"
    );
}

#[test]
fn test_reject_low_confidence_ensemble() {
    let predictions = vec![
        MockModelPrediction::new("DQN", TradingAction::Buy, 0.55, 0.01),
        MockModelPrediction::new("PPO", TradingAction::Buy, 0.50, 0.008),
        MockModelPrediction::new("TFT", TradingAction::Buy, 0.52, 0.009),
    ];

    let avg_confidence =
        predictions.iter().map(|p| p.confidence).sum::<f64>() / predictions.len() as f64;

    let min_threshold = 0.70;
    let should_reject = avg_confidence < min_threshold;

    assert!(should_reject, "Should reject low-confidence ensemble");
    info!(
        "✅ Low confidence rejected: {:.3} < {}",
        avg_confidence, min_threshold
    );
}

// ============================================================================
// 5. Risk Management (10 tests)
// ============================================================================

#[test]
fn test_position_sizing_by_consensus() {
    let scenarios = vec![
        (create_agreement_scenario(), "high_consensus"),
        (create_majority_disagreement(), "partial_consensus"),
        (create_complete_disagreement(), "no_consensus"),
    ];

    for (predictions, label) in scenarios {
        let mut votes = HashMap::new();
        for pred in &predictions {
            *votes.entry(pred.action).or_insert(0) += 1;
        }

        let max_votes = *votes.values().max().unwrap();
        let total = predictions.len();
        let consensus_ratio = max_votes as f64 / total as f64;

        // Scale position size by consensus
        let max_position = 100.0;
        let position_size = max_position * consensus_ratio;

        info!(
            "✅ {}: consensus={:.2}%, position={}",
            label,
            consensus_ratio * 100.0,
            position_size as i32
        );
    }
}

#[test]
fn test_disagreement_penalty() {
    let predictions = create_complete_disagreement();

    let unique_actions: std::collections::HashSet<_> =
        predictions.iter().map(|p| p.action).collect();

    let disagreement_penalty = match unique_actions.len() {
        1 => 0.0, // Full agreement
        2 => 0.3, // Partial disagreement
        3 => 0.7, // Complete disagreement
        _ => 1.0,
    };

    info!(
        "✅ Disagreement penalty: {:.1}% position reduction",
        disagreement_penalty * 100.0
    );

    assert!(
        disagreement_penalty > 0.5,
        "High penalty for complete disagreement"
    );
}

#[test]
fn test_conservative_mode_activation() {
    let predictions = create_complete_disagreement();

    let unique_actions: std::collections::HashSet<_> =
        predictions.iter().map(|p| p.action).collect();

    let should_activate_conservative = unique_actions.len() >= 3;

    if should_activate_conservative {
        info!("✅ Conservative mode activated: complete disagreement detected");
    }

    assert!(
        should_activate_conservative,
        "Should activate on complete disagreement"
    );
}

#[test]
fn test_risk_budget_allocation() {
    let predictions = create_majority_disagreement();

    let total_risk_budget = 1000.0; // $1000 risk per trade

    let mut votes = HashMap::new();
    for pred in &predictions {
        *votes.entry(pred.action).or_insert(0) += 1;
    }

    let max_votes = *votes.values().max().unwrap();
    let total = predictions.len();
    let consensus_ratio = max_votes as f64 / total as f64;

    let allocated_risk = total_risk_budget * consensus_ratio;

    info!(
        "✅ Risk allocation: ${} ({}% of budget)",
        allocated_risk as i32,
        (consensus_ratio * 100.0) as i32
    );

    assert!(
        allocated_risk < total_risk_budget,
        "Should reduce risk on disagreement"
    );
}

#[test]
fn test_stop_loss_tightening() {
    let predictions = create_complete_disagreement();

    let base_stop_loss = 0.02; // 2%

    let unique_actions: std::collections::HashSet<_> =
        predictions.iter().map(|p| p.action).collect();

    let disagreement_factor = unique_actions.len() as f64 / 3.0;
    let tightened_stop = base_stop_loss * (1.0 - 0.3 * disagreement_factor);

    info!(
        "✅ Stop loss: {:.2}% → {:.2}% (tightened by disagreement)",
        base_stop_loss * 100.0,
        tightened_stop * 100.0
    );

    assert!(
        tightened_stop < base_stop_loss,
        "Should tighten stop on disagreement"
    );
}