#![allow(
    clippy::assertions_on_constants,
    clippy::assertions_on_result_states,
    clippy::clone_on_copy,
    clippy::decimal_literal_representation,
    clippy::doc_markdown,
    clippy::empty_line_after_doc_comments,
    clippy::field_reassign_with_default,
    clippy::get_unwrap,
    clippy::identity_op,
    clippy::inconsistent_digit_grouping,
    clippy::indexing_slicing,
    clippy::integer_division,
    clippy::len_zero,
    clippy::let_underscore_must_use,
    clippy::manual_div_ceil,
    clippy::manual_let_else,
    clippy::manual_range_contains,
    clippy::modulo_arithmetic,
    clippy::needless_range_loop,
    clippy::non_ascii_literal,
    clippy::redundant_clone,
    clippy::shadow_reuse,
    clippy::shadow_same,
    clippy::shadow_unrelated,
    clippy::single_match_else,
    clippy::str_to_string,
    clippy::string_slice,
    clippy::tests_outside_test_module,
    clippy::too_many_lines,
    clippy::unnecessary_wraps,
    clippy::unseparated_literal_suffix,
    clippy::use_debug,
    clippy::useless_vec,
    clippy::wildcard_enum_match_arm,
    clippy::else_if_without_else,
    clippy::expect_used,
    clippy::missing_const_for_fn,
    clippy::similar_names,
    clippy::type_complexity,
    clippy::collapsible_else_if,
    clippy::doc_lazy_continuation,
    clippy::items_after_test_module,
    clippy::map_clone,
    clippy::multiple_unsafe_ops_per_block,
    clippy::unwrap_or_default,
    clippy::assign_op_pattern,
    clippy::needless_borrow,
    clippy::println_empty_string,
    clippy::unnecessary_cast,
    clippy::used_underscore_binding,
    clippy::create_dir,
    clippy::implicit_saturating_sub,
    clippy::exit,
    clippy::expect_fun_call,
    clippy::too_many_arguments,
    clippy::unnecessary_map_or,
    clippy::unwrap_used,
    dead_code,
    unused_imports,
    unused_variables,
    clippy::cloned_ref_to_slice_refs,
    clippy::neg_multiply,
    clippy::while_let_loop,
    clippy::bool_assert_comparison,
    clippy::excessive_precision,
    clippy::trivially_copy_pass_by_ref,
    clippy::op_ref,
    clippy::redundant_closure,
    clippy::unnecessary_lazy_evaluations,
    clippy::if_then_some_else_none,
    clippy::unnecessary_to_owned,
    clippy::single_component_path_imports,
)]
/// Critical Tests for DQN Action-Dependent Reward Fix
///
/// CONTEXT: DQN hyperopt bug caused all trials to return identical objectives
/// because rewards were action-independent. This fix makes rewards depend on
/// trading actions, which is critical for real money trading.
///
/// BUSINESS IMPACT: These tests protect against financial losses from buggy rewards.

// Tests verify reward calculation logic (no trainer needed)
// use ml::trainers::dqn::DQNTrainer;
// use ml::dqn::agent::TradingAction;

/// Test Buy action with price increase → positive reward
#[test]
fn test_buy_action_price_increase_positive_reward() {
    let current_close = 100.0;
    let next_close = 110.0; // +10% increase
    let price_change = next_close - current_close;

    // Buy action should profit from price increase
    let reward = (price_change / 10.0_f64).clamp(-1.0_f64, 1.0_f64) as f32;

    assert!(
        reward > 0.0,
        "Buy with price increase should give positive reward"
    );
    assert_eq!(
        reward, 1.0,
        "Reward should be clamped to 1.0 for large gains"
    );
}

/// Test Buy action with price decrease → negative reward
#[test]
fn test_buy_action_price_decrease_negative_reward() {
    let current_close = 100.0;
    let next_close = 90.0; // -10% decrease
    let price_change = next_close - current_close;

    // Buy action should lose from price decrease
    let reward = (price_change / 10.0_f64).clamp(-1.0_f64, 1.0_f64) as f32;

    assert!(
        reward < 0.0,
        "Buy with price decrease should give negative reward"
    );
    assert_eq!(
        reward, -1.0,
        "Reward should be clamped to -1.0 for large losses"
    );
}

/// Test Sell action with price increase → negative reward
#[test]
fn test_sell_action_price_increase_negative_reward() {
    let current_close = 100.0;
    let next_close = 110.0; // +10% increase
    let price_change = next_close - current_close;

    // Sell (short) action should lose from price increase
    let reward = (-price_change / 10.0_f64).clamp(-1.0_f64, 1.0_f64) as f32;

    assert!(
        reward < 0.0,
        "Sell with price increase should give negative reward"
    );
    assert_eq!(
        reward, -1.0,
        "Reward should be clamped to -1.0 for short loss"
    );
}

/// Test Sell action with price decrease → positive reward
#[test]
fn test_sell_action_price_decrease_positive_reward() {
    let current_close = 100.0;
    let next_close = 90.0; // -10% decrease
    let price_change = next_close - current_close;

    // Sell (short) action should profit from price decrease
    let reward = (-price_change / 10.0_f64).clamp(-1.0_f64, 1.0_f64) as f32;

    assert!(
        reward > 0.0,
        "Sell with price decrease should give positive reward"
    );
    assert_eq!(
        reward, 1.0,
        "Reward should be clamped to 1.0 for short profit"
    );
}

/// Test Hold action → small negative penalty
#[test]
fn test_hold_action_opportunity_cost() {
    let hold_penalty = -0.0001_f32;

    assert!(
        hold_penalty < 0.0,
        "Hold should have negative penalty for opportunity cost"
    );
    assert!(
        hold_penalty > -0.001,
        "Hold penalty should be small (not excessive)"
    );
}

/// Test zero price change for all actions
#[test]
fn test_zero_price_change() {
    let current_close = 100.0;
    let next_close = 100.0; // No change
    let price_change = next_close - current_close;

    // Buy action with no price change
    let buy_reward = (price_change / 10.0_f64).clamp(-1.0_f64, 1.0_f64) as f32;
    assert_eq!(
        buy_reward, 0.0,
        "Buy with no price change should give zero reward"
    );

    // Sell action with no price change
    let sell_reward = (-price_change / 10.0_f64).clamp(-1.0_f64, 1.0_f64) as f32;
    assert_eq!(
        sell_reward, 0.0,
        "Sell with no price change should give zero reward"
    );
}

/// Test reward clamping for extreme positive price change
#[test]
fn test_reward_clamping_extreme_positive() {
    let current_close = 100.0;
    let next_close = 1000.0; // +900% increase (extreme)
    let price_change = next_close - current_close;

    // Buy action should be clamped to 1.0 max
    let reward = (price_change / 10.0_f64).clamp(-1.0_f64, 1.0_f64) as f32;
    assert_eq!(
        reward, 1.0,
        "Extreme positive reward should be clamped to 1.0"
    );
}

/// Test reward clamping for extreme negative price change
#[test]
fn test_reward_clamping_extreme_negative() {
    let current_close = 1000.0;
    let next_close = 100.0; // -90% decrease (extreme)
    let price_change = next_close - current_close;

    // Buy action should be clamped to -1.0 min
    let reward = (price_change / 10.0_f64).clamp(-1.0_f64, 1.0_f64) as f32;
    assert_eq!(
        reward, -1.0,
        "Extreme negative reward should be clamped to -1.0"
    );
}

/// Test small price changes are preserved (no underflow)
#[test]
fn test_small_price_change_no_underflow() {
    let current_close = 100.0;
    let next_close = 100.05; // +0.05% tiny increase
    let price_change = next_close - current_close;

    let reward = (price_change / 10.0_f64).clamp(-1.0_f64, 1.0_f64) as f32;
    assert!(
        reward > 0.0,
        "Small positive price change should give small positive reward"
    );
    assert!(
        reward < 0.01,
        "Small price change should give proportionally small reward"
    );
    assert_eq!(reward, 0.005, "Reward should be 0.05 / 10.0 = 0.005");
}

/// Test that rewards vary with different actions (proves fix works)
#[test]
fn test_rewards_vary_with_actions() {
    let current_close = 100.0;
    let next_close = 110.0; // +10% increase
    let price_change = next_close - current_close;

    // Buy reward (positive for up move)
    let buy_reward = (price_change / 10.0_f64).clamp(-1.0_f64, 1.0_f64) as f32;

    // Sell reward (negative for up move)
    let sell_reward = (-price_change / 10.0_f64).clamp(-1.0_f64, 1.0_f64) as f32;

    // Hold reward (fixed penalty)
    let hold_reward = -0.0001_f32;

    // All three rewards should be DIFFERENT
    assert_ne!(
        buy_reward, sell_reward,
        "Buy and Sell rewards must differ for same price change"
    );
    assert_ne!(buy_reward, hold_reward, "Buy and Hold rewards must differ");
    assert_ne!(
        sell_reward, hold_reward,
        "Sell and Hold rewards must differ"
    );

    // Specifically: Buy should be positive, Sell negative, Hold small negative
    assert!(buy_reward > 0.0, "Buy should profit from up move");
    assert!(sell_reward < 0.0, "Sell should lose from up move");
    assert!(hold_reward < 0.0, "Hold should have opportunity cost");
    assert!(
        buy_reward.abs() > hold_reward.abs(),
        "Buy reward should be larger than Hold penalty"
    );
}

/// Test reward calculation matches trading economics
#[test]
fn test_reward_economics() {
    // Scenario: Price goes from 4000 to 4100 (ES futures typical move)
    let current_close = 4000.0;
    let next_close = 4100.0; // +100 point move
    let price_change = next_close - current_close;

    let buy_reward = (price_change / 10.0_f64).clamp(-1.0_f64, 1.0_f64) as f32;
    let sell_reward = (-price_change / 10.0_f64).clamp(-1.0_f64, 1.0_f64) as f32;

    // Buy should profit: +100 / 10 = +10 (clamped to +1.0)
    assert_eq!(
        buy_reward, 1.0,
        "Large up move should give max reward for Buy"
    );

    // Sell should lose: -100 / 10 = -10 (clamped to -1.0)
    assert_eq!(
        sell_reward, -1.0,
        "Large up move should give max loss for Sell"
    );

    // Magnitude should be equal but opposite
    assert_eq!(
        buy_reward, -sell_reward,
        "Buy and Sell rewards should be opposite for same move"
    );
}

/// Test reward bounds are enforced (security check)
#[test]
fn test_reward_bounds_enforced() {
    // Test extreme price changes don't cause overflow
    let extreme_cases = vec![
        (0.0, 1_000_000.0), // Huge increase
        (1_000_000.0, 0.0), // Huge decrease
        (100.0, 100.00001), // Tiny increase
        (100.0, 99.99999),  // Tiny decrease
    ];

    for (current, next) in extreme_cases {
        let price_change = next - current;

        let buy_reward = (price_change / 10.0_f64).clamp(-1.0_f64, 1.0_f64) as f32;
        let sell_reward = (-price_change / 10.0_f64).clamp(-1.0_f64, 1.0_f64) as f32;

        // All rewards must be within [-1.0, 1.0] bounds
        assert!(
            buy_reward >= -1.0 && buy_reward <= 1.0,
            "Buy reward must be within [-1.0, 1.0], got {}",
            buy_reward
        );
        assert!(
            sell_reward >= -1.0 && sell_reward <= 1.0,
            "Sell reward must be within [-1.0, 1.0], got {}",
            sell_reward
        );
    }
}

/// Test reward consistency across multiple trials (hyperopt fix verification)
#[test]
fn test_reward_varies_across_trials() {
    // Simulate different price sequences (like different hyperopt trials would see)
    let scenarios = vec![
        (100.0, 105.0), // +5% up move
        (100.0, 95.0),  // -5% down move
        (100.0, 100.0), // No change
        (100.0, 120.0), // +20% up move
    ];

    let mut buy_rewards = Vec::new();

    for (current, next) in scenarios {
        let price_change = next - current;
        let reward = (price_change / 10.0_f64).clamp(-1.0_f64, 1.0_f64) as f32;
        buy_rewards.push(reward);
    }

    // Rewards should NOT all be identical (proves hyperopt fix works)
    let first_reward = buy_rewards[0];
    let all_identical = buy_rewards.iter().all(|&r| r == first_reward);

    assert!(
        !all_identical,
        "Rewards must vary across different price scenarios (not all {:?})",
        buy_rewards
    );
}

/// Test NaN/Inf handling (security - prevent training crashes)
#[test]
fn test_nan_inf_handling() {
    // Test NaN price change
    let nan_price_change = f64::NAN;
    let reward_nan = (nan_price_change / 10.0_f64).clamp(-1.0_f64, 1.0_f64) as f32;
    assert!(
        reward_nan.is_nan(),
        "NaN input should produce NaN reward (will be caught by validation)"
    );

    // Test Inf price change
    let inf_price_change = f64::INFINITY;
    let reward_inf = (inf_price_change / 10.0_f64).clamp(-1.0_f64, 1.0_f64) as f32;
    assert_eq!(reward_inf, 1.0, "Inf input should be clamped to max reward");

    // Test -Inf price change
    let neg_inf_price_change = f64::NEG_INFINITY;
    let reward_neg_inf = (neg_inf_price_change / 10.0_f64).clamp(-1.0_f64, 1.0_f64) as f32;
    assert_eq!(
        reward_neg_inf, -1.0,
        "-Inf input should be clamped to min reward"
    );
}

/// Test reward magnitude is economically reasonable
#[test]
fn test_reward_magnitude_reasonable() {
    // Typical ES futures tick: $12.50 per 0.25 point move
    // Typical daily range: 50-100 points

    // Scenario 1: Small 1-point move (typical intraday)
    let small_move = 1.0;
    let small_reward = (small_move / 10.0_f64).clamp(-1.0_f64, 1.0_f64) as f32;
    assert_eq!(small_reward, 0.1, "1-point move should give 0.1 reward");

    // Scenario 2: Medium 10-point move (good trade)
    let medium_move = 10.0;
    let medium_reward = (medium_move / 10.0_f64).clamp(-1.0_f64, 1.0_f64) as f32;
    assert_eq!(
        medium_reward, 1.0,
        "10-point move should give max 1.0 reward"
    );

    // Scenario 3: Large 50-point move (rare but possible)
    let large_move = 50.0;
    let large_reward = (large_move / 10.0_f64).clamp(-1.0_f64, 1.0_f64) as f32;
    assert_eq!(
        large_reward, 1.0,
        "Large move should be clamped to 1.0 (prevents over-scaling)"
    );
}

/// Test that Hold penalty is smaller than typical trading rewards
#[test]
fn test_hold_penalty_vs_trading_rewards() {
    let hold_penalty = -0.0001_f32;

    // Even a tiny 0.1-point move should give larger reward than Hold penalty
    let tiny_move_reward = (0.1 / 10.0_f64).clamp(-1.0_f64, 1.0_f64) as f32; // 0.01

    assert!(
        tiny_move_reward.abs() > hold_penalty.abs(),
        "Tiny trading reward ({}) should be larger than Hold penalty ({})",
        tiny_move_reward,
        hold_penalty
    );
}
