foxhunt/adaptive-strategy/examples/ppo_position_sizing_demo.rs

//! PPO Position Sizing Integration Demo
//!
//! This example demonstrates how to use the PPO (Proximal Policy Optimization)
//! position sizer integrated into the adaptive-strategy crate for continuous,
//! risk-aware position optimization.

use adaptive_strategy::{
    config::{PositionSizingMethod, RiskConfig},
    risk::{PPOPositionSizerConfig, RewardFunctionConfig, RiskManager},
};
use foxhunt_core::types::prelude::*;
use rust_decimal_macros::dec;
use std::collections::HashMap;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🚀 PPO Position Sizing Integration Demo");
    println!("========================================");

    // 1. Configure PPO Position Sizer
    let ppo_config = PPOPositionSizerConfig {
        learning_rate: 1e-4,
        gamma: 0.99,
        lambda: 0.95,
        epsilon: 0.2,
        value_loss_coef: 0.5,
        entropy_coef: 0.01,
        max_grad_norm: 0.5,
        batch_size: 64,
        update_epochs: 10,
        target_kl: 0.01,
        reward_function: RewardFunctionConfig::Combined {
            sharpe_weight: 0.4,
            drawdown_weight: 0.3,
            var_weight: 0.2,
            kelly_weight: 0.1,
        },
        risk_free_rate: dec!(0.02),
        var_confidence: dec!(0.05),
        max_position_size: dec!(0.25), // 25% max position
        min_position_size: dec!(0.01), // 1% min position
        market_regime_adaptation: true,
        adaptive_learning_rate: true,
        kelly_comparison_weight: dec!(0.3),
    };

    // 2. Configure Risk Management with PPO
    let risk_config = RiskConfig {
        max_portfolio_var: 0.02,
        var_confidence_level: 0.95,
        max_drawdown_threshold: 0.05,
        position_sizing_method: PositionSizingMethod::PPO,
        kelly_fraction: 0.25,
        max_leverage: 2.0,
        stop_loss_pct: 0.02,
        take_profit_pct: 0.04,
    };
    // 3. Initialize Risk Manager with PPO
    let mut risk_manager = RiskManager::new(risk_config.clone())?;
    // Configure PPO for this risk manager
    // risk_manager.configure_ppo(ppo_config)?;

    println!("✅ PPO Position Sizer initialized with sophisticated reward function");

    // 4. Create Sample Market Data and Portfolio State
    let current_time = chrono::Utc::now();
    let symbols = vec!["AAPL", "GOOGL", "MSFT", "TSLA", "NVDA"];

    // Sample market data
    let mut market_data = HashMap::new();
    let mut prices = HashMap::new();
    let sample_prices = [
        dec!(150.0),  // AAPL
        dec!(2800.0), // GOOGL
        dec!(420.0),  // MSFT
        dec!(250.0),  // TSLA
        dec!(900.0),  // NVDA
    ];

    for (i, symbol) in symbols.iter().enumerate() {
        let price = Price::new(sample_prices[i]);
        prices.insert(symbol.to_string(), price);

        market_data.insert(
            symbol.to_string(),
            MarketData {
                symbol: symbol.to_string(),
                price,
                bid: Price::new(sample_prices[i] - dec!(0.01)),
                ask: Price::new(sample_prices[i] + dec!(0.01)),
                volume: Quantity::new(dec!(1000000)),
                timestamp: current_time,
            },
        );
    }

    // Current portfolio positions
    let mut current_positions = HashMap::new();
    current_positions.insert(
        "AAPL".to_string(),
        Position {
            symbol: "AAPL".to_string(),
            quantity: Quantity::new(dec!(100)),
            average_cost: Price::new(dec!(145.0)),
            market_value: Price::new(sample_prices[0]),
            timestamp: current_time,
        },
    );

    let portfolio_value = dec!(100000.0); // $100k portfolio

    println!("📊 Sample portfolio value: ${}", portfolio_value);
    println!("📈 Current positions: {} symbols", current_positions.len());

    // 5. Demonstrate PPO Position Sizing for Each Symbol
    println!("\n🧠 PPO Position Sizing Analysis:");
    println!("================================");

    for symbol in &symbols {
        let market_data_item = market_data.get(symbol).unwrap();

        // Calculate PPO-optimized position size
        let ppo_position_size = risk_manager
            .calculate_ppo_position_size(
                symbol,
                &market_data_item,
                &current_positions,
                portfolio_value,
            )
            .await?;

        // Get Kelly criterion comparison
        let kelly_size = risk_manager
            .calculate_kelly_position_size(
                symbol,
                &market_data_item,
                &current_positions,
                portfolio_value,
            )
            .await
            .unwrap_or(Decimal::ZERO);

        let position_value = ppo_position_size * portfolio_value;
        let shares = position_value / market_data_item.price.value();

        println!("Symbol: {}", symbol);
        println!("  💰 Current Price: ${:.2}", market_data_item.price.value());
        println!(
            "  🎯 PPO Position Size: {:.4} ({:.2}%)",
            ppo_position_size,
            ppo_position_size * Decimal::from(100)
        );
        println!(
            "  📊 Kelly Comparison: {:.4} ({:.2}%)",
            kelly_size,
            kelly_size * Decimal::from(100)
        );
        println!("  💵 Position Value: ${:.2}", position_value);
        println!("  📈 Shares: {:.0}", shares);

        // Show PPO advantage analysis
        let ppo_advantage = ppo_position_size - kelly_size;
        if ppo_advantage > Decimal::ZERO {
            println!(
                "  ⬆️  PPO recommends {}% MORE than Kelly (+{:.2}%)",
                symbol,
                ppo_advantage * Decimal::from(100)
            );
        } else if ppo_advantage < Decimal::ZERO {
            println!(
                "  ⬇️  PPO recommends {}% LESS than Kelly ({:.2}%)",
                symbol,
                ppo_advantage * Decimal::from(100)
            );
        } else {
            println!("  ➡️  PPO aligns with Kelly criterion");
        }
        println!();
    }

    // 6. Demonstrate Learning and Adaptation
    println!("🔄 PPO Learning and Adaptation:");
    println!("===============================");

    // Simulate market data updates and PPO learning
    for epoch in 1..=3 {
        println!("Learning Epoch {}", epoch);

        // Simulate some market returns and portfolio performance
        let returns = vec![
            dec!(0.02),  // 2% return
            dec!(-0.01), // -1% return
            dec!(0.015), // 1.5% return
        ];

        let portfolio_returns = vec![
            dec!(0.018),  // 1.8% portfolio return
            dec!(-0.008), // -0.8% portfolio return
            dec!(0.012),  // 1.2% portfolio return
        ];

        // Update PPO policy based on observed performance
        for (i, (market_return, portfolio_return)) in
            returns.iter().zip(portfolio_returns.iter()).enumerate()
        {
            risk_manager
                .update_ppo_policy(
                    &symbols[i % symbols.len()],
                    &market_data[&symbols[i % symbols.len()]],
                    &current_positions,
                    portfolio_value,
                    *portfolio_return,
                )
                .await?;

            println!(
                "  Step {}: Market {:.2}% → Portfolio {:.2}% (PPO adapting)",
                i + 1,
                market_return * Decimal::from(100),
                portfolio_return * Decimal::from(100)
            );
        }

        println!("  ✅ PPO policy updated based on performance feedback");
    }

    // 7. Show Risk Management Integration
    println!("\n🛡️  Risk Management Integration:");
    println!("================================");

    // Check risk limits
    let total_exposure = symbols
        .iter()
        .map(|symbol| {
            let market_data_item = market_data.get(symbol).unwrap();
            // Use a future to handle async function
            tokio::task::block_in_place(|| {
                tokio::runtime::Handle::current().block_on(async {
                    risk_manager
                        .calculate_ppo_position_size(
                            symbol,
                            market_data_item,
                            &current_positions,
                            portfolio_value,
                        )
                        .await
                        .unwrap_or(Decimal::ZERO)
                })
            })
        })
        .sum::<Decimal>();

    println!(
        "📊 Total Portfolio Exposure: {:.2}%",
        total_exposure * Decimal::from(100)
    );

    if total_exposure <= Decimal::ONE {
        println!("✅ Portfolio exposure within 100% limit");
    } else {
        println!("⚠️  Portfolio exposure exceeds 100% - PPO risk constraints active");
    }

    // Show individual position risk checks
    for symbol in &symbols {
        let market_data_item = market_data.get(symbol).unwrap();
        let position_size = risk_manager
            .calculate_ppo_position_size(
                symbol,
                market_data_item,
                &current_positions,
                portfolio_value,
            )
            .await?;

        let max_allowed = strategy_config.risk_config.max_position_size;
        if position_size <= max_allowed {
            println!(
                "✅ {}: {:.2}% ≤ {:.2}% (within limits)",
                symbol,
                position_size * Decimal::from(100),
                max_allowed * Decimal::from(100)
            );
        } else {
            println!(
                "🚫 {}: {:.2}% > {:.2}% (position capped)",
                symbol,
                position_size * Decimal::from(100),
                max_allowed * Decimal::from(100)
            );
        }
    }

    // 8. Performance Metrics
    println!("\n📈 PPO Performance Metrics:");
    println!("===========================");

    let performance_metrics = risk_manager.get_ppo_performance_metrics().await?;
    println!(
        "🎯 Average Reward: {:.6}",
        performance_metrics
            .get("average_reward")
            .unwrap_or(&Decimal::ZERO)
    );
    println!(
        "📊 Policy Loss: {:.6}",
        performance_metrics
            .get("policy_loss")
            .unwrap_or(&Decimal::ZERO)
    );
    println!(
        "💰 Value Loss: {:.6}",
        performance_metrics
            .get("value_loss")
            .unwrap_or(&Decimal::ZERO)
    );
    println!(
        "🔀 Entropy: {:.6}",
        performance_metrics.get("entropy").unwrap_or(&Decimal::ZERO)
    );
    println!(
        "📈 Learning Rate: {:.2e}",
        performance_metrics
            .get("learning_rate")
            .unwrap_or(&dec!(0.0001))
    );

    println!("\n🎉 PPO Position Sizing Demo Complete!");
    println!("=====================================");
    println!("The PPO agent continuously optimizes position sizes by:");
    println!("• 🧠 Learning from market feedback and portfolio performance");
    println!("• 🎯 Balancing risk-return using sophisticated reward functions");
    println!("• 📊 Comparing and integrating with Kelly criterion insights");
    println!("• 🛡️  Respecting strict risk management constraints");
    println!("• 🔄 Adapting learning rate based on market regime detection");
    println!("\nPPO Integration Successfully Demonstrated! 🚀");

    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;

    #[tokio::test]
    async fn test_ppo_demo_initialization() {
        // Test that the demo can initialize without errors
        let ppo_config = PPOPositionSizerConfig {
            learning_rate: 1e-4,
            gamma: 0.99,
            lambda: 0.95,
            epsilon: 0.2,
            value_loss_coef: 0.5,
            entropy_coef: 0.01,
            max_grad_norm: 0.5,
            batch_size: 64,
            update_epochs: 10,
            target_kl: 0.01,
            reward_function: RewardFunctionConfig::Sharpe,
            risk_free_rate: dec!(0.02),
            var_confidence: dec!(0.05),
            max_position_size: dec!(0.25),
            min_position_size: dec!(0.01),
            market_regime_adaptation: true,
            adaptive_learning_rate: true,
            kelly_comparison_weight: dec!(0.3),
        };

        let strategy_config = AdaptiveStrategyConfig {
            risk_config: RiskConfig {
                max_position_size: dec!(0.25),
                max_portfolio_leverage: dec!(2.0),
                var_limit: dec!(0.02),
                max_drawdown: dec!(0.05),
                max_correlation: dec!(0.7),
                rebalance_threshold: dec!(0.05),
                position_sizing_method: PositionSizingMethod::PPO,
            },
            min_liquidity: dec!(1000000),
            max_volatility: dec!(0.3),
            correlation_threshold: dec!(0.8),
            rebalance_frequency: 86400,
        };

        let risk_manager =
            RiskManager::new(strategy_config.risk_config.clone()).with_ppo_config(ppo_config);

        assert!(
            risk_manager.is_ok(),
            "PPO Risk Manager should initialize successfully"
        );
    }
}