foxhunt/crates/ml/tests/debug_position_delta_test.rs

#![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,
)]
//! Debug test to trace position_delta sign logic
//!
//! This test verifies whether position_delta is positive or negative
//! when going from FLAT to LONG.

#![allow(unused_crate_dependencies)]

use ml::dqn::action_space::{ExposureLevel, FactoredAction, OrderType, Urgency};
use ml::dqn::portfolio_tracker::PortfolioTracker;

#[test]
fn test_position_delta_sign_when_buying() {
    let mut tracker = PortfolioTracker::new(100_000.0, 0.0001, 1.0);

    // Trace internal state
    println!("=== INITIAL STATE ===");
    println!("Cash: ${:.2}", tracker.cash_balance());
    println!("Position: {:.2} contracts", tracker.current_position());

    // Execute: Go from FLAT (0) to LONG (1.0 contract)
    let action = FactoredAction::new(
        ExposureLevel::Long100,  // target_exposure = +1.0
        OrderType::Market,
        Urgency::Normal
    );

    println!("\n=== EXECUTING ACTION ===");
    println!("Action: Long100 (target_exposure = +1.0)");
    println!("Price: $5,600.00");
    println!("max_position parameter: 1.0");

    // Execute the action
    tracker.execute_action(action, 5600.0, 1.0);

    println!("\n=== AFTER EXECUTION ===");
    println!("Cash: ${:.2}", tracker.cash_balance());
    println!("Position: {:.2} contracts", tracker.current_position());
    println!("Portfolio Value: ${:.2}", tracker.total_value(5600.0));

    // Manually calculate what position_delta should have been
    let target_exposure: f32 = 1.0;  // Long100
    let max_position: f32 = 1.0;
    let target_position: f32 = target_exposure * max_position;  // 1.0
    let clamped_position: f32 = target_position.clamp(-1.0, 1.0);  // 1.0
    let initial_position: f32 = 0.0;
    let position_delta: f32 = clamped_position - initial_position;  // 1.0 - 0.0 = +1.0

    println!("\n=== MANUAL CALCULATION ===");
    println!("target_position: {:.2}", target_position);
    println!("clamped_position: {:.2}", clamped_position);
    println!("initial_position: {:.2}", initial_position);
    println!("position_delta: {:.2} (should be POSITIVE for buying)", position_delta);

    // Expected behavior:
    // - position_delta = +1.0 (POSITIVE when buying/going long)
    // - Line 268 checks `if position_delta < 0.0` → FALSE
    // - Cash check BYPASSED for buying!

    println!("\n=== SIGN LOGIC ANALYSIS ===");
    if position_delta < 0.0 {
        println!("❌ position_delta < 0.0: Cash check would RUN (but this is a BUY!)");
    } else {
        println!("✅ position_delta >= 0.0: Cash check BYPASSED (THIS IS THE BUG!)");
    }

    // Expected cash after buying 1 contract at $5,600:
    // cash = 100,000 + (+1.0 * 5,600) - transaction_cost
    // But V6 formula says: cash += position_delta * price - cost
    // = 100,000 + (1.0 * 5,600) - cost = 105,600 - cost (ADDS cash when buying!)

    let expected_cash = 100_000.0 - (1.0 * 5600.0) - (1.0 * 5600.0 * 0.0015);
    println!("\n=== EXPECTED VS ACTUAL ===");
    println!("Expected cash (correct): ${:.2}", expected_cash);
    println!("Actual cash: ${:.2}", tracker.cash_balance());

    // The bug: position_delta is POSITIVE when buying, so:
    // 1. Line 268 check fails (position_delta < 0.0 → false)
    // 2. Cash check bypassed
    // 3. Line 310: cash += position_delta * price - cost
    //    = 100,000 + (+1.0 * 5,600) - 8.4 = 105,591.60 (ADDS cash!)

    if tracker.cash_balance() > 100_000.0 {
        println!("\n❌ BUG CONFIRMED: Cash INCREASED when buying (should decrease)");
    } else {
        println!("\n✅ Cash correctly decreased when buying");
    }
}

#[test]
fn test_position_delta_sign_when_selling() {
    let mut tracker = PortfolioTracker::new(100_000.0, 0.0001, 1.0);

    println!("\n=== TEST 2: GOING SHORT ===");
    println!("Initial: FLAT (0 contracts) → Short100 (-1.0 contracts)");

    let action = FactoredAction::new(
        ExposureLevel::Short100,  // target_exposure = -1.0
        OrderType::Market,
        Urgency::Normal
    );

    tracker.execute_action(action, 5600.0, 1.0);

    // Calculate position_delta
    let target_exposure: f32 = -1.0;  // Short100
    let target_position: f32 = target_exposure * 1.0;  // -1.0
    let clamped_position: f32 = target_position.clamp(-1.0, 1.0);  // -1.0
    let position_delta: f32 = clamped_position - 0.0;  // -1.0 - 0.0 = -1.0

    println!("position_delta: {:.2} (NEGATIVE for selling/going short)", position_delta);

    if position_delta < 0.0 {
        println!("✅ position_delta < 0.0: Cash check would RUN (but this is a SELL, not a BUY!)");
    } else {
        println!("❌ position_delta >= 0.0: Cash check BYPASSED");
    }

    // Expected cash after shorting 1 contract at $5,600:
    // Should GAIN $5,600 minus transaction cost
    let expected_cash = 100_000.0 + (1.0 * 5600.0) - (1.0 * 5600.0 * 0.0015);
    println!("Expected cash: ${:.2}", expected_cash);
    println!("Actual cash: ${:.2}", tracker.cash_balance());

    // Line 310: cash += position_delta * price - cost
    // = 100,000 + (-1.0 * 5,600) - 8.4 = 94,391.60 (SUBTRACTS cash!)

    if tracker.cash_balance() < 100_000.0 {
        println!("❌ BUG CONFIRMED: Cash DECREASED when selling short (should increase)");
    } else {
        println!("✅ Cash correctly increased when selling short");
    }
}