TradingConfig

pub struct TradingConfig {
    pub live_enabled: bool,
    pub symbols: Vec<String>,
    pub initial_capital: f64,
    pub max_position: i64,
    pub max_order_size: u32,
}

impl Default for TradingConfig

use nano_gateway::config::TradingConfig;

let config = TradingConfig::default();
assert_eq!(config.live_enabled, false);
assert_eq!(config.max_position, 50);

use nano_gateway::config::TradingConfig;

let paper_config = TradingConfig {
    live_enabled: false,
    symbols: vec![
        "ESH24".to_string(),
        "NQH24".to_string(),
    ],
    initial_capital: 100_000.0,
    max_position: 20,
    max_order_size: 5,
};

let live_config = TradingConfig {
    live_enabled: true,
    symbols: vec!["ESH24".to_string()],
    initial_capital: 500_000.0,
    max_position: 10,  // Conservative for live
    max_order_size: 2,  // Small orders for live
};

let multi_config = TradingConfig {
    live_enabled: false,
    symbols: vec![
        "ESH24".to_string(),  // S&P 500 E-mini
        "NQH24".to_string(),  // Nasdaq 100 E-mini
        "YMH24".to_string(),  // Dow E-mini
        "RTYM24".to_string(), // Russell 2000 E-mini
    ],
    initial_capital: 2_000_000.0,
    max_position: 50,  // Per instrument
    max_order_size: 10,
};

let hft_config = TradingConfig {
    live_enabled: true,
    symbols: vec!["ESH24".to_string()],
    initial_capital: 1_000_000.0,
    max_position: 100,
    max_order_size: 20,  // Larger orders for HFT
};

if config.live_enabled {
    println!("WARNING: Live trading is ENABLED");
    // Additional confirmation required
} else {
    println!("Paper trading mode - safe to test");
}

let config = TradingConfig {
    symbols: vec![
        "ESM24".to_string(),  // ES June 2024
        "ESU24".to_string(),  // ES September 2024
    ],
    ..Default::default()
};

// Access symbols
for symbol in &config.symbols {
    println!("Trading: {}", symbol);
}

let capital = config.initial_capital;
let risk_per_trade = capital * 0.01;  // 1% risk per trade

println!("Trading with ${:.2}", capital);
println!("Max risk per trade: ${:.2}", risk_per_trade);

let config = TradingConfig {
    max_position: 50,
    ..Default::default()
};

// Check if order would exceed limit
let current_position = 45;
let order_size = 10;

if current_position + order_size > config.max_position {
    println!("Order would exceed max position limit");
}

let config = TradingConfig {
    max_order_size: 10,
    ..Default::default()
};

// Split large orders if needed
let desired_size = 25;
let num_orders = (desired_size + config.max_order_size - 1) / config.max_order_size;

println!("Split into {} orders of {} contracts", 
    num_orders, config.max_order_size);

pub struct AppConfig {
    pub name: String,
    pub log_level: String,
    pub metrics_port: u16,
    pub data_dir: PathBuf,
    pub model_path: Option<PathBuf>,
    pub trading: TradingConfig,
}

use nano_gateway::config::AppConfig;

let config = AppConfig::load("config.toml")?;
let trading = &config.trading;

println!("Live trading: {}", trading.live_enabled);

let config = AppConfig::from_env()?;

name = "nanoarb"
log_level = "info"
metrics_port = 9090
data_dir = "data"

[trading]
live_enabled = false
symbols = ["ESH24", "NQH24"]
initial_capital = 1000000.0
max_position = 50
max_order_size = 10

fn validate_trading_config(config: &TradingConfig) -> Result<(), String> {
    if config.initial_capital <= 0.0 {
        return Err("Initial capital must be positive".to_string());
    }
    
    if config.max_position <= 0 {
        return Err("Max position must be positive".to_string());
    }
    
    if config.max_order_size == 0 {
        return Err("Max order size must be positive".to_string());
    }
    
    if config.max_order_size > config.max_position as u32 {
        return Err("Max order size cannot exceed max position".to_string());
    }
    
    if config.symbols.is_empty() {
        return Err("At least one symbol required".to_string());
    }
    
    if config.live_enabled {
        println!("WARNING: Live trading enabled - proceed with caution");
    }
    
    Ok(())
}

use nano_gateway::config::{AppConfig, TradingConfig};

// Create custom trading configuration
let trading_config = TradingConfig {
    live_enabled: false,
    symbols: vec![
        "ESH24".to_string(),
        "NQH24".to_string(),
    ],
    initial_capital: 500_000.0,
    max_position: 30,
    max_order_size: 5,
};

// Validate configuration
validate_trading_config(&trading_config)
    .expect("Invalid trading configuration");

// Create full app config
let mut app_config = AppConfig::default();
app_config.trading = trading_config;

// Save to file
app_config.save("my_config.toml")?;

// Use in trading system
println!("Trading configuration:");
println!("  Mode: {}", 
    if app_config.trading.live_enabled { "LIVE" } else { "PAPER" });
println!("  Symbols: {:?}", app_config.trading.symbols);
println!("  Capital: ${:.2}", app_config.trading.initial_capital);
println!("  Max Position: {}", app_config.trading.max_position);
println!("  Max Order Size: {}", app_config.trading.max_order_size);