//! Comprehensive tests for Causal Inference Module
//!
//! This test suite verifies causal reasoning including:
//! - DAG validation
//! - Intervention semantics (do-calculus)
//! - Counterfactual computation
//! - Causal abstraction consistency

use prime_radiant::causal::{
    CausalModel, StructuralEquation, Variable, VariableId, VariableType, Value,
    CausalAbstraction, AbstractionMap, ConsistencyResult,
    CausalCoherenceChecker, CausalConsistency, Belief,
    counterfactual, causal_effect, Observation, Distribution,
    DirectedGraph, TopologicalOrder, DAGValidationError,
    DoCalculus, Rule, Identification,
};
use prime_radiant::causal::integration::{SheafGraph, causal_coherence_energy, CoherenceEnergy};
use proptest::prelude::*;
use approx::assert_relative_eq;
use std::collections::{HashMap, HashSet};

// =============================================================================
// DAG VALIDATION TESTS
// =============================================================================

mod dag_validation_tests {
    use super::*;

    /// Test basic DAG creation
    #[test]
    fn test_create_dag() {
        let mut graph = DirectedGraph::new();
        graph.add_node(0);
        graph.add_node(1);
        graph.add_node(2);

        assert_eq!(graph.node_count(), 3);
    }

    /// Test adding valid edges
    #[test]
    fn test_add_valid_edges() {
        let mut graph = DirectedGraph::new();
        graph.add_edge(0, 1).unwrap();
        graph.add_edge(1, 2).unwrap();
        graph.add_edge(0, 2).unwrap();

        assert_eq!(graph.edge_count(), 3);
        assert!(graph.contains_edge(0, 1));
        assert!(graph.contains_edge(1, 2));
        assert!(graph.contains_edge(0, 2));
    }

    /// Test cycle detection
    #[test]
    fn test_cycle_detection() {
        let mut graph = DirectedGraph::new();
        graph.add_edge(0, 1).unwrap();
        graph.add_edge(1, 2).unwrap();

        // Adding 2 -> 0 would create a cycle
        let result = graph.add_edge(2, 0);
        assert!(result.is_err());

        match result {
            Err(DAGValidationError::CycleDetected(nodes)) => {
                assert!(!nodes.is_empty());
            }
            _ => panic!("Expected CycleDetected error"),
        }
    }

    /// Test self-loop detection
    #[test]
    fn test_self_loop_detection() {
        let mut graph = DirectedGraph::new();
        let result = graph.add_edge(0, 0);

        assert!(result.is_err());
        assert!(matches!(result, Err(DAGValidationError::SelfLoop(0))));
    }

    /// Test topological ordering
    #[test]
    fn test_topological_order() {
        let mut graph = DirectedGraph::new();
        // Diamond graph: 0 -> 1, 0 -> 2, 1 -> 3, 2 -> 3
        graph.add_edge(0, 1).unwrap();
        graph.add_edge(0, 2).unwrap();
        graph.add_edge(1, 3).unwrap();
        graph.add_edge(2, 3).unwrap();

        let order = graph.topological_order().unwrap();

        assert_eq!(order.len(), 4);
        assert!(order.comes_before(0, 1));
        assert!(order.comes_before(0, 2));
        assert!(order.comes_before(1, 3));
        assert!(order.comes_before(2, 3));
    }

    /// Test ancestors computation
    #[test]
    fn test_ancestors() {
        let mut graph = DirectedGraph::new();
        graph.add_edge(0, 1).unwrap();
        graph.add_edge(1, 2).unwrap();
        graph.add_edge(0, 3).unwrap();
        graph.add_edge(3, 2).unwrap();

        let ancestors = graph.ancestors(2);

        assert!(ancestors.contains(&0));
        assert!(ancestors.contains(&1));
        assert!(ancestors.contains(&3));
        assert!(!ancestors.contains(&2));
    }

    /// Test descendants computation
    #[test]
    fn test_descendants() {
        let mut graph = DirectedGraph::new();
        graph.add_edge(0, 1).unwrap();
        graph.add_edge(0, 2).unwrap();
        graph.add_edge(1, 3).unwrap();
        graph.add_edge(2, 3).unwrap();

        let descendants = graph.descendants(0);

        assert!(descendants.contains(&1));
        assert!(descendants.contains(&2));
        assert!(descendants.contains(&3));
        assert!(!descendants.contains(&0));
    }

    /// Test d-separation in chain
    #[test]
    fn test_d_separation_chain() {
        // X -> Z -> Y (chain)
        let mut graph = DirectedGraph::new();
        graph.add_node_with_label(0, "X");
        graph.add_node_with_label(1, "Z");
        graph.add_node_with_label(2, "Y");
        graph.add_edge(0, 1).unwrap();
        graph.add_edge(1, 2).unwrap();

        let x: HashSet<u32> = [0].into_iter().collect();
        let y: HashSet<u32> = [2].into_iter().collect();
        let z: HashSet<u32> = [1].into_iter().collect();
        let empty: HashSet<u32> = HashSet::new();

        // X and Y are NOT d-separated given empty set
        assert!(!graph.d_separated(&x, &y, &empty));

        // X and Y ARE d-separated given Z
        assert!(graph.d_separated(&x, &y, &z));
    }

    /// Test d-separation in fork
    #[test]
    fn test_d_separation_fork() {
        // X <- Z -> Y (fork)
        let mut graph = DirectedGraph::new();
        graph.add_edge(1, 0).unwrap();  // Z -> X
        graph.add_edge(1, 2).unwrap();  // Z -> Y

        let x: HashSet<u32> = [0].into_iter().collect();
        let y: HashSet<u32> = [2].into_iter().collect();
        let z: HashSet<u32> = [1].into_iter().collect();
        let empty: HashSet<u32> = HashSet::new();

        // X and Y are NOT d-separated given empty set
        assert!(!graph.d_separated(&x, &y, &empty));

        // X and Y ARE d-separated given Z
        assert!(graph.d_separated(&x, &y, &z));
    }

    /// Test d-separation in collider
    #[test]
    fn test_d_separation_collider() {
        // X -> Z <- Y (collider)
        let mut graph = DirectedGraph::new();
        graph.add_edge(0, 1).unwrap();  // X -> Z
        graph.add_edge(2, 1).unwrap();  // Y -> Z

        let x: HashSet<u32> = [0].into_iter().collect();
        let y: HashSet<u32> = [2].into_iter().collect();
        let z: HashSet<u32> = [1].into_iter().collect();
        let empty: HashSet<u32> = HashSet::new();

        // X and Y ARE d-separated given empty set (collider blocks)
        assert!(graph.d_separated(&x, &y, &empty));

        // X and Y are NOT d-separated given Z (conditioning opens collider)
        assert!(!graph.d_separated(&x, &y, &z));
    }

    /// Test v-structure detection
    #[test]
    fn test_v_structures() {
        let mut graph = DirectedGraph::new();
        graph.add_edge(0, 2).unwrap();  // X -> Z
        graph.add_edge(1, 2).unwrap();  // Y -> Z

        let v_structs = graph.v_structures();

        assert_eq!(v_structs.len(), 1);
        let (a, b, c) = v_structs[0];
        assert_eq!(b, 2);  // Z is the collider
    }
}

// =============================================================================
// INTERVENTION TESTS
// =============================================================================

mod intervention_tests {
    use super::*;

    /// Test intervention do(X = x) removes incoming edges
    #[test]
    fn test_intervention_removes_incoming_edges() {
        let mut model = CausalModel::new();

        // Z -> X -> Y
        model.add_variable("Z", VariableType::Continuous).unwrap();
        model.add_variable("X", VariableType::Continuous).unwrap();
        model.add_variable("Y", VariableType::Continuous).unwrap();

        let z_id = model.get_variable_id("Z").unwrap();
        let x_id = model.get_variable_id("X").unwrap();
        let y_id = model.get_variable_id("Y").unwrap();

        model.add_edge(z_id, x_id).unwrap();  // Z -> X
        model.add_edge(x_id, y_id).unwrap();  // X -> Y

        // Structural equation: X = 2*Z + noise
        model.set_structural_equation(x_id, StructuralEquation::linear(&[z_id], vec![2.0]));

        // Structural equation: Y = 3*X + noise
        model.set_structural_equation(y_id, StructuralEquation::linear(&[x_id], vec![3.0]));

        // Before intervention, X depends on Z
        assert!(model.parents(&x_id).unwrap().contains(&z_id));

        // Intervene do(X = 5)
        let mutilated = model.intervene(x_id, Value::Continuous(5.0)).unwrap();

        // After intervention, X has no parents
        assert!(mutilated.parents(&x_id).unwrap().is_empty());

        // Y still depends on X
        assert!(mutilated.parents(&y_id).unwrap().contains(&x_id));
    }

    /// Test interventional distribution differs from observational
    #[test]
    fn test_interventional_vs_observational() {
        let mut model = CausalModel::new();

        // Confounded: Z -> X, Z -> Y, X -> Y
        model.add_variable("Z", VariableType::Continuous).unwrap();
        model.add_variable("X", VariableType::Continuous).unwrap();
        model.add_variable("Y", VariableType::Continuous).unwrap();

        let z_id = model.get_variable_id("Z").unwrap();
        let x_id = model.get_variable_id("X").unwrap();
        let y_id = model.get_variable_id("Y").unwrap();

        model.add_edge(z_id, x_id).unwrap();
        model.add_edge(z_id, y_id).unwrap();
        model.add_edge(x_id, y_id).unwrap();

        // Compute observational P(Y | X = 1)
        let obs = Observation::new(&[("X", Value::Continuous(1.0))]);
        let p_y_given_x = model.conditional_distribution(&obs, "Y").unwrap();

        // Compute interventional P(Y | do(X = 1))
        let mutilated = model.intervene(x_id, Value::Continuous(1.0)).unwrap();
        let p_y_do_x = mutilated.marginal_distribution("Y").unwrap();

        // These should generally differ due to confounding
        // (The specific values depend on structural equations)
        assert!(p_y_given_x != p_y_do_x || model.is_unconfounded(x_id, y_id));
    }

    /// Test average treatment effect computation
    #[test]
    fn test_average_treatment_effect() {
        let mut model = CausalModel::new();

        // Simple model: Treatment -> Outcome
        model.add_variable("T", VariableType::Binary).unwrap();
        model.add_variable("Y", VariableType::Continuous).unwrap();

        let t_id = model.get_variable_id("T").unwrap();
        let y_id = model.get_variable_id("Y").unwrap();

        model.add_edge(t_id, y_id).unwrap();

        // Y = 2*T + epsilon
        model.set_structural_equation(y_id, StructuralEquation::linear(&[t_id], vec![2.0]));

        // ATE = E[Y | do(T=1)] - E[Y | do(T=0)]
        let ate = causal_effect(&model, t_id, y_id,
            Value::Binary(true),
            Value::Binary(false)
        ).unwrap();

        // Should be approximately 2.0
        assert_relative_eq!(ate, 2.0, epsilon = 0.5);
    }

    /// Test multiple simultaneous interventions
    #[test]
    fn test_multiple_interventions() {
        let mut model = CausalModel::new();

        model.add_variable("X", VariableType::Continuous).unwrap();
        model.add_variable("Y", VariableType::Continuous).unwrap();
        model.add_variable("Z", VariableType::Continuous).unwrap();

        let x_id = model.get_variable_id("X").unwrap();
        let y_id = model.get_variable_id("Y").unwrap();
        let z_id = model.get_variable_id("Z").unwrap();

        model.add_edge(x_id, z_id).unwrap();
        model.add_edge(y_id, z_id).unwrap();

        // Intervene on both X and Y
        let interventions = vec![
            (x_id, Value::Continuous(1.0)),
            (y_id, Value::Continuous(2.0)),
        ];

        let mutilated = model.multi_intervene(&interventions).unwrap();

        // Both X and Y should have no parents
        assert!(mutilated.parents(&x_id).unwrap().is_empty());
        assert!(mutilated.parents(&y_id).unwrap().is_empty());
    }
}

// =============================================================================
// COUNTERFACTUAL TESTS
// =============================================================================

mod counterfactual_tests {
    use super::*;

    /// Test basic counterfactual computation
    #[test]
    fn test_basic_counterfactual() {
        let mut model = CausalModel::new();

        // X -> Y with Y = 2*X
        model.add_variable("X", VariableType::Continuous).unwrap();
        model.add_variable("Y", VariableType::Continuous).unwrap();

        let x_id = model.get_variable_id("X").unwrap();
        let y_id = model.get_variable_id("Y").unwrap();

        model.add_edge(x_id, y_id).unwrap();
        model.set_structural_equation(y_id, StructuralEquation::linear(&[x_id], vec![2.0]));

        // Observe Y = 4 (implies X = 2)
        let observation = Observation::new(&[("Y", Value::Continuous(4.0))]);

        // Counterfactual: What would Y be if X = 3?
        let cf_y = counterfactual(&model, &observation, x_id, Value::Continuous(3.0), "Y").unwrap();

        // Y' = 2 * 3 = 6
        match cf_y {
            Value::Continuous(y) => assert_relative_eq!(y, 6.0, epsilon = 0.1),
            _ => panic!("Expected continuous value"),
        }
    }

    /// Test counterfactual with noise inference
    #[test]
    fn test_counterfactual_with_noise() {
        let mut model = CausalModel::new();

        // X -> Y with Y = X + U_Y where U_Y is noise
        model.add_variable("X", VariableType::Continuous).unwrap();
        model.add_variable("Y", VariableType::Continuous).unwrap();

        let x_id = model.get_variable_id("X").unwrap();
        let y_id = model.get_variable_id("Y").unwrap();

        model.add_edge(x_id, y_id).unwrap();
        model.set_structural_equation(y_id, StructuralEquation::with_noise(&[x_id], vec![1.0]));

        // Observe X = 1, Y = 3 (so U_Y = 2)
        let observation = Observation::new(&[
            ("X", Value::Continuous(1.0)),
            ("Y", Value::Continuous(3.0)),
        ]);

        // What if X = 2?
        let cf_y = counterfactual(&model, &observation, x_id, Value::Continuous(2.0), "Y").unwrap();

        // Y' = 2 + 2 = 4 (noise U_Y = 2 is preserved)
        match cf_y {
            Value::Continuous(y) => assert_relative_eq!(y, 4.0, epsilon = 0.1),
            _ => panic!("Expected continuous value"),
        }
    }

    /// Test counterfactual consistency
    #[test]
    fn test_counterfactual_consistency() {
        let mut model = CausalModel::new();

        model.add_variable("X", VariableType::Continuous).unwrap();
        model.add_variable("Y", VariableType::Continuous).unwrap();

        let x_id = model.get_variable_id("X").unwrap();
        let y_id = model.get_variable_id("Y").unwrap();

        model.add_edge(x_id, y_id).unwrap();
        model.set_structural_equation(y_id, StructuralEquation::linear(&[x_id], vec![2.0]));

        // Observe X = 2, Y = 4
        let observation = Observation::new(&[
            ("X", Value::Continuous(2.0)),
            ("Y", Value::Continuous(4.0)),
        ]);

        // Counterfactual with actual value should match observed
        let cf_y = counterfactual(&model, &observation, x_id, Value::Continuous(2.0), "Y").unwrap();

        match cf_y {
            Value::Continuous(y) => assert_relative_eq!(y, 4.0, epsilon = 0.1),
            _ => panic!("Expected continuous value"),
        }
    }

    /// Test effect of treatment on treated (ETT)
    #[test]
    fn test_effect_on_treated() {
        let mut model = CausalModel::new();

        model.add_variable("T", VariableType::Binary).unwrap();
        model.add_variable("Y", VariableType::Continuous).unwrap();

        let t_id = model.get_variable_id("T").unwrap();
        let y_id = model.get_variable_id("Y").unwrap();

        model.add_edge(t_id, y_id).unwrap();
        model.set_structural_equation(y_id, StructuralEquation::linear(&[t_id], vec![5.0]));

        // For treated individuals (T = 1), what would Y be if T = 0?
        let observation = Observation::new(&[
            ("T", Value::Binary(true)),
            ("Y", Value::Continuous(5.0)),
        ]);

        let cf_y = counterfactual(&model, &observation, t_id, Value::Binary(false), "Y").unwrap();

        // ETT = Y(T=1) - Y(T=0) for treated
        match cf_y {
            Value::Continuous(y_untreated) => {
                let ett = 5.0 - y_untreated;
                assert_relative_eq!(ett, 5.0, epsilon = 0.5);
            }
            _ => panic!("Expected continuous value"),
        }
    }
}

// =============================================================================
// CAUSAL ABSTRACTION TESTS
// =============================================================================

mod causal_abstraction_tests {
    use super::*;

    /// Test abstraction map between models
    #[test]
    fn test_abstraction_map() {
        // Low-level model: X1 -> X2 -> X3
        let mut low = CausalModel::new();
        low.add_variable("X1", VariableType::Continuous).unwrap();
        low.add_variable("X2", VariableType::Continuous).unwrap();
        low.add_variable("X3", VariableType::Continuous).unwrap();

        let x1 = low.get_variable_id("X1").unwrap();
        let x2 = low.get_variable_id("X2").unwrap();
        let x3 = low.get_variable_id("X3").unwrap();

        low.add_edge(x1, x2).unwrap();
        low.add_edge(x2, x3).unwrap();

        // High-level model: A -> B
        let mut high = CausalModel::new();
        high.add_variable("A", VariableType::Continuous).unwrap();
        high.add_variable("B", VariableType::Continuous).unwrap();

        let a = high.get_variable_id("A").unwrap();
        let b = high.get_variable_id("B").unwrap();

        high.add_edge(a, b).unwrap();

        // Abstraction: A = X1, B = X3 (X2 is "hidden")
        let abstraction = CausalAbstraction::new(&low, &high);
        abstraction.add_mapping(x1, a);
        abstraction.add_mapping(x3, b);

        assert!(abstraction.is_valid_abstraction());
    }

    /// Test abstraction consistency
    #[test]
    fn test_abstraction_consistency() {
        // Two-level model
        let mut low = CausalModel::new();
        low.add_variable("X", VariableType::Continuous).unwrap();
        low.add_variable("Y", VariableType::Continuous).unwrap();

        let x = low.get_variable_id("X").unwrap();
        let y = low.get_variable_id("Y").unwrap();

        low.add_edge(x, y).unwrap();
        low.set_structural_equation(y, StructuralEquation::linear(&[x], vec![2.0]));

        let mut high = CausalModel::new();
        high.add_variable("A", VariableType::Continuous).unwrap();
        high.add_variable("B", VariableType::Continuous).unwrap();

        let a = high.get_variable_id("A").unwrap();
        let b = high.get_variable_id("B").unwrap();

        high.add_edge(a, b).unwrap();
        high.set_structural_equation(b, StructuralEquation::linear(&[a], vec![2.0]));

        let abstraction = CausalAbstraction::new(&low, &high);
        abstraction.add_mapping(x, a);
        abstraction.add_mapping(y, b);

        let result = abstraction.check_consistency();
        assert!(matches!(result, ConsistencyResult::Consistent));
    }

    /// Test intervention consistency across abstraction
    #[test]
    fn test_intervention_consistency() {
        let mut low = CausalModel::new();
        low.add_variable("X", VariableType::Continuous).unwrap();
        low.add_variable("Y", VariableType::Continuous).unwrap();

        let x = low.get_variable_id("X").unwrap();
        let y = low.get_variable_id("Y").unwrap();

        low.add_edge(x, y).unwrap();
        low.set_structural_equation(y, StructuralEquation::linear(&[x], vec![3.0]));

        let mut high = CausalModel::new();
        high.add_variable("A", VariableType::Continuous).unwrap();
        high.add_variable("B", VariableType::Continuous).unwrap();

        let a = high.get_variable_id("A").unwrap();
        let b = high.get_variable_id("B").unwrap();

        high.add_edge(a, b).unwrap();
        high.set_structural_equation(b, StructuralEquation::linear(&[a], vec![3.0]));

        let abstraction = CausalAbstraction::new(&low, &high);
        abstraction.add_mapping(x, a);
        abstraction.add_mapping(y, b);

        // Intervene on low-level model
        let low_intervened = low.intervene(x, Value::Continuous(5.0)).unwrap();
        let low_y = low_intervened.compute("Y").unwrap();

        // Intervene on high-level model
        let high_intervened = high.intervene(a, Value::Continuous(5.0)).unwrap();
        let high_b = high_intervened.compute("B").unwrap();

        // Results should match
        match (low_y, high_b) {
            (Value::Continuous(ly), Value::Continuous(hb)) => {
                assert_relative_eq!(ly, hb, epsilon = 0.1);
            }
            _ => panic!("Expected continuous values"),
        }
    }
}

// =============================================================================
// CAUSAL COHERENCE TESTS
// =============================================================================

mod causal_coherence_tests {
    use super::*;

    /// Test causal coherence checker
    #[test]
    fn test_causal_coherence_consistent() {
        let checker = CausalCoherenceChecker::new();

        let mut model = CausalModel::new();
        model.add_variable("X", VariableType::Continuous).unwrap();
        model.add_variable("Y", VariableType::Continuous).unwrap();

        let x = model.get_variable_id("X").unwrap();
        let y = model.get_variable_id("Y").unwrap();

        model.add_edge(x, y).unwrap();

        // Belief: X causes Y
        let belief = Belief::causal_relation("X", "Y", true);

        let result = checker.check(&model, &[belief]);
        assert!(matches!(result, CausalConsistency::Consistent));
    }

    /// Test detecting spurious correlation
    #[test]
    fn test_detect_spurious_correlation() {
        let checker = CausalCoherenceChecker::new();

        let mut model = CausalModel::new();
        // Z -> X, Z -> Y (confounded)
        model.add_variable("Z", VariableType::Continuous).unwrap();
        model.add_variable("X", VariableType::Continuous).unwrap();
        model.add_variable("Y", VariableType::Continuous).unwrap();

        let z = model.get_variable_id("Z").unwrap();
        let x = model.get_variable_id("X").unwrap();
        let y = model.get_variable_id("Y").unwrap();

        model.add_edge(z, x).unwrap();
        model.add_edge(z, y).unwrap();

        // Mistaken belief: X causes Y
        let belief = Belief::causal_relation("X", "Y", true);

        let result = checker.check(&model, &[belief]);
        assert!(matches!(result, CausalConsistency::SpuriousCorrelation(_)));
    }

    /// Test integration with sheaf coherence
    #[test]
    fn test_causal_sheaf_integration() {
        let sheaf = SheafGraph {
            nodes: vec!["X".to_string(), "Y".to_string()],
            edges: vec![(0, 1)],
            sections: vec![vec![1.0, 2.0], vec![2.0, 4.0]],
        };

        let mut model = CausalModel::new();
        model.add_variable("X", VariableType::Continuous).unwrap();
        model.add_variable("Y", VariableType::Continuous).unwrap();

        let x_id = model.get_variable_id("X").unwrap();
        let y_id = model.get_variable_id("Y").unwrap();

        model.add_edge(x_id, y_id).unwrap();

        let energy = causal_coherence_energy(&sheaf, &model);

        assert!(energy.structural_component >= 0.0);
        assert!(energy.causal_component >= 0.0);
        assert!(energy.total >= 0.0);
    }
}

// =============================================================================
// DO-CALCULUS TESTS
// =============================================================================

mod do_calculus_tests {
    use super::*;

    /// Test Rule 1: Ignoring observations
    #[test]
    fn test_rule1_ignoring_observations() {
        let mut model = CausalModel::new();

        model.add_variable("X", VariableType::Continuous).unwrap();
        model.add_variable("Y", VariableType::Continuous).unwrap();
        model.add_variable("Z", VariableType::Continuous).unwrap();

        let x = model.get_variable_id("X").unwrap();
        let y = model.get_variable_id("Y").unwrap();
        let z = model.get_variable_id("Z").unwrap();

        model.add_edge(x, y).unwrap();
        model.add_edge(z, y).unwrap();

        let calc = DoCalculus::new(&model);

        // P(y | do(x), z) = P(y | do(x)) if Z d-separated from Y given X in mutilated graph
        let x_set: HashSet<_> = [x].into_iter().collect();
        let z_set: HashSet<_> = [z].into_iter().collect();
        let y_set: HashSet<_> = [y].into_iter().collect();

        let rule1_applies = calc.can_apply_rule1(&y_set, &x_set, &z_set);
        assert!(!rule1_applies);  // Z -> Y, so can't ignore Z
    }

    /// Test Rule 2: Action/observation exchange
    #[test]
    fn test_rule2_action_observation_exchange() {
        let mut model = CausalModel::new();

        model.add_variable("X", VariableType::Continuous).unwrap();
        model.add_variable("Y", VariableType::Continuous).unwrap();
        model.add_variable("Z", VariableType::Continuous).unwrap();

        let x = model.get_variable_id("X").unwrap();
        let y = model.get_variable_id("Y").unwrap();
        let z = model.get_variable_id("Z").unwrap();

        // X -> Z -> Y
        model.add_edge(x, z).unwrap();
        model.add_edge(z, y).unwrap();

        let calc = DoCalculus::new(&model);

        // P(y | do(x), do(z)) = P(y | do(x), z) if...
        let can_exchange = calc.can_apply_rule2(y, x, z);
        // Depends on the specific d-separation conditions
        assert!(can_exchange || !can_exchange);  // Result depends on structure
    }

    /// Test Rule 3: Removing actions
    #[test]
    fn test_rule3_removing_actions() {
        let mut model = CausalModel::new();

        model.add_variable("X", VariableType::Continuous).unwrap();
        model.add_variable("Y", VariableType::Continuous).unwrap();

        let x = model.get_variable_id("X").unwrap();
        let y = model.get_variable_id("Y").unwrap();

        // No edge from X to Y
        // X and Y are independent

        let calc = DoCalculus::new(&model);

        // P(y | do(x)) = P(y) if X has no effect on Y
        let can_remove = calc.can_apply_rule3(y, x);
        assert!(can_remove);
    }

    /// Test causal effect identification
    #[test]
    fn test_causal_effect_identification() {
        let mut model = CausalModel::new();

        // Simple identifiable case: X -> Y
        model.add_variable("X", VariableType::Continuous).unwrap();
        model.add_variable("Y", VariableType::Continuous).unwrap();

        let x = model.get_variable_id("X").unwrap();
        let y = model.get_variable_id("Y").unwrap();

        model.add_edge(x, y).unwrap();

        let calc = DoCalculus::new(&model);
        let result = calc.identify(y, &[x].into_iter().collect());

        assert!(matches!(result, Identification::Identified(_)));
    }

    /// Test non-identifiable case
    #[test]
    fn test_non_identifiable_effect() {
        let mut model = CausalModel::new();

        // Confounded: U -> X, U -> Y, X -> Y (U unobserved)
        model.add_variable("X", VariableType::Continuous).unwrap();
        model.add_variable("Y", VariableType::Continuous).unwrap();

        let x = model.get_variable_id("X").unwrap();
        let y = model.get_variable_id("Y").unwrap();

        model.add_edge(x, y).unwrap();
        model.add_latent_confounding(x, y);  // Unobserved confounder

        let calc = DoCalculus::new(&model);
        let result = calc.identify(y, &[x].into_iter().collect());

        // Without adjustment variables, effect is not identifiable
        assert!(matches!(result, Identification::NotIdentified(_)));
    }
}

// =============================================================================
// PROPERTY-BASED TESTS
// =============================================================================

mod property_tests {
    use super::*;

    proptest! {
        /// Property: Topological order respects all edges
        #[test]
        fn prop_topo_order_respects_edges(
            edges in proptest::collection::vec((0..10u32, 0..10u32), 0..20)
        ) {
            let mut graph = DirectedGraph::new();

            for (from, to) in &edges {
                if from != to {
                    let _ = graph.add_edge(*from, *to);  // May fail if creates cycle
                }
            }

            if let Ok(order) = graph.topological_order() {
                for (from, to) in graph.edges() {
                    prop_assert!(order.comes_before(from, to));
                }
            }
        }

        /// Property: Interventions don't create cycles
        #[test]
        fn prop_intervention_preserves_dag(
            n in 2..8usize,
            seed in 0..1000u64
        ) {
            let mut model = CausalModel::new();

            for i in 0..n {
                model.add_variable(&format!("V{}", i), VariableType::Continuous).unwrap();
            }

            // Random DAG edges
            let mut rng = rand_chacha::ChaCha8Rng::seed_from_u64(seed);
            for i in 0..n {
                for j in (i+1)..n {
                    if rand::Rng::gen_bool(&mut rng, 0.3) {
                        let vi = model.get_variable_id(&format!("V{}", i)).unwrap();
                        let vj = model.get_variable_id(&format!("V{}", j)).unwrap();
                        let _ = model.add_edge(vi, vj);
                    }
                }
            }

            // Any intervention should preserve DAG property
            let v0 = model.get_variable_id("V0").unwrap();
            if let Ok(mutilated) = model.intervene(v0, Value::Continuous(1.0)) {
                prop_assert!(mutilated.is_dag());
            }
        }
    }
}

// =============================================================================
// EDGE CASE TESTS
// =============================================================================

mod edge_case_tests {
    use super::*;

    /// Test empty model
    #[test]
    fn test_empty_model() {
        let model = CausalModel::new();
        assert_eq!(model.variable_count(), 0);
    }

    /// Test single variable model
    #[test]
    fn test_single_variable() {
        let mut model = CausalModel::new();
        model.add_variable("X", VariableType::Continuous).unwrap();

        assert_eq!(model.variable_count(), 1);

        let x = model.get_variable_id("X").unwrap();
        assert!(model.parents(&x).unwrap().is_empty());
    }

    /// Test duplicate variable names
    #[test]
    fn test_duplicate_variable_name() {
        let mut model = CausalModel::new();
        model.add_variable("X", VariableType::Continuous).unwrap();

        let result = model.add_variable("X", VariableType::Continuous);
        assert!(result.is_err());
    }

    /// Test intervention on non-existent variable
    #[test]
    fn test_intervene_nonexistent() {
        let model = CausalModel::new();
        let fake_id = VariableId(999);

        let result = model.intervene(fake_id, Value::Continuous(1.0));
        assert!(result.is_err());
    }

    /// Test empty observation counterfactual
    #[test]
    fn test_empty_observation_counterfactual() {
        let mut model = CausalModel::new();
        model.add_variable("X", VariableType::Continuous).unwrap();
        model.add_variable("Y", VariableType::Continuous).unwrap();

        let x = model.get_variable_id("X").unwrap();

        let empty_obs = Observation::new(&[]);
        let result = counterfactual(&model, &empty_obs, x, Value::Continuous(1.0), "Y");

        // Should work with empty observation (uses prior)
        assert!(result.is_ok());
    }
}