//! Simple test to verify our implementations compile and work

#[cfg(test)]
mod integration_tests {
    use crate::dqn::{WorkingDQN, WorkingDQNConfig, Experience, TradingAction};
    use crate::ppo::{WorkingPPO, PPOConfig};
    
    #[test]
    fn test_dqn_creation_and_basic_ops() {
        let config = WorkingDQNConfig {
            state_dim: 10,
            num_actions: 3,
            hidden_dims: vec![16, 8],
            replay_buffer_capacity: 100,
            batch_size: 4,
            min_replay_size: 10,
            ..WorkingDQNConfig::default()
        };
        
        let dqn_result = WorkingDQN::new(config);
        assert!(dqn_result.is_ok(), "Failed to create DQN: {:?}", dqn_result.err());
        
        let mut dqn = dqn_result.expect("DQN model should be created successfully in test"); // Safe after assertion
        
        // Test action selection
        let state = vec![0.1; 10];
        let action_result = dqn.select_action(&state);
        assert!(action_result.is_ok(), "Failed to select action: {:?}", action_result.err());
        
        if let Ok(action) = action_result {
            assert!(matches!(action, TradingAction::Buy | TradingAction::Sell | TradingAction::Hold));
        }
        
        // Test experience storage
        let experience = Experience::new(
            vec![0.1; 10],
            0,
            1.0,
            vec![0.2; 10],
            false,
        );
        let store_result = dqn.store_experience(experience);
        assert!(store_result.is_ok(), "Failed to store experience: {:?}", store_result.err());
        assert_eq!(dqn.get_replay_buffer_size(), 1);
    }
    
    #[test] 
    fn test_ppo_creation_and_basic_ops() {
        let config = PPOConfig {
            state_dim: 10,
            num_actions: 3,
            policy_hidden_dims: vec![16],
            value_hidden_dims: vec![16],
            mini_batch_size: 2,
            ..PPOConfig::default()
        };
        
        let ppo_result = WorkingPPO::new(config);
        assert!(ppo_result.is_ok(), "Failed to create PPO: {:?}", ppo_result.err());
        
        let ppo = ppo_result.expect("PPO model should be created successfully in test"); // Safe after assertion
        
        // Test action selection
        let state = vec![0.1; 10];
        let act_result = ppo.act(&state);
        assert!(act_result.is_ok(), "Failed to act: {:?}", act_result.err());
        
        if let Ok((action, value)) = act_result {
            assert!(matches!(action, TradingAction::Buy | TradingAction::Sell | TradingAction::Hold));
            assert!(value.is_finite());
        }
}