rusty_ems/exchanges/

binance_rest.rs

use crate::error::EMSError;
use crate::error::batch_errors::{BatchResult, ErrorClassification, OrderResult};
use crate::error::exchange_errors::{extract_rate_limit_info_detailed, parse_binance_error};
use anyhow::{Result, anyhow};
use futures::future;
use log;
use quanta::Clock;
use reqwest::Client;
use rusty_common::SmartString;
use rusty_common::auth::exchanges::binance::BinanceAuth;
use rusty_common::collections::FxHashMap;
use rusty_model::trading_order::Order;
use serde::{Deserialize, Serialize};
use simd_json::prelude::{ValueAsScalar, ValueObjectAccess};
use smallvec::SmallVec;
use std::sync::Arc;

/// Parameters required to place an order on Binance
/// Uses owned strings to avoid lifetime issues with Clone trait
#[derive(Clone)]
pub struct PlaceOrderParams {
    /// Trading symbol (e.g., "BTCUSDT")
    pub symbol: SmartString,
    /// Order side - "BUY" or "SELL"
    pub side: SmartString, // "BUY" or "SELL"
    /// Order type - "LIMIT", "MARKET", etc.
    pub order_type: SmartString, // "LIMIT", "MARKET", etc.
    /// Time in force - "GTC", "IOC", "FOK"
    pub time_in_force: SmartString, // "GTC", "IOC", "FOK"
    /// Order quantity as a string
    pub quantity: SmartString,
    /// Order price as a string
    pub price: SmartString,
    /// Client-generated order ID for tracking
    pub client_order_id: SmartString,
}

/// Parameters for OCO (One-Cancels-Other) orders
pub struct OcoOrderParams<'a> {
    /// Trading symbol (e.g., "BTCUSDT")
    pub symbol: &'a str,
    /// Order side - "BUY" or "SELL"
    pub side: &'a str,
    /// Order quantity as a string
    pub quantity: &'a str,
    /// Order type for above price - "STOP_LOSS_LIMIT", "LIMIT_MAKER", etc.
    pub above_type: &'a str, // "STOP_LOSS_LIMIT", "LIMIT_MAKER", etc.
    /// Order type for below price - "STOP_LOSS", "STOP_LOSS_LIMIT", etc.
    pub below_type: &'a str, // "STOP_LOSS", "STOP_LOSS_LIMIT", etc.
    /// Price for above order
    pub above_price: Option<&'a str>,
    /// Stop price for above order
    pub above_stop_price: Option<&'a str>,
    /// Price for below order
    pub below_price: Option<&'a str>,
    /// Stop price for below order
    pub below_stop_price: Option<&'a str>,
    /// Client-generated list order ID for tracking
    pub list_client_order_id: Option<&'a str>,
}

/// Parameters for SOR (Smart Order Routing) orders
pub struct SorOrderParams<'a> {
    /// Trading symbol (e.g., "BTCUSDT")
    pub symbol: &'a str,
    /// Order side - "BUY" or "SELL"
    pub side: &'a str,
    /// Order type - "LIMIT" or "MARKET"
    pub order_type: &'a str, // "LIMIT" or "MARKET"
    /// Order quantity as a string
    pub quantity: &'a str,
    /// Order price (required for LIMIT orders)
    pub price: Option<&'a str>, // Required for LIMIT orders
    /// Time in force specification
    pub time_in_force: Option<&'a str>,
    /// Client-generated order ID for tracking
    pub client_order_id: Option<&'a str>,
    /// Strategy identifier for SOR routing
    pub strategy_id: Option<i64>,
    /// Strategy type for SOR routing
    pub strategy_type: Option<i32>,
}

/// Parameters for batch order operations
pub struct BatchOrderParams {
    /// Vector of order parameters for batch processing
    pub orders: Vec<PlaceOrderParams>,
}

/// Parameters for native Binance batch order operations (max 5 orders)
#[derive(Debug, Clone, Serialize)]
pub struct NativeBatchOrderParams {
    #[serde(rename = "batchOrders")]
    /// JSON string containing the array of orders for batch processing
    pub batch_orders: String, // JSON string of order array
}

/// Individual order in a native batch request
#[derive(Debug, Clone, Serialize)]
pub struct BinanceNativeOrder {
    /// Trading symbol (e.g., "BTCUSDT")
    pub symbol: String,
    /// Order side - "BUY" or "SELL"
    pub side: String,
    /// Order type - "LIMIT", "MARKET", etc.
    #[serde(rename = "type")]
    pub order_type: String,
    /// Time in force specification - "GTC", "IOC", "FOK"
    #[serde(rename = "timeInForce")]
    pub time_in_force: String,
    /// Order quantity as a string
    pub quantity: String,
    /// Order price (optional for market orders)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub price: Option<String>,
    /// Client-generated order ID for tracking
    #[serde(rename = "newClientOrderId")]
    pub client_order_id: String,
}

/// Result for individual order in batch response
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BatchOrderResult {
    #[serde(flatten)]
    /// Order response data if the order was successful
    pub order: Option<BinanceOrderResponse>,
    /// Error code if the order failed
    pub code: Option<i32>,
    /// Error message if the order failed
    pub msg: Option<SmartString>,
}

/// Response from native batch order API
type BinanceBatchOrderResponse = Vec<BatchOrderResult>;

/// Binance REST client for making authenticated API calls
#[derive(Debug, Clone)]
pub struct BinanceRestClient {
    /// Authentication handler
    auth: Arc<BinanceAuth>,

    /// HTTP client for REST API calls
    client: Client,

    /// Base URL for Binance API
    api_url: SmartString,
}

/// Order response from Binance
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BinanceOrderResponse {
    /// Trading symbol (e.g., "BTCUSDT")
    pub symbol: SmartString,
    #[serde(rename = "orderId")]
    /// Unique order ID assigned by Binance
    pub order_id: u64,
    #[serde(rename = "clientOrderId")]
    /// Client-generated order ID for tracking
    pub client_order_id: SmartString,
    #[serde(rename = "transactTime")]
    /// Transaction timestamp from Binance
    pub transaction_time: u64,
    /// Current order status (NEW, PARTIALLY_FILLED, FILLED, CANCELED, etc.)
    pub status: SmartString,
    #[serde(rename = "executedQty", default)]
    /// Quantity of the order that has been executed
    pub executed_qty: SmartString,
    #[serde(rename = "origQty")]
    /// Original quantity of the order
    pub original_qty: SmartString,
    /// Order price as a string
    pub price: SmartString,
    #[serde(rename = "timeInForce")]
    /// Time in force specification (GTC, IOC, FOK)
    pub time_in_force: SmartString,
    #[serde(rename = "type")]
    /// Order type (LIMIT, MARKET, STOP_LOSS, etc.)
    pub order_type: SmartString,
    /// Order side (BUY or SELL)
    pub side: SmartString,
}

/// Error response from Binance
#[derive(Debug, Serialize, Deserialize)]
pub struct BinanceError {
    /// Binance error code
    pub code: i32,
    /// Error message description
    pub msg: SmartString,
}

/// Symbol information from Binance
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BinanceSymbolInfo {
    /// Trading symbol (e.g., "BTCUSDT")
    pub symbol: SmartString,
    /// Trading status (TRADING, HALT, BREAK, etc.)
    pub status: SmartString,
    #[serde(rename = "baseAsset")]
    /// Base asset symbol (e.g., "BTC")
    pub base_asset: SmartString,
    #[serde(rename = "quoteAsset")]
    /// Quote asset symbol (e.g., "USDT")
    pub quote_asset: SmartString,
}

/// SOR (Smart Order Routing) configuration entry
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BinanceSorConfig {
    #[serde(rename = "baseAsset")]
    /// Base asset for SOR configuration
    pub base_asset: SmartString,
    /// List of symbols available for SOR routing
    pub symbols: Vec<SmartString>,
}

/// Exchange information from Binance
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BinanceExchangeInfo {
    /// Exchange timezone
    pub timezone: SmartString,
    #[serde(rename = "serverTime")]
    /// Current server time in milliseconds
    pub server_time: u64,
    /// List of trading symbols and their information
    pub symbols: Vec<BinanceSymbolInfo>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    /// SOR (Smart Order Routing) configurations if available
    pub sors: Option<Vec<BinanceSorConfig>>,
}

/// OCO Order List response
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BinanceOcoResponse {
    #[serde(rename = "orderListId")]
    /// Unique order list ID assigned by Binance
    pub order_list_id: i64,
    #[serde(rename = "contingencyType")]
    /// Type of contingency order (OCO)
    pub contingency_type: SmartString,
    #[serde(rename = "listStatusType")]
    /// Status type of the order list
    pub list_status_type: SmartString,
    #[serde(rename = "listOrderStatus")]
    /// Current status of the order list
    pub list_order_status: SmartString,
    #[serde(rename = "listClientOrderId")]
    /// Client-generated order list ID for tracking
    pub list_client_order_id: SmartString,
    #[serde(rename = "transactionTime")]
    /// Transaction timestamp from Binance
    pub transaction_time: u64,
    /// Trading symbol for the OCO order
    pub symbol: SmartString,
    /// List of order information in the OCO
    pub orders: Vec<BinanceOrderInfo>,
    #[serde(rename = "orderReports")]
    /// Detailed order reports for each order in the OCO
    pub order_reports: Vec<BinanceOrderResponse>,
}

/// Order information in OCO response
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BinanceOrderInfo {
    /// Trading symbol (e.g., "BTCUSDT")
    pub symbol: SmartString,
    #[serde(rename = "orderId")]
    /// Unique order ID assigned by Binance
    pub order_id: u64,
    #[serde(rename = "clientOrderId")]
    /// Client-generated order ID for tracking
    pub client_order_id: SmartString,
}

/// SOR Order response
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BinanceSorResponse {
    /// Trading symbol (e.g., "BTCUSDT")
    pub symbol: SmartString,
    #[serde(rename = "orderId")]
    /// Unique order ID assigned by Binance
    pub order_id: u64,
    #[serde(rename = "clientOrderId")]
    /// Client-generated order ID for tracking
    pub client_order_id: SmartString,
    #[serde(rename = "transactTime")]
    /// Transaction timestamp from Binance
    pub transaction_time: u64,
    /// Current order status (NEW, PARTIALLY_FILLED, FILLED, etc.)
    pub status: SmartString,
    #[serde(rename = "executedQty")]
    /// Quantity of the order that has been executed
    pub executed_qty: SmartString,
    #[serde(rename = "origQty")]
    /// Original quantity of the order
    pub original_qty: SmartString,
    /// Order price as a string
    pub price: SmartString,
    #[serde(rename = "workingFloor")]
    /// Trading floor where the order is being processed
    pub working_floor: SmartString,
    #[serde(rename = "usedSor")]
    /// Whether Smart Order Routing was used for this order
    pub used_sor: bool,
}

/// Amended order response
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BinanceAmendResponse {
    /// Trading symbol (e.g., "BTCUSDT")
    pub symbol: SmartString,
    #[serde(rename = "orderId")]
    /// Unique order ID assigned by Binance
    pub order_id: u64,
    #[serde(rename = "clientOrderId")]
    /// Client-generated order ID for tracking
    pub client_order_id: SmartString,
    #[serde(rename = "transactTime")]
    /// Transaction timestamp from Binance
    pub transaction_time: u64,
    /// Current order status after amendment
    pub status: SmartString,
    #[serde(rename = "executedQty")]
    /// Quantity of the order that has been executed
    pub executed_qty: SmartString,
    #[serde(rename = "origQty")]
    /// Original quantity of the order after amendment
    pub original_qty: SmartString,
    /// Order price as a string
    pub price: SmartString,
    #[serde(rename = "type")]
    /// Order type (LIMIT, MARKET, etc.)
    pub order_type: SmartString,
    /// Order side (BUY or SELL)
    pub side: SmartString,
}

impl BinanceRestClient {
    /// Create a new Binance REST client with HMAC authentication
    #[must_use]
    pub fn new_hmac(api_key: SmartString, secret_key: SmartString) -> Self {
        Self {
            auth: Arc::new(BinanceAuth::new_hmac(api_key, secret_key)),
            client: Client::new(),
            api_url: "https://api.binance.com".into(),
        }
    }

    /// Create a new Binance REST client with Ed25519 authentication
    pub fn new_ed25519(api_key: SmartString, private_key: SmartString) -> Result<Self> {
        let auth = BinanceAuth::new_ed25519(api_key, private_key)
            .map_err(|e| anyhow!("Failed to create Ed25519 auth: {}", e))?;

        Ok(Self {
            auth: Arc::new(auth),
            client: Client::new(),
            api_url: "https://api.binance.com".into(),
        })
    }

    /// Create a new Binance REST client from existing `BinanceAuth`
    #[must_use]
    pub fn new_with_auth(auth: BinanceAuth) -> Self {
        Self {
            auth: Arc::new(auth),
            client: Client::new(),
            api_url: "https://api.binance.com".into(),
        }
    }

    /// Set a custom API URL (for testing or using testnet)
    #[must_use]
    pub fn with_api_url(mut self, api_url: SmartString) -> Self {
        self.api_url = api_url;
        self
    }

    /// Generate headers for authenticated requests
    fn generate_headers(
        &self,
        method: &str,
        path: &str,
        body: Option<&str>,
    ) -> Result<reqwest::header::HeaderMap> {
        let auth_headers = self
            .auth
            .generate_headers(method, path, None, body)
            .map_err(|e| anyhow!("Auth header generation failed: {}", e))?;

        let mut headers = reqwest::header::HeaderMap::new();

        for (key, value) in auth_headers {
            let header_name = reqwest::header::HeaderName::from_bytes(key.as_bytes())
                .map_err(|e| anyhow!("Invalid header name: {}", e))?;
            let header_value = reqwest::header::HeaderValue::from_str(&value)
                .map_err(|e| anyhow!("Invalid header value: {}", e))?;
            headers.insert(header_name, header_value);
        }

        Ok(headers)
    }

    /// Place a new order on Binance
    pub async fn place_order(&self, params: PlaceOrderParams) -> Result<BinanceOrderResponse> {
        let request_params = [
            ("symbol", params.symbol.as_str()),
            ("side", params.side.as_str()),
            ("type", params.order_type.as_str()),
            ("timeInForce", params.time_in_force.as_str()),
            ("quantity", params.quantity.as_str()),
            ("price", params.price.as_str()),
            ("newClientOrderId", params.client_order_id.as_str()),
        ];

        // Generate signed query string using the improved auth system
        let signed_query = self
            .auth
            .generate_signed_query_string(Some(&request_params))
            .map_err(|e| anyhow!("Auth error: {}", e))?;

        let url = format!("{}/api/v3/order", self.api_url);

        // Generate headers using the improved auth system
        let headers = self.generate_headers("POST", "/api/v3/order", None)?;

        let response = self
            .client
            .post(&url)
            .headers(headers)
            .body(signed_query.to_string())
            .send()
            .await?;

        self.handle_response::<BinanceOrderResponse>(response).await
    }

    /// Cancel an existing order on Binance
    pub async fn cancel_order(
        &self,
        symbol: &str,
        client_order_id: &str,
    ) -> Result<BinanceOrderResponse> {
        let request_params = [("symbol", symbol), ("origClientOrderId", client_order_id)];

        // Generate signed query string using the improved auth system
        let signed_query = self
            .auth
            .generate_signed_query_string(Some(&request_params))
            .map_err(|e| anyhow!("Auth error: {}", e))?;

        let url = format!("{}/api/v3/order", self.api_url);

        // Generate headers using the improved auth system
        let headers = self.generate_headers("DELETE", "/api/v3/order", None)?;

        let response = self
            .client
            .delete(&url)
            .headers(headers)
            .body(signed_query.to_string())
            .send()
            .await?;

        self.handle_response::<BinanceOrderResponse>(response).await
    }

    /// Get order status from Binance
    pub async fn get_order_status(
        &self,
        symbol: &str,
        client_order_id: &str,
    ) -> Result<BinanceOrderResponse> {
        let request_params = [("symbol", symbol), ("origClientOrderId", client_order_id)];

        // Generate signed query string using the improved auth system
        let signed_query = self
            .auth
            .generate_signed_query_string(Some(&request_params))
            .map_err(|e| anyhow!("Auth error: {}", e))?;

        let url = format!("{}/api/v3/order?{}", self.api_url, signed_query);

        // Generate headers using the improved auth system
        let headers = self.generate_headers("GET", "/api/v3/order", None)?;

        let response = self.client.get(&url).headers(headers).send().await?;

        self.handle_response::<BinanceOrderResponse>(response).await
    }

    /// Cancel all open orders for a specific symbol
    pub async fn cancel_all_orders(&self, symbol: &str) -> Result<Vec<BinanceOrderResponse>> {
        let request_params = [("symbol", symbol)];

        // Generate signed query string using the improved auth system
        let signed_query = self
            .auth
            .generate_signed_query_string(Some(&request_params))
            .map_err(|e| anyhow!("Auth error: {}", e))?;

        let url = format!("{}/api/v3/openOrders", self.api_url);

        // Generate headers using the improved auth system
        let headers = self.generate_headers("DELETE", "/api/v3/openOrders", None)?;

        let response = self
            .client
            .delete(&url)
            .headers(headers)
            .body(signed_query.to_string())
            .send()
            .await?;

        self.handle_response::<Vec<BinanceOrderResponse>>(response)
            .await
    }

    /// Get exchange information (public endpoint, no authentication required)
    pub async fn get_exchange_info(&self) -> Result<BinanceExchangeInfo> {
        let url = format!("{}/api/v3/exchangeInfo", self.api_url);
        let response = self.client.get(&url).send().await?;

        self.handle_response::<BinanceExchangeInfo>(response).await
    }

    /// Create a new listen key for user data stream
    pub async fn create_listen_key(&self) -> Result<String> {
        let url = format!("{}/api/v3/userDataStream", self.api_url);

        // Generate headers using the improved auth system
        let headers = self.generate_headers("POST", "/api/v3/userDataStream", None)?;

        let response = self.client.post(&url).headers(headers).send().await?;

        let response_body: simd_json::OwnedValue = self.handle_response(response).await?;
        let listen_key = response_body
            .get("listenKey")
            .and_then(|v| v.as_str())
            .ok_or_else(|| anyhow!("Invalid listen key response"))?
            .to_string();

        Ok(listen_key)
    }

    /// Refresh existing listen key to keep it active
    pub async fn refresh_listen_key(&self, listen_key: &str) -> Result<()> {
        let url = format!("{}/api/v3/userDataStream", self.api_url);

        // Generate headers using the improved auth system
        let headers = self.generate_headers("PUT", "/api/v3/userDataStream", None)?;

        let response = self
            .client
            .put(&url)
            .headers(headers)
            .query(&[("listenKey", listen_key)])
            .send()
            .await?;

        self.handle_response::<()>(response).await?;
        Ok(())
    }

    /// Delete a listen key
    pub async fn delete_listen_key(&self, listen_key: &str) -> Result<()> {
        let url = format!("{}/api/v3/userDataStream", self.api_url);

        // Generate headers using the improved auth system
        let headers = self.generate_headers("DELETE", "/api/v3/userDataStream", None)?;

        let response = self
            .client
            .delete(&url)
            .headers(headers)
            .query(&[("listenKey", listen_key)])
            .send()
            .await?;

        self.handle_response::<()>(response).await?;
        Ok(())
    }

    /// Place an OCO (One-Cancels-Other) order
    pub async fn place_oco_order(&self, params: OcoOrderParams<'_>) -> Result<BinanceOcoResponse> {
        let mut request_params = vec![
            ("symbol", params.symbol),
            ("side", params.side),
            ("quantity", params.quantity),
            ("aboveType", params.above_type),
            ("belowType", params.below_type),
        ];

        if let Some(above_price) = params.above_price {
            request_params.push(("abovePrice", above_price));
        }
        if let Some(above_stop_price) = params.above_stop_price {
            request_params.push(("aboveStopPrice", above_stop_price));
        }
        if let Some(below_price) = params.below_price {
            request_params.push(("belowPrice", below_price));
        }
        if let Some(below_stop_price) = params.below_stop_price {
            request_params.push(("belowStopPrice", below_stop_price));
        }
        if let Some(list_client_order_id) = params.list_client_order_id {
            request_params.push(("listClientOrderId", list_client_order_id));
        }

        let signed_query = self
            .auth
            .generate_signed_query_string(Some(&request_params))
            .map_err(|e| anyhow!("Auth error: {}", e))?;

        let url = format!("{}/api/v3/orderList/oco", self.api_url);
        let headers = self.generate_headers("POST", "/api/v3/orderList/oco", None)?;

        let response = self
            .client
            .post(&url)
            .headers(headers)
            .body(signed_query.to_string())
            .send()
            .await?;

        self.handle_response::<BinanceOcoResponse>(response).await
    }

    /// Place a SOR (Smart Order Routing) order
    pub async fn place_sor_order(&self, params: SorOrderParams<'_>) -> Result<BinanceSorResponse> {
        let mut request_params = vec![
            ("symbol", params.symbol),
            ("side", params.side),
            ("type", params.order_type),
            ("quantity", params.quantity),
        ];

        if let Some(price) = params.price {
            request_params.push(("price", price));
        }
        if let Some(time_in_force) = params.time_in_force {
            request_params.push(("timeInForce", time_in_force));
        }
        if let Some(client_order_id) = params.client_order_id {
            request_params.push(("newClientOrderId", client_order_id));
        }
        let strategy_id_str;
        if let Some(strategy_id) = params.strategy_id {
            strategy_id_str = strategy_id.to_string();
            request_params.push(("strategyId", &strategy_id_str));
        }
        let strategy_type_str;
        if let Some(strategy_type) = params.strategy_type {
            strategy_type_str = strategy_type.to_string();
            request_params.push(("strategyType", &strategy_type_str));
        }

        let signed_query = self
            .auth
            .generate_signed_query_string(Some(&request_params))
            .map_err(|e| anyhow!("Auth error: {}", e))?;

        let url = format!("{}/api/v3/sor/order", self.api_url);
        let headers = self.generate_headers("POST", "/api/v3/sor/order", None)?;

        let response = self
            .client
            .post(&url)
            .headers(headers)
            .body(signed_query.to_string())
            .send()
            .await?;

        self.handle_response::<BinanceSorResponse>(response).await
    }

    /// Place multiple orders using native Binance batch API (max 5 orders)
    pub async fn place_native_batch_orders(
        &self,
        orders: Vec<BinanceNativeOrder>,
    ) -> Result<BinanceBatchOrderResponse> {
        if orders.is_empty() {
            return Ok(Vec::new());
        }

        if orders.len() > 5 {
            return Err(anyhow!(
                "Native batch orders limited to 5 orders, got {}",
                orders.len()
            ));
        }

        // Convert orders to JSON string
        let batch_orders_json = simd_json::to_string(&orders)
            .map_err(|e| anyhow!("Failed to serialize batch orders: {}", e))?;

        let request_params = [("batchOrders", batch_orders_json.as_str())];

        // Generate signed query string
        let signed_query = self
            .auth
            .generate_signed_query_string(Some(&request_params))
            .map_err(|e| anyhow!("Auth error: {}", e))?;

        let url = format!("{}/fapi/v1/batchOrders", self.api_url);
        let headers = self.generate_headers("POST", "/fapi/v1/batchOrders", None)?;

        let response = self
            .client
            .post(&url)
            .headers(headers)
            .body(signed_query.to_string())
            .send()
            .await?;

        self.handle_response::<BinanceBatchOrderResponse>(response)
            .await
    }

    /// Place multiple orders in a batch (uses native API for ≤5 orders, concurrent for larger batches)
    pub async fn place_batch_orders(
        &self,
        params: BatchOrderParams,
    ) -> Result<Vec<Result<BinanceOrderResponse>>> {
        if params.orders.is_empty() {
            return Ok(Vec::new());
        }

        // Try native batch API for small batches (≤5 orders)
        if params.orders.len() <= 5 {
            // Convert to native batch format
            let native_orders: Vec<BinanceNativeOrder> = params
                .orders
                .iter()
                .map(|order| BinanceNativeOrder {
                    symbol: order.symbol.to_string(),
                    side: order.side.to_string(),
                    order_type: order.order_type.to_string(),
                    time_in_force: order.time_in_force.to_string(),
                    quantity: order.quantity.to_string(),
                    price: if order.price != "0" && !order.price.is_empty() {
                        Some(order.price.to_string())
                    } else {
                        None
                    },
                    client_order_id: order.client_order_id.to_string(),
                })
                .collect();

            // Try native batch API first
            match self.place_native_batch_orders(native_orders).await {
                Ok(batch_response) => {
                    // Convert batch response to expected format
                    let results: Vec<Result<BinanceOrderResponse>> = batch_response
                        .into_iter()
                        .map(|result| {
                            if let Some(order) = result.order {
                                Ok(order)
                            } else {
                                let error_msg = result.msg.unwrap_or_else(|| {
                                    format!("Batch order failed with code: {:?}", result.code)
                                        .into()
                                });
                                Err(anyhow!("Batch order error: {}", error_msg))
                            }
                        })
                        .collect();
                    return Ok(results);
                }
                Err(e) => {
                    // Only fallback for specific errors, not transport/auth issues
                    // Check if this is a transport-level error that would affect all requests
                    let is_transport_error = if let Some(ems_error) = e.downcast_ref::<EMSError>() {
                        use crate::error::batch_errors::ErrorClassification;
                        ems_error.is_transport_error()
                    } else if let Some(req_err) = e.downcast_ref::<reqwest::Error>() {
                        // Check reqwest errors directly
                        req_err.is_timeout()
                            || req_err.is_connect()
                            || req_err.status().is_some_and(|s| s.as_u16() == 429) // Rate limit
                    } else {
                        // For other errors, check the error string for transport-related patterns
                        let error_str = e.to_string().to_lowercase();
                        error_str.contains("connection")
                            || error_str.contains("timeout")
                            || error_str.contains("network")
                            || error_str.contains("refused")
                            || error_str.contains("unreachable")
                    };

                    if is_transport_error {
                        // Propagate transport errors - fallback won't help
                        log::error!("Native batch API failed with transport error: {e}");
                        return Err(e);
                    }

                    // Fall back to concurrent execution for API-specific errors
                    // (e.g., batch endpoint not available, malformed batch request)
                    log::warn!(
                        "Native batch API failed with non-transport error, falling back to concurrent execution: {e}"
                    );
                }
            }
        }

        // Fall back to concurrent execution for large batches or if native API fails
        let order_futures: Vec<_> = params
            .orders
            .into_iter()
            .map(|order_params| {
                let self_ref = self;
                async move { self_ref.place_order(order_params).await }
            })
            .collect();

        // Execute all orders concurrently
        let results = future::join_all(order_futures).await;
        Ok(results)
    }

    /// Place multiple orders with improved error handling that separates transport from per-order errors
    pub async fn place_batch_orders_improved(
        &self,
        orders: SmallVec<[Order; 8]>,
    ) -> Result<BatchResult<BinanceOrderResponse>> {
        let clock = Clock::new();
        let start_time = clock.raw();

        if orders.is_empty() {
            return Ok(BatchResult::success(
                FxHashMap::default(),
                clock.raw() - start_time,
            ));
        }

        // Convert orders to Binance format with owned strings to avoid lifetime issues
        let order_params: Vec<(String, String, String, String, String, String, String)> = orders
            .iter()
            .map(|order| {
                let symbol = order.symbol.to_string();
                let side = match order.side {
                    rusty_model::enums::OrderSide::Buy => "BUY".to_string(),
                    rusty_model::enums::OrderSide::Sell => "SELL".to_string(),
                };
                let order_type = match order.order_type {
                    rusty_model::enums::OrderType::Market => "MARKET".to_string(),
                    rusty_model::enums::OrderType::Limit => "LIMIT".to_string(),
                    _ => "LIMIT".to_string(), // Default to limit
                };
                let time_in_force = "GTC".to_string(); // Good Till Cancelled
                let quantity = order.quantity.to_string();
                let price = order
                    .price
                    .map_or_else(|| "0".to_string(), |p| p.to_string());
                let client_order_id = order.id.into_uuid().to_string();
                (
                    symbol,
                    side,
                    order_type,
                    time_in_force,
                    quantity,
                    price,
                    client_order_id,
                )
            })
            .collect();

        // Convert to PlaceOrderParams with owned strings
        let order_params_refs: Vec<PlaceOrderParams> = order_params
            .iter()
            .map(
                |(symbol, side, order_type, time_in_force, quantity, price, client_order_id)| {
                    PlaceOrderParams {
                        symbol: symbol.clone().into(),
                        side: side.clone().into(),
                        order_type: order_type.clone().into(),
                        time_in_force: time_in_force.clone().into(),
                        quantity: quantity.clone().into(),
                        price: price.clone().into(),
                        client_order_id: client_order_id.clone().into(),
                    }
                },
            )
            .collect();

        // Try the existing batch order method
        match self
            .place_batch_orders(BatchOrderParams {
                orders: order_params_refs,
            })
            .await
        {
            Ok(results) => {
                // Process results and classify errors
                let mut order_results = FxHashMap::default();
                let mut has_transport_error = false;
                let mut transport_error = None;

                for (i, result) in results.into_iter().enumerate() {
                    let order_id = orders[i].id.into_uuid().to_string().into();

                    match result {
                        Ok(response) => {
                            order_results.insert(order_id, OrderResult::success(response));
                        }
                        Err(e) => {
                            // Convert anyhow error to EMSError
                            let ems_error = EMSError::from(e);

                            // Check if this is a transport error that affects all orders
                            if ems_error.is_transport_error() && !has_transport_error {
                                has_transport_error = true;
                                transport_error = Some(ems_error.clone());
                            }

                            order_results.insert(
                                order_id,
                                OrderResult::failed(ems_error, orders[i].clone()),
                            );
                        }
                    }
                }

                let processing_time = clock.raw() - start_time;

                // If we detected a transport error, treat the entire batch as a transport failure
                if has_transport_error {
                    return Ok(BatchResult::transport_failure(
                        transport_error.unwrap(),
                        orders.len(),
                        processing_time,
                    ));
                }

                // Determine batch status based on results
                let successful_count = order_results
                    .values()
                    .filter(|result| result.is_success())
                    .count();

                if successful_count == orders.len() {
                    Ok(BatchResult::success(order_results, processing_time))
                } else if successful_count > 0 {
                    Ok(BatchResult::partial_success(order_results, processing_time))
                } else {
                    Ok(BatchResult::all_failed(order_results, processing_time))
                }
            }
            Err(e) => {
                // The entire batch failed at the transport level
                let ems_error = EMSError::from(e);
                let processing_time = clock.raw() - start_time;

                if ems_error.is_transport_error() {
                    Ok(BatchResult::transport_failure(
                        ems_error,
                        orders.len(),
                        processing_time,
                    ))
                } else {
                    // Unexpected error type, treat as transport failure
                    Ok(BatchResult::transport_failure(
                        EMSError::internal(format!("Unexpected batch error: {ems_error}")),
                        orders.len(),
                        processing_time,
                    ))
                }
            }
        }
    }

    /// Cancel an order list (OCO, OTO, etc.)
    pub async fn cancel_order_list(
        &self,
        symbol: &str,
        order_list_id: i64,
    ) -> Result<BinanceOcoResponse> {
        let request_params = [
            ("symbol", symbol),
            ("orderListId", &order_list_id.to_string()),
        ];

        let signed_query = self
            .auth
            .generate_signed_query_string(Some(&request_params))
            .map_err(|e| anyhow!("Auth error: {}", e))?;

        let url = format!("{}/api/v3/orderList", self.api_url);
        let headers = self.generate_headers("DELETE", "/api/v3/orderList", None)?;

        let response = self
            .client
            .delete(&url)
            .headers(headers)
            .body(signed_query.to_string())
            .send()
            .await?;

        self.handle_response::<BinanceOcoResponse>(response).await
    }

    /// Amend an order keeping queue priority (reduce quantity only)
    pub async fn amend_order_keep_priority(
        &self,
        symbol: &str,
        client_order_id: &str,
        new_quantity: rust_decimal::Decimal,
    ) -> Result<BinanceAmendResponse> {
        let request_params = [
            ("symbol", symbol),
            ("origClientOrderId", client_order_id),
            ("newQty", &new_quantity.to_string()),
        ];

        let signed_query = self
            .auth
            .generate_signed_query_string(Some(&request_params))
            .map_err(|e| anyhow!("Auth error: {}", e))?;

        let url = format!("{}/api/v3/order/amend/keepPriority", self.api_url);
        let headers = self.generate_headers("PUT", "/api/v3/order/amend/keepPriority", None)?;

        let response = self
            .client
            .put(&url)
            .headers(headers)
            .body(signed_query.to_string())
            .send()
            .await?;

        self.handle_response::<BinanceAmendResponse>(response).await
    }

    /// Test SOR order placement (validation only)
    pub async fn test_sor_order(&self, params: SorOrderParams<'_>) -> Result<()> {
        let mut request_params = vec![
            ("symbol", params.symbol),
            ("side", params.side),
            ("type", params.order_type),
            ("quantity", params.quantity),
        ];

        if let Some(price) = params.price {
            request_params.push(("price", price));
        }
        if let Some(time_in_force) = params.time_in_force {
            request_params.push(("timeInForce", time_in_force));
        }
        if let Some(client_order_id) = params.client_order_id {
            request_params.push(("newClientOrderId", client_order_id));
        }

        let signed_query = self
            .auth
            .generate_signed_query_string(Some(&request_params))
            .map_err(|e| anyhow!("Auth error: {}", e))?;

        let url = format!("{}/api/v3/sor/order/test", self.api_url);
        let headers = self.generate_headers("POST", "/api/v3/sor/order/test", None)?;

        let response = self
            .client
            .post(&url)
            .headers(headers)
            .body(signed_query.to_string())
            .send()
            .await?;

        self.handle_response::<()>(response).await?;
        Ok(())
    }

    /// Generate WebSocket authentication message
    /// This exposes the unified auth system's WebSocket functionality
    pub fn generate_ws_auth(&self) -> Result<SmartString> {
        self.auth
            .generate_ws_auth()
            .map_err(|e| anyhow!("WebSocket auth error: {}", e))
    }

    /// Get SOR configuration from exchange info
    pub async fn get_sor_config(&self) -> Result<Vec<BinanceSorConfig>> {
        let exchange_info = self.get_exchange_info().await?;
        Ok(exchange_info.sors.unwrap_or_default())
    }

    /// Get allocations for SOR trades
    pub async fn get_my_allocations(&self, symbol: &str) -> Result<simd_json::OwnedValue> {
        let request_params = [("symbol", symbol)];

        let signed_query = self
            .auth
            .generate_signed_query_string(Some(&request_params))
            .map_err(|e| anyhow!("Auth error: {}", e))?;

        let url = format!("{}/api/v3/myAllocations?{}", self.api_url, signed_query);
        let headers = self.generate_headers("GET", "/api/v3/myAllocations", None)?;

        let response = self.client.get(&url).headers(headers).send().await?;
        self.handle_response::<simd_json::OwnedValue>(response)
            .await
    }

    /// Centralized response handling with improved error parsing
    async fn handle_response<T>(&self, response: reqwest::Response) -> Result<T>
    where
        T: serde::de::DeserializeOwned + 'static,
    {
        let status = response.status();

        // Parse and log rate limit information for all responses
        let rate_limit_info = extract_rate_limit_info_detailed(response.headers());
        let summary = rate_limit_info.summary();
        if summary != "no_rate_limit_info" {
            log::trace!("[Binance] Rate limits: {summary}");

            // Warn if approaching rate limits
            if rate_limit_info.is_approaching_limit() {
                log::warn!("[Binance] Rate limit approaching: {summary}");
            }
        }

        if status.is_success() {
            // Special handling for unit type endpoints that don't return data
            if std::any::TypeId::of::<T>() == std::any::TypeId::of::<()>() {
                // Safety: We've confirmed T is (), so this transmute is safe
                return Ok(unsafe { std::mem::transmute_copy(&()) });
            }

            let response_bytes = response.bytes().await?;
            let mut response_vec = response_bytes.to_vec();
            // SAFETY: response_vec is valid UTF-8 bytes from HTTP response
            let response_body: T = simd_json::from_slice(&mut response_vec)
                .map_err(|e| anyhow!("Failed to parse response: {}", e))?;
            return Ok(response_body);
        }

        // Handle error responses
        let error_bytes = response.bytes().await?;
        let mut error_vec = error_bytes.to_vec();

        // Handle rate limit exceeded with detailed information
        if status == reqwest::StatusCode::TOO_MANY_REQUESTS {
            let retry_info = if let Some(retry_ms) = rate_limit_info.get_retry_after_ms() {
                format!(" (retry after {retry_ms}ms)")
            } else {
                String::new()
            };

            log::warn!("[Binance] Rate limit exceeded{retry_info}. Details: {summary}");
        }

        // Try to parse using centralized Binance error parser
        let error_result = if let Ok(json_value) =
            simd_json::from_slice::<simd_json::value::owned::Value>(&mut error_vec)
        {
            if let Some(ems_error) = parse_binance_error(&json_value, "Binance") {
                return Err(anyhow!(ems_error));
            }
            // If centralized parser doesn't handle it, try old format
            if let Ok(error) = simd_json::from_slice::<BinanceError>(&mut error_vec) {
                format!("Binance error: {} (code: {})", error.msg, error.code)
            } else {
                let error_text = String::from_utf8_lossy(&error_bytes);
                format!("HTTP {status} error: {error_text}")
            }
        } else {
            // Fallback to raw string representation for non-JSON errors
            let error_text = String::from_utf8_lossy(&error_bytes);
            format!("HTTP {status} error: {error_text}")
        };

        let error_message = error_result;

        Err(anyhow!(error_message))
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use base64::{Engine as _, engine::general_purpose::STANDARD as BASE64};
    use dotenv::dotenv;
    use std::env;

    #[tokio::test]
    async fn test_get_exchange_info() {
        dotenv().ok();

        let api_key = env::var("BINANCE_API_KEY").unwrap_or_default();
        let secret_key = env::var("BINANCE_SECRET_KEY").unwrap_or_default();

        if api_key.is_empty() || secret_key.is_empty() {
            println!("Skipping test: BINANCE_API_KEY and BINANCE_SECRET_KEY must be set");
            return;
        }

        let client = BinanceRestClient::new_hmac(api_key.into(), secret_key.into());

        let result = client.get_exchange_info().await;
        assert!(result.is_ok(), "Failed to get exchange info: {result:?}");

        let exchange_info = result.unwrap();
        assert!(!exchange_info.symbols.is_empty(), "No symbols returned");

        println!("Found {} symbols", exchange_info.symbols.len());
        for (i, symbol_info) in exchange_info.symbols.iter().take(5).enumerate() {
            println!(
                "  {}: {} ({}/{})",
                i + 1,
                symbol_info.symbol,
                symbol_info.base_asset,
                symbol_info.quote_asset
            );
        }
    }

    #[tokio::test]
    async fn test_ed25519_authentication() {
        // Test creating client with Ed25519 authentication
        let api_key: SmartString = "test_api_key".into();
        let private_key = BASE64.encode([1u8; 32]); // Test key

        let client = BinanceRestClient::new_ed25519(api_key, private_key.into());
        assert!(client.is_ok(), "Failed to create Ed25519 client");

        let client = client.unwrap();

        // Test WebSocket auth generation (only works with Ed25519)
        let ws_auth = client.generate_ws_auth();
        assert!(
            ws_auth.is_ok(),
            "Failed to generate WebSocket auth with Ed25519"
        );

        let auth_message = ws_auth.unwrap();
        assert!(auth_message.contains("session.logon"));
        assert!(auth_message.contains("test_api_key"));
    }

    #[test]
    fn test_header_generation() {
        let client = BinanceRestClient::new_hmac("test_api_key".into(), "test_secret".into());

        // Test GET headers
        let headers = client.generate_headers("GET", "/api/v3/account", None);
        assert!(headers.is_ok());
        let headers = headers.unwrap();
        assert!(headers.contains_key("x-mbx-apikey"));

        // Test POST headers
        let headers = client.generate_headers("POST", "/api/v3/order", Some("test body"));
        assert!(headers.is_ok());
        let headers = headers.unwrap();
        assert!(headers.contains_key("x-mbx-apikey"));
        assert!(headers.contains_key("content-type"));
    }
}