foxhunt/tli/src/commands/trade.rs

//! TLI Trade Commands
//!
//! Trading operations with ML-powered decision making.
//!
//! # Architecture
//! This module acts as a routing layer for trade-related commands:
//! - `ml` - ML-powered trading operations (ensemble voting, predictions, performance)
//!
//! # Command Flow
//! User → main.rs → trade.rs → `trade_ml.rs` → API Gateway → Trading Service
//!
//! # Future Extensions
//! - `manual` - Manual order submission
//! - `modify` - Order modification
//! - `cancel` - Order cancellation

use anyhow::Result;
use clap::{Args, Subcommand};

use crate::commands::trade_ml::{TradeMlArgs, execute_trade_ml_command};

/// Trade command arguments
#[derive(Debug, Args)]
pub struct TradeArgs {
    #[command(subcommand)]
    pub command: TradeCommand,
}

/// Trade subcommands
#[derive(Debug, Subcommand)]
pub enum TradeCommand {
    /// ML-powered trading commands
    #[command(name = "ml")]
    Ml(TradeMlArgs),
}

/// Execute trade command
///
/// # Arguments
/// * `args` - Trade command arguments (contains subcommand)
/// * `api_gateway_url` - API Gateway URL for gRPC connection
/// * `jwt_token` - JWT authentication token
///
/// # Returns
/// - `Ok(())` - Command executed successfully
/// - `Err(anyhow::Error)` - Command execution failed
///
/// # Routing
/// This function routes to the appropriate subcommand handler:
/// - `TradeCommand::Ml` → `execute_trade_ml_command()`
///
/// # Example
/// ```no_run
/// use tli::commands::trade::{TradeArgs, TradeCommand, execute_trade_command};
/// use tli::commands::trade_ml::TradeMlArgs;
///
/// # async fn example() -> anyhow::Result<()> {
/// let args = TradeArgs {
///     command: TradeCommand::Ml(TradeMlArgs { /* ... */ }),
/// };
///
/// execute_trade_command(args, "http://localhost:50051", "jwt-token").await?;
/// # Ok(())
/// # }
/// ```
pub async fn execute_trade_command(
    args: TradeArgs,
    api_gateway_url: &str,
    jwt_token: &str,
) -> Result<()> {
    match args.command {
        TradeCommand::Ml(ml_args) => execute_trade_ml_command(ml_args, api_gateway_url, jwt_token).await,
    }
}

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

    #[test]
    fn test_trade_args_structure() {
        // Verify TradeArgs struct is correctly defined
        // This ensures the command structure is valid for clap parsing
        use clap::Parser;

        #[derive(Parser)]
        struct TestCli {
            #[command(flatten)]
            trade_args: TradeArgs,
        }

        // Test that the structure compiles and can be parsed
        // (Actual parsing is tested in main.rs integration tests)
    }

    #[test]
    fn test_trade_command_variants() {
        // Verify TradeCommand enum has expected variants
        use crate::commands::trade_ml::TradeMlArgs;

        let _ml_variant = TradeCommand::Ml(TradeMlArgs {
            command: crate::commands::trade_ml::TradeMlCommand::Performance {
                model: None,
            },
        });

        // Test compiles = variants are correctly defined
    }

    #[tokio::test]
    async fn test_execute_trade_command_routing() {
        use crate::commands::trade_ml::{TradeMlArgs, TradeMlCommand};

        // Create a test TradeArgs with ML subcommand
        let args = TradeArgs {
            command: TradeCommand::Ml(TradeMlArgs {
                command: TradeMlCommand::Performance {
                    model: Some("DQN".to_owned()),
                },
            }),
        };

        // Execute command (will fail due to no actual API Gateway, but tests routing)
        let result = execute_trade_command(
            args,
            "http://localhost:50051",
            "mock-token"
        ).await;

        // Should attempt to execute (may fail due to connection, but routing works)
        assert!(result.is_ok() || result.is_err());
    }
}