Rust Documentation

use binary_options_tools_v2::{PocketOption, StreamEvent};
use tokio::time::{Duration, timeout};
use futures::StreamExt;

#[tokio::main]
async fn main() -> Result<(), Box> {
    let client = PocketOption::new("your_ssid_here").await?;

    // Concurrent operations
    let (balance, candles, history) = tokio::try_join!(
        client.get_balance(),
        client.get_candles("EURUSD_otc", 60, 100),
        client.get_history(50)
    )?;

    println!("Balance: ${}", balance);
    println!("Candles count: {}", candles.len());
    println!("History count: {}", history.len());

    // Stream real-time candles with timeout
    let mut stream = client.stream_candles("EURUSD_otc", 60).await?;
    
    while let Ok(Some(event)) = timeout(Duration::from_secs(30), stream.next()).await {
        match event? {
            StreamEvent::Candle(candle) => {
                println!("New candle: {} -> {}", candle.open, candle.close);
                
                // Implement your trading logic here
                if should_place_order(&candle) {
                    let order = client.create_raw_order(OrderOptions {
                        asset: "EURUSD_otc".to_string(),
                        amount: 10.0,
                        action: determine_action(&candle),
                        expiration: 60,
                    }).await?;
                    
                    println!("Placed order: {}", order.order_id);
                }
            }
            StreamEvent::Error(e) => {
                eprintln!("Stream error: {}", e);
                break;
            }
        }
    }

    Ok(())
}

fn should_place_order(candle: &CandleData) -> bool {
    // Your trading logic here
    candle.close > candle.open
}

fn determine_action(candle: &CandleData) -> String {
    if candle.close > candle.open {
        "call".to_string()
    } else {
        "put".to_string()
    }
}

use binary_options_tools_v2::{PocketOption, TradingBot, Strategy};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

#[derive(Debug, Serialize, Deserialize)]
struct TradingConfig {
    ssid: String,
    assets: Vec,
    max_concurrent_orders: usize,
    risk_percentage: f64,
}

struct AdvancedTradingBot {
    client: PocketOption,
    config: TradingConfig,
    active_orders: HashMap,
}

impl AdvancedTradingBot {
    async fn new(config: TradingConfig) -> Result> {
        let client = PocketOption::new(&config.ssid).await?;
        
        Ok(Self {
            client,
            config,
            active_orders: HashMap::new(),
        })
    }

    async fn run(&mut self) -> Result<(), Box> {
        // Initialize multiple asset streams
        let mut streams = Vec::new();
        
        for asset in &self.config.assets {
            let stream = self.client.stream_candles(asset, 60).await?;
            streams.push(stream);
        }

        // Process streams concurrently
        let mut combined_stream = futures::stream::select_all(streams);

        while let Some(event) = combined_stream.next().await {
            match event? {
                StreamEvent::Candle(candle) => {
                    self.process_candle(candle).await?;
                }
                StreamEvent::OrderUpdate(update) => {
                    self.handle_order_update(update).await?;
                }
                _ => {}
            }
        }

        Ok(())
    }

    async fn process_candle(&mut self, candle: CandleData) -> Result<(), Box> {
        // Check if we can place more orders
        if self.active_orders.len() >= self.config.max_concurrent_orders {
            return Ok(());
        }

        // Analyze candle with multiple strategies
        let strategies = vec![
            MACDStrategy::new(),
            RSIStrategy::new(),
            BollingerBandsStrategy::new(),
        ];

        let mut signals = Vec::new();
        for strategy in strategies {
            if let Some(signal) = strategy.analyze(&candle) {
                signals.push(signal);
            }
        }

        // Consensus-based trading
        if signals.len() >= 2 {
            let action = determine_consensus_action(&signals);
            let amount = self.calculate_position_size().await?;
            
            let order = self.client.create_raw_order(OrderOptions {
                asset: candle.asset.clone(),
                amount,
                action,
                expiration: 60,
            }).await?;

            self.active_orders.insert(order.order_id.clone(), OrderInfo {
                id: order.order_id,
                asset: candle.asset,
                amount,
                timestamp: std::time::SystemTime::now(),
            });
        }

        Ok(())
    }

    async fn calculate_position_size(&self) -> Result> {
        let balance = self.client.get_balance().await?;
        let risk_amount = balance * self.config.risk_percentage / 100.0;
        Ok(risk_amount.min(100.0).max(1.0)) // Min $1, Max $100
    }

    async fn handle_order_update(&mut self, update: OrderUpdate) -> Result<(), Box> {
        if let Some(order_info) = self.active_orders.remove(&update.order_id) {
            match update.status {
                OrderStatus::Win => {
                    println!("✅ Order {} won! Profit: ${}", order_info.id, update.profit);
                }
                OrderStatus::Lose => {
                    println!("❌ Order {} lost. Loss: ${}", order_info.id, order_info.amount);
                }
                _ => {}
            }
        }
        Ok(())
    }
}

#[tokio::main]
async fn main() -> Result<(), Box> {
    let config = TradingConfig {
        ssid: "your_ssid_here".to_string(),
        assets: vec![
            "EURUSD_otc".to_string(),
            "GBPUSD_otc".to_string(),
            "USDJPY_otc".to_string(),
        ],
        max_concurrent_orders: 3,
        risk_percentage: 2.0,
    };

    let mut bot = AdvancedTradingBot::new(config).await?;
    bot.run().await?;

    Ok(())
}