rusty_ems/exchanges/

upbit.rs

use std::sync::Arc;
use std::time::Duration;

use anyhow::{Result, anyhow};
use async_trait::async_trait;
// No longer needed - using rusty_common::time utilities
use flume::Sender;
use parking_lot::RwLock;
use quanta::Clock;
use reqwest::Client;
use rust_decimal::Decimal;
use rusty_common::SmartString;
use rusty_common::auth::exchanges::upbit::{UpbitAuth, UpbitAuthConfig};
use rusty_common::utils::id_generation;
use rusty_common::websocket::connector::{WebSocketSink, WebSocketStream};
use rusty_model::{
    enums::{OrderSide, OrderStatus, OrderType},
    instruments::InstrumentId,
    trading_order::Order,
    venues::Venue,
};
use serde::{Deserialize, Serialize};
use simd_json::json;
use smallvec::SmallVec;
use tokio::sync::RwLock as AsyncRwLock;

use crate::execution_engine::{Exchange, ExecutionReport};

// Upbit API URLs from rusty_model::exchanges::upbit
const API_URL: &str = "https://api.upbit.com";
const WS_URL: &str = "wss://api.upbit.com/websocket/v1";
const WS_PRIVATE_URL: &str = "wss://api.upbit.com/websocket/v1/private";

/// Response structure for Upbit order operations
///
/// This struct represents the response from Upbit's order API endpoints
/// (place order, cancel order, get order status) containing comprehensive
/// order information including execution details, fees, and timestamps.
#[derive(Debug, Serialize, Deserialize)]
struct UpbitOrderResponse {
    /// Unique order identifier (UUID format)
    uuid: String,
    /// Order side: "bid" for buy orders, "ask" for sell orders
    side: String,
    /// Order type: "limit", "price", "market", "best"
    ord_type: String,
    /// Order price (None for market orders)
    price: Option<String>,
    /// Order state: "wait", "watch", "done", "cancel"
    state: String,
    /// Market symbol (e.g., "KRW-BTC")
    market: String,
    /// Order creation timestamp in ISO 8601 format
    created_at: String,
    /// Total order volume
    volume: String,
    /// Remaining volume to be filled
    remaining_volume: String,
    /// Reserved fee amount
    reserved_fee: String,
    /// Remaining fee amount
    remaining_fee: String,
    /// Paid fee amount
    paid_fee: String,
    /// Locked amount for the order
    locked: String,
    /// Executed volume
    executed_volume: String,
    /// Number of trades executed for this order
    trades_count: u64,
    /// Time in force constraint: "ioc", "fok", or None
    time_in_force: Option<String>,
    /// Client-provided identifier for the order
    identifier: Option<String>,
}

/// Error response structure from Upbit API
///
/// This struct represents the error response format returned by Upbit's API
/// when an operation fails, containing detailed error information.
#[derive(Debug, Serialize, Deserialize)]
struct UpbitErrorResponse {
    /// Error details
    error: UpbitError,
}

/// Detailed error information from Upbit API
///
/// Contains the specific error name and human-readable message
/// for debugging and error handling purposes.
#[derive(Debug, Serialize, Deserialize)]
struct UpbitError {
    /// Error name/code identifying the type of error
    name: String,
    /// Human-readable error message describing the issue
    message: String,
}

/// Upbit exchange client for order execution and account management
///
/// This client implements the Exchange trait for Upbit, providing:
/// - Order placement, cancellation, and modification
/// - Account balance queries
/// - Order status tracking
/// - WebSocket connection management for real-time updates
/// - Authentication using JWT tokens
///
/// The client uses asynchronous operations for all API calls and supports
/// both REST API and WebSocket connections for comprehensive trading functionality.
#[derive(Clone)]
pub struct UpbitExchange {
    /// Authentication handler from rusty-feeder
    auth: Arc<UpbitAuth>,

    /// HTTP client for REST API requests
    client: Arc<Client>,

    /// WebSocket connection for user data stream
    ws_sink: Arc<AsyncRwLock<Option<WebSocketSink>>>,
    ws_stream: Arc<AsyncRwLock<Option<WebSocketStream>>>,

    /// Connection status
    connected: Arc<RwLock<bool>>,

    /// High-precision clock
    clock: Clock,

    /// Cache of instruments
    instruments_cache: Arc<RwLock<SmallVec<[InstrumentId; 32]>>>,
}

impl UpbitExchange {
    /// Create a new Upbit exchange instance
    #[must_use]
    pub fn new(api_key: String, secret_key: String) -> Self {
        let client = Client::builder()
            .timeout(Duration::from_secs(10))
            .build()
            .expect("Failed to build HTTP client");

        let auth_config = UpbitAuthConfig::new(api_key.into(), secret_key.into());
        let auth = Arc::new(UpbitAuth::new(auth_config));

        Self {
            auth,
            client: Arc::new(client),
            ws_sink: Arc::new(AsyncRwLock::new(None)),
            ws_stream: Arc::new(AsyncRwLock::new(None)),
            connected: Arc::new(RwLock::new(false)),
            clock: Clock::new(),
            instruments_cache: Arc::new(RwLock::new(SmallVec::new())),
        }
    }

    /// Map Upbit order status to internal `OrderStatus`
    fn map_order_status(status: &str) -> OrderStatus {
        match status {
            "wait" => OrderStatus::New,
            "watch" => OrderStatus::New,
            "done" => OrderStatus::Filled,
            "cancel" => OrderStatus::Cancelled,
            _ => OrderStatus::Rejected, // Default to rejected for unknown status
        }
    }

    /// Map internal `OrderType` to Upbit order type
    const fn map_order_type(order_type: OrderType) -> &'static str {
        match order_type {
            OrderType::Market => "price", // For buy orders, "price" means market order with total price
            OrderType::Limit => "limit",
            OrderType::PostOnly => "best", // Best limit order
            _ => "limit",                  // Default to limit for unsupported types
        }
    }

    /// Map internal `OrderType` to Upbit time in force
    const fn map_time_in_force(order_type: OrderType) -> Option<&'static str> {
        match order_type {
            OrderType::ImmediateOrCancel => Some("ioc"),
            OrderType::FillOrKill => Some("fok"),
            _ => None,
        }
    }

    /// Map internal `OrderSide` to Upbit order side
    const fn map_order_side(side: OrderSide) -> &'static str {
        match side {
            OrderSide::Buy => "bid",
            OrderSide::Sell => "ask",
        }
    }

    /// Parse Upbit timestamp to nanoseconds since epoch
    ///
    /// # Arguments
    ///
    /// * `timestamp_str` - RFC3339 timestamp string
    ///
    /// # Returns
    ///
    /// Returns nanoseconds since Unix epoch as u64. Only accepts timestamps
    /// after Unix epoch (1970-01-01T00:00:00Z) to ensure valid u64 values.
    fn parse_timestamp(timestamp_str: &str) -> Result<u64> {
        // Use rusty_common time utilities instead of chrono
        rusty_common::time::parse_rfc3339_timestamp(timestamp_str).map_err(|e| {
            anyhow!(
                "Failed to parse RFC3339 timestamp '{}': {}",
                timestamp_str,
                e
            )
        })
    }
}

#[async_trait]
impl Exchange for UpbitExchange {
    fn venue(&self) -> Venue {
        Venue::Upbit
    }

    async fn place_order(&self, order: Order, report_tx: Sender<ExecutionReport>) -> Result<()> {
        if !*self.connected.read() {
            return Err(anyhow!("Not connected to Upbit"));
        }

        let market = order.symbol.clone();
        let side = Self::map_order_side(order.side);
        let ord_type = Self::map_order_type(order.order_type);

        // Construct the request body
        let mut body = json!({
            "market": market,
            "side": side,
            "ord_type": ord_type,
        });

        // Add price and volume based on order type
        if ord_type == "limit" {
            body["price"] = json!(
                order
                    .price
                    .map_or_else(|| "0".to_string(), |p| p.to_string())
            );
            body["volume"] = json!(order.quantity.to_string());
        } else if ord_type == "price" {
            // For market buy, we specify the total price
            body["price"] = json!(
                order
                    .price
                    .map_or_else(|| "0".to_string(), |p| p.to_string())
            );
        } else if ord_type == "market" {
            // For market sell, we specify the volume
            body["volume"] = json!(order.quantity.to_string());
        } else if ord_type == "best" {
            // Best order type requires time_in_force
            if let Some(tif) = Self::map_time_in_force(order.order_type) {
                body["time_in_force"] = json!(tif);

                // For best orders, add price/volume based on side
                if side == "bid" {
                    // Buy: price required, volume optional
                    body["price"] = json!(
                        order
                            .price
                            .map_or_else(|| "0".to_string(), |p| p.to_string())
                    );
                } else {
                    // Sell: volume required, price optional
                    body["volume"] = json!(order.quantity.to_string());
                }
            } else {
                return Err(anyhow!("Best order type requires IOC or FOK order type"));
            }
        }

        // Add time_in_force for limit orders if specified
        if ord_type == "limit"
            && let Some(tif) = Self::map_time_in_force(order.order_type)
        {
            body["time_in_force"] = json!(tif);
        }

        // Add identifier if provided (using client_id)
        if !order.client_id.as_str().is_empty() {
            body["identifier"] = json!(order.client_id.as_str());
        }

        // Generate JWT token for POST request
        let body_str = simd_json::to_string(&body)?;
        let token = self.auth.generate_rest_jwt_post(&body_str)?;

        // Send the request
        let url = format!("{API_URL}/v1/orders");
        let response = self
            .client
            .post(&url)
            .header("Authorization", format!("Bearer {token}"))
            .header("Content-Type", "application/json")
            .json(&body)
            .send()
            .await?;

        if response.status().is_success() {
            let order_response: UpbitOrderResponse = response.json().await?;

            // Send acknowledgment report
            let report = ExecutionReport {
                id: id_generation::generate_ack_id(&order.id.to_string()),
                order_id: order.id.to_string().into(),
                exchange_timestamp: Self::parse_timestamp(&order_response.created_at)
                    .unwrap_or_else(|e| {
                        log::warn!("Failed to parse Upbit timestamp: {e}");
                        rusty_common::time::get_timestamp_ns_result()
                            .unwrap_or_else(|_| self.clock.raw())
                    }),
                system_timestamp: rusty_common::time::get_epoch_timestamp_ns(),
                instrument_id: InstrumentId::new(order.symbol.clone(), order.venue),
                status: Self::map_order_status(&order_response.state),
                filled_quantity: Decimal::from_str_exact(&order_response.executed_volume)
                    .unwrap_or(Decimal::ZERO),
                remaining_quantity: Decimal::from_str_exact(&order_response.remaining_volume)
                    .unwrap_or(Decimal::ZERO),
                execution_price: order_response
                    .price
                    .and_then(|p| Decimal::from_str_exact(&p).ok()),
                reject_reason: None,
                exchange_execution_id: Some(order_response.uuid.into()),
                is_final: false,
            };

            report_tx.send_async(report).await?;
        } else {
            let error_response: UpbitErrorResponse = response.json().await?;
            let error_msg = format!(
                "{}: {}",
                error_response.error.name, error_response.error.message
            );

            // Send rejection report
            let report = ExecutionReport {
                id: id_generation::generate_rejection_id(&order.id.to_string()),
                order_id: order.id.to_string().into(),
                exchange_timestamp: rusty_common::time::get_timestamp_ns_result()
                    .unwrap_or_else(|_| self.clock.raw()),
                system_timestamp: rusty_common::time::get_epoch_timestamp_ns(),
                instrument_id: InstrumentId::new(order.symbol.clone(), order.venue),
                status: OrderStatus::Rejected,
                filled_quantity: Decimal::ZERO,
                remaining_quantity: order.quantity,
                execution_price: None,
                reject_reason: Some(error_msg.clone().into()),
                exchange_execution_id: None,
                is_final: true,
            };

            report_tx.send_async(report).await?;
            return Err(anyhow!("Order placement failed: {}", error_msg));
        }

        Ok(())
    }

    async fn cancel_order(
        &self,
        order_id: SmartString,
        report_tx: Sender<ExecutionReport>,
    ) -> Result<()> {
        if !*self.connected.read() {
            return Err(anyhow!("Not connected to Upbit"));
        }

        // Construct query parameters
        let query_params = Some(("uuid", order_id.as_str()));
        let query_string = format!("uuid={order_id}");

        // Generate JWT token with query hash
        let token = self
            .auth
            .generate_rest_jwt_get(query_params.as_ref().map(std::slice::from_ref))?;

        // Send the request
        let url = format!("{API_URL}/v1/order?{query_string}");
        let response = self
            .client
            .delete(&url)
            .header("Authorization", format!("Bearer {token}"))
            .send()
            .await?;

        if response.status().is_success() {
            let order_response: UpbitOrderResponse = response.json().await?;

            // Create instrument ID
            let instrument = InstrumentId {
                symbol: order_response.market.into(),
                venue: Venue::Upbit,
            };

            // Send cancellation report
            let report = ExecutionReport {
                id: id_generation::generate_cancel_id(&order_id),
                order_id: order_id.clone(),
                exchange_timestamp: Self::parse_timestamp(&order_response.created_at)
                    .unwrap_or_else(|e| {
                        log::warn!("Failed to parse Upbit timestamp: {e}");
                        rusty_common::time::get_timestamp_ns_result()
                            .unwrap_or_else(|_| self.clock.raw())
                    }),
                system_timestamp: rusty_common::time::get_epoch_timestamp_ns(),
                instrument_id: instrument,
                status: OrderStatus::Cancelled,
                filled_quantity: Decimal::from_str_exact(&order_response.executed_volume)
                    .unwrap_or(Decimal::ZERO),
                remaining_quantity: Decimal::from_str_exact(&order_response.remaining_volume)
                    .unwrap_or(Decimal::ZERO),
                execution_price: order_response
                    .price
                    .and_then(|p| Decimal::from_str_exact(&p).ok()),
                reject_reason: None,
                exchange_execution_id: Some(order_response.uuid.into()),
                is_final: true,
            };

            report_tx.send_async(report).await?;
        } else {
            let error_response: UpbitErrorResponse = response.json().await?;
            let error_msg = format!(
                "{}: {}",
                error_response.error.name, error_response.error.message
            );
            return Err(anyhow!("Order cancellation failed: {}", error_msg));
        }

        Ok(())
    }

    async fn modify_order(
        &self,
        _order_id: SmartString,
        _new_price: Option<Decimal>,
        _new_quantity: Option<Decimal>,
        _report_tx: Sender<ExecutionReport>,
    ) -> Result<()> {
        // Upbit doesn't support direct order modification
        // We need to cancel the existing order and place a new one

        // For now, we'll just return an error
        Err(anyhow!(
            "Order modification not supported for Upbit. Cancel and place a new order instead."
        ))
    }

    async fn cancel_all_orders(
        &self,
        _instrument_id: Option<InstrumentId>,
        __report_tx: Sender<ExecutionReport>,
    ) -> Result<()> {
        // Upbit doesn't have a direct API for canceling all orders
        // We would need to get all open orders and cancel them one by one

        // For now, we'll just return an error
        Err(anyhow!("Cancel all orders not implemented for Upbit"))
    }

    async fn get_order_status(&self, order_id: &str) -> Result<OrderStatus> {
        if !*self.connected.read() {
            return Err(anyhow!("Not connected to Upbit"));
        }

        // Construct query parameters
        let query_params = Some(("uuid", order_id));
        let query_string = format!("uuid={order_id}");

        // Generate JWT token with query hash
        let token = self
            .auth
            .generate_rest_jwt_get(query_params.as_ref().map(std::slice::from_ref))?;

        // Send the request
        let url = format!("{API_URL}/v1/order?{query_string}");
        let response = self
            .client
            .get(&url)
            .header("Authorization", format!("Bearer {token}"))
            .send()
            .await?;

        if response.status().is_success() {
            let order_response: UpbitOrderResponse = response.json().await?;
            return Ok(Self::map_order_status(&order_response.state));
        } else {
            let error_response: UpbitErrorResponse = response.json().await?;
            let error_msg = format!(
                "{}: {}",
                error_response.error.name, error_response.error.message
            );
            return Err(anyhow!("Failed to get order status: {}", error_msg));
        }
    }

    async fn connect(&self, _report_sender: Sender<ExecutionReport>) -> Result<()> {
        // For Upbit, we'll just set the connected flag to true
        // In a real implementation, we might want to test the connection by making a simple API call
        *self.connected.write() = true;
        Ok(())
    }

    async fn disconnect(&self) -> Result<()> {
        // For Upbit, we'll just set the connected flag to false
        *self.connected.write() = false;
        Ok(())
    }

    async fn is_connected(&self) -> bool {
        *self.connected.read()
    }

    async fn get_instruments(&self) -> Result<SmallVec<[InstrumentId; 32]>> {
        // Check if we have cached instruments
        {
            let cache = self.instruments_cache.read();
            if !cache.is_empty() {
                return Ok(cache.clone());
            }
        }

        // Fetch the list of markets from Upbit
        let url = format!("{API_URL}/v1/market/all");
        let response = self.client.get(&url).send().await?;

        if response.status().is_success() {
            #[derive(Debug, Deserialize)]
            struct Market {
                market: String,
                korean_name: String,
                english_name: String,
            }

            let markets: Vec<Market> = response.json().await?;
            let mut instruments = SmallVec::new();

            for market in markets {
                let instrument_id = InstrumentId {
                    symbol: market.market.into(),
                    venue: Venue::Upbit,
                };
                instruments.push(instrument_id);
            }

            // Cache the instruments
            *self.instruments_cache.write() = instruments.clone();

            return Ok(instruments);
        }
        return Err(anyhow!("Failed to get instruments from Upbit"));
    }

    async fn send_fix_message(&self, _message: Vec<u8>) -> Result<()> {
        // Upbit doesn't support FIX protocol
        anyhow::bail!("FIX protocol not supported on Upbit")
    }

    async fn receive_fix_message(&self) -> Result<Vec<u8>> {
        // Upbit doesn't support FIX protocol
        anyhow::bail!("FIX protocol not supported on Upbit")
    }
}

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

    #[test]
    fn test_map_time_in_force_ioc() {
        let result = UpbitExchange::map_time_in_force(OrderType::ImmediateOrCancel);
        assert_eq!(result, Some("ioc"));
    }

    #[test]
    fn test_map_time_in_force_fok() {
        let result = UpbitExchange::map_time_in_force(OrderType::FillOrKill);
        assert_eq!(result, Some("fok"));
    }

    #[test]
    fn test_map_time_in_force_market() {
        let result = UpbitExchange::map_time_in_force(OrderType::Market);
        assert_eq!(result, None);
    }

    #[test]
    fn test_map_time_in_force_limit() {
        let result = UpbitExchange::map_time_in_force(OrderType::Limit);
        assert_eq!(result, None);
    }

    #[test]
    fn test_map_time_in_force_stop() {
        let result = UpbitExchange::map_time_in_force(OrderType::Stop);
        assert_eq!(result, None);
    }

    #[test]
    fn test_map_time_in_force_stop_limit() {
        let result = UpbitExchange::map_time_in_force(OrderType::StopLimit);
        assert_eq!(result, None);
    }

    #[test]
    fn test_map_time_in_force_post_only() {
        let result = UpbitExchange::map_time_in_force(OrderType::PostOnly);
        assert_eq!(result, None);
    }

    #[test]
    fn test_parse_timestamp_valid_rfc3339() {
        let timestamp = "2023-12-25T12:30:45.123456789Z";
        let result = UpbitExchange::parse_timestamp(timestamp);
        assert!(result.is_ok());
        let nanos = result.unwrap();
        assert!(nanos > 0);
    }

    #[test]
    fn test_parse_timestamp_valid_with_timezone() {
        let timestamp = "2023-12-25T12:30:45.123456789+09:00";
        let result = UpbitExchange::parse_timestamp(timestamp);
        assert!(result.is_ok());
        let nanos = result.unwrap();
        assert!(nanos > 0);
    }

    #[test]
    fn test_parse_timestamp_valid_with_negative_timezone() {
        let timestamp = "2023-12-25T12:30:45.123456789-05:00";
        let result = UpbitExchange::parse_timestamp(timestamp);
        assert!(result.is_ok());
        let nanos = result.unwrap();
        assert!(nanos > 0);
    }

    #[test]
    fn test_parse_timestamp_valid_without_nanos() {
        let timestamp = "2023-12-25T12:30:45Z";
        let result = UpbitExchange::parse_timestamp(timestamp);
        assert!(result.is_ok());
        let nanos = result.unwrap();
        assert!(nanos > 0);
    }

    #[test]
    fn test_parse_timestamp_valid_microseconds() {
        let timestamp = "2023-12-25T12:30:45.123456Z";
        let result = UpbitExchange::parse_timestamp(timestamp);
        assert!(result.is_ok());
        let nanos = result.unwrap();
        assert!(nanos > 0);
    }

    #[test]
    fn test_parse_timestamp_valid_milliseconds() {
        let timestamp = "2023-12-25T12:30:45.123Z";
        let result = UpbitExchange::parse_timestamp(timestamp);
        assert!(result.is_ok());
        let nanos = result.unwrap();
        assert!(nanos > 0);
    }

    #[test]
    fn test_parse_timestamp_year_boundary() {
        let timestamp = "2023-12-31T23:59:59.999999999Z";
        let result = UpbitExchange::parse_timestamp(timestamp);
        assert!(result.is_ok());
        let nanos = result.unwrap();
        assert!(nanos > 0);
    }

    #[test]
    fn test_parse_timestamp_leap_year() {
        let timestamp = "2024-02-29T12:30:45.123456789Z";
        let result = UpbitExchange::parse_timestamp(timestamp);
        assert!(result.is_ok());
        let nanos = result.unwrap();
        assert!(nanos > 0);
    }

    #[test]
    fn test_parse_timestamp_invalid_format() {
        let timestamp = "2023-12-25 12:30:45";
        let result = UpbitExchange::parse_timestamp(timestamp);
        assert!(result.is_err());
        assert!(
            result
                .unwrap_err()
                .to_string()
                .contains("Failed to parse RFC3339 timestamp")
        );
    }

    #[test]
    fn test_parse_timestamp_invalid_date() {
        let timestamp = "2023-02-30T12:30:45.123456789Z";
        let result = UpbitExchange::parse_timestamp(timestamp);
        assert!(result.is_err());
        assert!(
            result
                .unwrap_err()
                .to_string()
                .contains("Failed to parse RFC3339 timestamp")
        );
    }

    #[test]
    fn test_parse_timestamp_invalid_time() {
        let timestamp = "2023-12-25T25:30:45.123456789Z";
        let result = UpbitExchange::parse_timestamp(timestamp);
        assert!(result.is_err());
        assert!(
            result
                .unwrap_err()
                .to_string()
                .contains("Failed to parse RFC3339 timestamp")
        );
    }

    #[test]
    fn test_parse_timestamp_empty_string() {
        let timestamp = "";
        let result = UpbitExchange::parse_timestamp(timestamp);
        assert!(result.is_err());
        assert!(
            result
                .unwrap_err()
                .to_string()
                .contains("Failed to parse RFC3339 timestamp")
        );
    }

    #[test]
    fn test_parse_timestamp_malformed_timezone() {
        let timestamp = "2023-12-25T12:30:45.123456789+25:00";
        let result = UpbitExchange::parse_timestamp(timestamp);
        assert!(result.is_err());
        assert!(
            result
                .unwrap_err()
                .to_string()
                .contains("Failed to parse RFC3339 timestamp")
        );
    }

    #[test]
    fn test_parse_timestamp_missing_timezone() {
        let timestamp = "2023-12-25T12:30:45.123456789";
        let result = UpbitExchange::parse_timestamp(timestamp);
        assert!(result.is_err());
        assert!(
            result
                .unwrap_err()
                .to_string()
                .contains("Failed to parse RFC3339 timestamp")
        );
    }

    #[test]
    fn test_parse_timestamp_with_whitespace() {
        let timestamp = " 2023-12-25T12:30:45.123456789Z ";
        let result = UpbitExchange::parse_timestamp(timestamp);
        assert!(result.is_err());
        assert!(
            result
                .unwrap_err()
                .to_string()
                .contains("Failed to parse RFC3339 timestamp")
        );
    }

    #[test]
    fn test_parse_timestamp_precision_edge_cases() {
        // Test maximum nanosecond precision
        let timestamp = "2023-12-25T12:30:45.999999999Z";
        let result = UpbitExchange::parse_timestamp(timestamp);
        assert!(result.is_ok());
        let nanos = result.unwrap();
        assert!(nanos > 0);
    }

    #[test]
    fn test_parse_timestamp_error_message_format() {
        let invalid_timestamp = "invalid_timestamp";
        let result = UpbitExchange::parse_timestamp(invalid_timestamp);
        assert!(result.is_err());
        let error_msg = result.unwrap_err().to_string();
        assert!(error_msg.contains("Failed to parse RFC3339 timestamp"));
        assert!(error_msg.contains("invalid_timestamp"));
    }

    #[test]
    fn test_parse_timestamp_out_of_range() {
        // Test with a timestamp that would be out of range for i64 nanoseconds
        // This is a theoretical case as RFC3339 dates don't typically go this far
        let timestamp = "9999-12-31T23:59:59.999999999Z";
        let result = UpbitExchange::parse_timestamp(timestamp);
        // Should either succeed or fail with appropriate error
        // The exact behavior depends on chrono's implementation
        if let Err(error) = result {
            let error_msg = error.to_string();
            assert!(
                error_msg.contains("Failed to parse RFC3339 timestamp")
                    || error_msg.contains("out of range")
                    || error_msg.contains("overflow")
            );
        }
    }

    #[test]
    fn test_parse_timestamp_return_type() {
        let timestamp = "2023-12-25T12:30:45.123456789Z";
        let result = UpbitExchange::parse_timestamp(timestamp);
        assert!(result.is_ok());
        let nanos = result.unwrap();
        // Verify the result is a valid u64 nanosecond timestamp
        assert!(nanos > 1_000_000_000_000_000_000); // Should be > year 2001 in nanoseconds
    }

    #[tokio::test]
    async fn test_send_fix_message_not_supported() {
        let exchange =
            UpbitExchange::new("test_api_key".to_string(), "test_secret_key".to_string());

        let message = vec![b'T', b'E', b'S', b'T'];
        let result = exchange.send_fix_message(message).await;

        assert!(result.is_err());
        let err = result.unwrap_err();
        assert!(
            err.to_string()
                .contains("FIX protocol not supported on Upbit")
        );
    }

    #[tokio::test]
    async fn test_receive_fix_message_not_supported() {
        let exchange =
            UpbitExchange::new("test_api_key".to_string(), "test_secret_key".to_string());

        let result = exchange.receive_fix_message().await;

        assert!(result.is_err());
        let err = result.unwrap_err();
        assert!(
            err.to_string()
                .contains("FIX protocol not supported on Upbit")
        );
    }
}