foxhunt/data/examples/order_submission.rs

//! Order Submission Example
//!
//! This example demonstrates how to submit different types of orders
//! to Interactive Brokers TWS.
//!
//! Usage:
//!   cargo run --example order_submission
//!
//! Prerequisites:
//! - TWS or IB Gateway running with API enabled
//! - Paper trading account recommended for testing

use data::{init, paper_trading_config, InteractiveBrokersAdapter};
use std::collections::HashMap;
use std::time::Duration;
use tokio::time::sleep;
use tracing::{error, info, warn};
// use trading_engine::prelude::*; // REMOVED - prelude does not exist

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    // Initialize logging
    init()?;

    info!("=== Interactive Brokers Order Submission Example ===");

    // Create adapter and connect
    let config = paper_trading_config();
    let mut adapter = InteractiveBrokersAdapter::new(config);

    info!("Connecting to TWS...");
    adapter.connect().await?;

    if !adapter.is_connected() {
        error!("Failed to establish connection");
        return Err("Connection failed".into());
    }

    info!("✅ Connected to TWS");

    // Start message processing to handle order responses
    let adapter_arc = std::sync::Arc::new(adapter);
    let process_handle = {
        let adapter = adapter_arc.clone();
        tokio::spawn(async move {
            if let Err(e) = adapter.process_messages().await {
                error!("Message processing error: {}", e);
            }
        })
    };

    // Wait for connection to stabilize
    sleep(Duration::from_secs(2)).await;

    // Example 1: Market Order
    info!("\n--- Example 1: Market Order ---");
    let market_order = Order {
        id: OrderId::new(),
        symbol: Symbol::from("AAPL"),
        side: OrderSide::Buy,
        quantity: Quantity::new(10.0)?,
        order_type: OrderType::Market,
        price: None,
        stop_price: None,
        time_in_force: TimeInForce::Day,
        created_at: chrono::Utc::now(),
        updated_at: chrono::Utc::now(),
        filled_quantity: Quantity::ZERO,
        status: OrderStatus::New,
        metadata: HashMap::new(),
    };

    info!("Submitting market order: Buy 10 AAPL at market");
    match adapter_arc.submit_order(&market_order).await {
        Ok(tws_order_id) => {
            info!("✅ Market order submitted, TWS ID: {}", tws_order_id);

            // Wait for order processing
            sleep(Duration::from_secs(3)).await;

            // Cancel the order (for demo purposes)
            info!("Cancelling market order");
            adapter_arc.cancel_order(&tws_order_id).await?;
            info!("✅ Market order cancelled");
        },
        Err(e) => {
            error!("❌ Failed to submit market order: {}", e);
        },
    }

    sleep(Duration::from_secs(2)).await;

    // Example 2: Limit Order
    info!("\n--- Example 2: Limit Order ---");
    let limit_order = Order {
        id: OrderId::new(),
        symbol: Symbol::from("GOOGL"),
        side: OrderSide::Sell,
        quantity: Quantity::new(5.0)?,
        order_type: OrderType::Limit,
        price: Some(Price::new(2500.00)?), // Limit price
        stop_price: None,
        time_in_force: TimeInForce::GoodTillCancel,
        created_at: chrono::Utc::now(),
        updated_at: chrono::Utc::now(),
        filled_quantity: Quantity::ZERO,
        status: OrderStatus::New,
        metadata: HashMap::new(),
    };

    info!("Submitting limit order: Sell 5 GOOGL at $2500.00");
    match adapter_arc.submit_order(&limit_order).await {
        Ok(tws_order_id) => {
            info!("✅ Limit order submitted, TWS ID: {}", tws_order_id);

            // Wait for order processing
            sleep(Duration::from_secs(3)).await;

            // Cancel the order
            info!("Cancelling limit order");
            adapter_arc.cancel_order(&tws_order_id).await?;
            info!("✅ Limit order cancelled");
        },
        Err(e) => {
            error!("❌ Failed to submit limit order: {}", e);
        },
    }

    sleep(Duration::from_secs(2)).await;

    // Example 3: Stop Order
    info!("\n--- Example 3: Stop Order ---");
    let stop_order = Order {
        id: OrderId::new(),
        symbol: Symbol::from("MSFT"),
        side: OrderSide::Buy,
        quantity: Quantity::new(20.0)?,
        order_type: OrderType::Stop,
        price: Some(Price::new(350.00)?), // Stop price
        stop_price: Some(Price::new(350.00)?),
        time_in_force: TimeInForce::Day,
        created_at: chrono::Utc::now(),
        updated_at: chrono::Utc::now(),
        filled_quantity: Quantity::ZERO,
        status: OrderStatus::New,
        metadata: HashMap::new(),
    };

    info!("Submitting stop order: Buy 20 MSFT stop at $350.00");
    match adapter_arc.submit_order(&stop_order).await {
        Ok(tws_order_id) => {
            info!("✅ Stop order submitted, TWS ID: {}", tws_order_id);

            // Wait for order processing
            sleep(Duration::from_secs(3)).await;

            // Cancel the order
            info!("Cancelling stop order");
            adapter_arc.cancel_order(&tws_order_id).await?;
            info!("✅ Stop order cancelled");
        },
        Err(e) => {
            error!("❌ Failed to submit stop order: {}", e);
        },
    }

    sleep(Duration::from_secs(2)).await;

    // Example 4: Multiple Orders
    info!("\n--- Example 4: Multiple Orders ---");
    let orders = vec![
        Order {
            id: OrderId::new(),
            symbol: Symbol::from("TSLA"),
            side: OrderSide::Buy,
            quantity: Quantity::new(1.0)?,
            order_type: OrderType::Limit,
            price: Some(Price::new(200.00)?),
            stop_price: None,
            time_in_force: TimeInForce::Day,
            created_at: chrono::Utc::now(),
            updated_at: chrono::Utc::now(),
            filled_quantity: Quantity::ZERO,
            status: OrderStatus::New,
            metadata: HashMap::new(),
        },
        Order {
            id: OrderId::new(),
            symbol: Symbol::from("NVDA"),
            side: OrderSide::Sell,
            quantity: Quantity::new(2.0)?,
            order_type: OrderType::Limit,
            price: Some(Price::new(800.00)?),
            stop_price: None,
            time_in_force: TimeInForce::Day,
            created_at: chrono::Utc::now(),
            updated_at: chrono::Utc::now(),
            filled_quantity: Quantity::ZERO,
            status: OrderStatus::New,
            metadata: HashMap::new(),
        },
    ];

    let mut submitted_orders = Vec::new();

    for (i, order) in orders.iter().enumerate() {
        info!(
            "Submitting order {}: {} {} {} @ ${:.2}",
            i + 1,
            match order.side {
                OrderSide::Buy => "Buy",
                OrderSide::Sell => "Sell",
            },
            order.quantity.to_f64(),
            order.symbol.to_string(),
            order.price.as_ref().unwrap().to_f64()
        );

        match adapter_arc.submit_order(order).await {
            Ok(tws_order_id) => {
                info!("✅ Order {} submitted, TWS ID: {}", i + 1, tws_order_id);
                submitted_orders.push(tws_order_id);
            },
            Err(e) => {
                error!("❌ Failed to submit order {}: {}", i + 1, e);
            },
        }

        // Small delay between orders
        sleep(Duration::from_millis(500)).await;
    }

    // Wait for order processing
    info!("Waiting for order processing...");
    sleep(Duration::from_secs(5)).await;

    // Cancel all submitted orders
    info!("Cancelling all submitted orders...");
    for (i, tws_order_id) in submitted_orders.iter().enumerate() {
        match adapter_arc.cancel_order(tws_order_id).await {
            Ok(()) => {
                info!("✅ Cancelled order {}", i + 1);
            },
            Err(e) => {
                warn!("⚠️ Failed to cancel order {}: {}", i + 1, e);
            },
        }
    }

    // Stop message processing
    info!("Stopping message processing...");
    process_handle.abort();

    // Disconnect
    let mut adapter_mut =
        std::sync::Arc::try_unwrap(adapter_arc).map_err(|_| "Failed to unwrap adapter")?;
    adapter_mut.disconnect().await?;

    info!("=== Order submission example completed ===");
    Ok(())
}