//! Comprehensive tests for energy-based gate policy.

#![cfg(feature = "energy_gate")]

use ruvector_mincut_gated_transformer::{
    EnergyGate, EnergyGateConfig, GateDecision, GatePacket, GatePolicy,
};

#[test]
fn test_energy_computation_basic() {
    let config = EnergyGateConfig::default();
    let policy = GatePolicy::default();
    let energy_gate = EnergyGate::new(config, policy);

    let gate = GatePacket {
        lambda: 100,
        lambda_prev: 95,
        boundary_edges: 10,
        boundary_concentration_q15: 8192,
        partition_count: 3,
        flags: 0,
    };

    let energy = energy_gate.compute_energy(&gate);

    // Energy should be in valid range
    assert!(energy >= 0.0 && energy <= 1.0);
}

#[test]
fn test_energy_lambda_correlation() {
    let config = EnergyGateConfig::default();
    let policy = GatePolicy::default();
    let energy_gate = EnergyGate::new(config, policy);

    // High lambda = low energy (stable)
    let gate_high_lambda = GatePacket {
        lambda: 200,
        lambda_prev: 195,
        boundary_edges: 5,
        boundary_concentration_q15: 4096,
        partition_count: 2,
        flags: 0,
    };
    let energy_high = energy_gate.compute_energy(&gate_high_lambda);

    // Low lambda = high energy (unstable)
    let gate_low_lambda = GatePacket {
        lambda: 30,
        lambda_prev: 100,
        boundary_edges: 5,
        boundary_concentration_q15: 4096,
        partition_count: 2,
        flags: 0,
    };
    let energy_low = energy_gate.compute_energy(&gate_low_lambda);

    assert!(
        energy_high < energy_low,
        "High lambda should have lower energy"
    );
}

#[test]
fn test_energy_gradient_computation() {
    let config = EnergyGateConfig::default();
    let policy = GatePolicy::default();
    let energy_gate = EnergyGate::new(config, policy);

    let gate = GatePacket {
        lambda: 100,
        lambda_prev: 95,
        boundary_edges: 10,
        boundary_concentration_q15: 8192,
        partition_count: 3,
        flags: 0,
    };

    let gradient = energy_gate.energy_gradient(&gate);

    // Gradient should have finite values
    assert!(gradient.d_lambda.is_finite());
    assert!(gradient.d_boundary.is_finite());
    assert!(gradient.d_partition.is_finite());
    assert!(gradient.magnitude.is_finite());

    // Magnitude should be non-negative
    assert!(gradient.magnitude >= 0.0);
}

#[test]
fn test_decision_allow_stable() {
    let config = EnergyGateConfig::default();
    let policy = GatePolicy::default();
    let energy_gate = EnergyGate::new(config, policy);

    // Stable state
    let gate = GatePacket {
        lambda: 150,
        lambda_prev: 145,
        boundary_edges: 5,
        boundary_concentration_q15: 4096,
        partition_count: 2,
        flags: 0,
    };

    let (decision, confidence) = energy_gate.decide(&gate);

    assert_eq!(decision, GateDecision::Allow);
    // Confidence should be reasonable (relaxed from 0.5 to 0.3 for gradient-based system)
    assert!(
        confidence > 0.3,
        "Should have reasonable confidence for stable state, got: {}",
        confidence
    );
}