rusty_backtest/adapters/

krx_a3b6g7.rs

//! KRX A3B6G7 Data Adapter for Korean Exchange Data
//!
//! Handles the complex KRX A3B6G7 format with 160+ fields including
//! Korean market-specific metadata and multi-language support.

use crate::features::{Level, OrderBookSnapshot, TradeSide, TradeTick};
use rust_decimal::Decimal;
use rusty_common::collections::FxHashMap;
use smallvec::SmallVec;
use std::io::{BufRead, BufReader, Read};

/// KRX A3B6G7 field metadata
#[derive(Debug, Clone)]
pub struct FieldMetadata {
    /// Field index (0-based)
    pub index: usize,
    /// Korean field name
    pub name_kr: String,
    /// English field name
    pub name_en: String,
    /// Field data type
    pub data_type: FieldType,
    /// Field description
    pub description: String,
}

/// Field data types in A3B6G7
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum FieldType {
    /// Integer field
    Integer,
    /// Decimal/Price field
    Decimal,
    /// String field
    String,
    /// Timestamp field (YYYYMMDDHHMMSSNNNNNN format)
    Timestamp,
    /// Boolean/Flag field
    Boolean,
}

/// KRX A3B6G7 event - contains all 160+ fields
#[derive(Debug, Clone)]
pub struct KrxA3B6G7Event {
    /// Raw field values indexed by position
    pub fields: Vec<String>,
    /// Parsed timestamp in nanoseconds
    pub timestamp_ns: u64,
    /// Symbol code
    pub symbol: String,
    /// Event type
    pub event_type: KrxEventType,
}

/// KRX event types
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum KrxEventType {
    /// L2 orderbook update
    OrderBook,
    /// Trade execution
    Trade,
    /// Market statistics
    MarketStats,
    /// Auction data
    Auction,
    /// Circuit breaker event
    CircuitBreaker,
}

/// KRX A3B6G7 adapter with field mapping
pub struct KrxA3B6G7Adapter {
    /// Field metadata mapping
    field_map: FxHashMap<String, FieldMetadata>,
    /// Symbol mapping (KRX code to internal format)
    symbol_map: FxHashMap<String, String>,
    /// Critical field indices for fast access
    critical_indices: CriticalFieldIndices,
}

/// Pre-computed indices for critical fields
#[derive(Debug, Clone)]
struct CriticalFieldIndices {
    timestamp: usize,
    symbol: usize,
    event_type: usize,
    // Order book fields
    bid_prices: Vec<usize>,
    bid_quantities: Vec<usize>,
    bid_counts: Vec<usize>,
    ask_prices: Vec<usize>,
    ask_quantities: Vec<usize>,
    ask_counts: Vec<usize>,
    // Trade fields
    trade_price: usize,
    trade_quantity: usize,
    trade_side: usize,
    // Market stats
    open_price: usize,
    high_price: usize,
    low_price: usize,
    close_price: usize,
    volume: usize,
}

impl Default for CriticalFieldIndices {
    fn default() -> Self {
        // Standard A3B6G7 field positions
        Self {
            timestamp: 0,
            symbol: 1,
            event_type: 2,
            // 10 levels of order book (indices 10-69)
            bid_prices: (10..30).step_by(2).collect(),
            bid_quantities: (11..30).step_by(2).collect(),
            bid_counts: (70..80).collect(),
            ask_prices: (30..50).step_by(2).collect(),
            ask_quantities: (31..50).step_by(2).collect(),
            ask_counts: (80..90).collect(),
            // Trade fields
            trade_price: 50,
            trade_quantity: 51,
            trade_side: 52,
            // Market stats
            open_price: 90,
            high_price: 91,
            low_price: 92,
            close_price: 93,
            volume: 94,
        }
    }
}

impl Default for KrxA3B6G7Adapter {
    fn default() -> Self {
        Self::new()
    }
}

impl KrxA3B6G7Adapter {
    /// Create a new adapter with default field mappings
    #[must_use]
    pub fn new() -> Self {
        let mut adapter = Self {
            field_map: FxHashMap::default(),
            symbol_map: FxHashMap::default(),
            critical_indices: CriticalFieldIndices::default(),
        };

        // Initialize standard field mappings
        adapter.init_standard_fields();

        // Common symbol mappings
        adapter
            .symbol_map
            .insert("005930".to_string(), "SAMSUNG-KRW".to_string());
        adapter
            .symbol_map
            .insert("000660".to_string(), "SK-HYNIX-KRW".to_string());
        adapter
            .symbol_map
            .insert("035420".to_string(), "NAVER-KRW".to_string());

        adapter
    }

    /// Initialize standard A3B6G7 field mappings
    fn init_standard_fields(&mut self) {
        // Timestamp field
        self.add_field(FieldMetadata {
            index: 0,
            name_kr: "시간".to_string(),
            name_en: "timestamp".to_string(),
            data_type: FieldType::Timestamp,
            description: "Event timestamp in YYYYMMDDHHMMSSNNNNNN format".to_string(),
        });

        // Symbol field
        self.add_field(FieldMetadata {
            index: 1,
            name_kr: "종목코드".to_string(),
            name_en: "symbol_code".to_string(),
            data_type: FieldType::String,
            description: "6-digit KRX symbol code".to_string(),
        });

        // Event type field
        self.add_field(FieldMetadata {
            index: 2,
            name_kr: "이벤트구분".to_string(),
            name_en: "event_type".to_string(),
            data_type: FieldType::String,
            description: "Event type code".to_string(),
        });

        // Add order book fields (10 levels)
        for i in 0..10 {
            let base_idx = 10 + i * 2;

            // Bid price
            self.add_field(FieldMetadata {
                index: base_idx,
                name_kr: format!("매수호가{}", i + 1),
                name_en: format!("bid_price_{}", i + 1),
                data_type: FieldType::Decimal,
                description: format!("Bid price level {}", i + 1),
            });

            // Bid quantity
            self.add_field(FieldMetadata {
                index: base_idx + 1,
                name_kr: format!("매수잔량{}", i + 1),
                name_en: format!("bid_quantity_{}", i + 1),
                data_type: FieldType::Decimal,
                description: format!("Bid quantity level {}", i + 1),
            });
        }

        // Add more fields as needed...
    }

    /// Add a field metadata entry
    pub fn add_field(&mut self, metadata: FieldMetadata) {
        self.field_map
            .insert(metadata.name_en.clone(), metadata.clone());
        self.field_map.insert(metadata.name_kr.clone(), metadata);
    }

    /// Parse A3B6G7 line into event
    pub fn parse_line(&self, line: &str) -> Result<KrxA3B6G7Event, ParseError> {
        let fields: Vec<String> = line.split('|').map(|s| s.trim().to_string()).collect();

        if fields.len() < 95 {
            return Err(ParseError::InsufficientFields(fields.len()));
        }

        // Parse timestamp (YYYYMMDDHHMMSSNNNNNN to nanoseconds)
        let timestamp_str = &fields[self.critical_indices.timestamp];
        let timestamp_ns = self.parse_krx_timestamp(timestamp_str)?;

        // Parse symbol
        let symbol = fields[self.critical_indices.symbol].clone();
        let symbol = self.symbol_map.get(&symbol).cloned().unwrap_or(symbol);

        // Parse event type
        let event_type = match fields[self.critical_indices.event_type].as_str() {
            "B1" | "S1" => KrxEventType::OrderBook,
            "T1" => KrxEventType::Trade,
            "M1" => KrxEventType::MarketStats,
            "A1" => KrxEventType::Auction,
            "C1" => KrxEventType::CircuitBreaker,
            _ => {
                return Err(ParseError::InvalidEventType(
                    fields[self.critical_indices.event_type].clone(),
                ));
            }
        };

        Ok(KrxA3B6G7Event {
            fields,
            timestamp_ns,
            symbol,
            event_type,
        })
    }

    /// Parse KRX timestamp format to nanoseconds
    fn parse_krx_timestamp(&self, timestamp: &str) -> Result<u64, ParseError> {
        if timestamp.len() != 20 {
            return Err(ParseError::InvalidTimestamp(timestamp.to_string()));
        }

        // Parse components
        let year = timestamp[0..4]
            .parse::<u64>()
            .map_err(|_| ParseError::InvalidTimestamp(timestamp.to_string()))?;
        let month = timestamp[4..6]
            .parse::<u64>()
            .map_err(|_| ParseError::InvalidTimestamp(timestamp.to_string()))?;
        let day = timestamp[6..8]
            .parse::<u64>()
            .map_err(|_| ParseError::InvalidTimestamp(timestamp.to_string()))?;
        let hour = timestamp[8..10]
            .parse::<u64>()
            .map_err(|_| ParseError::InvalidTimestamp(timestamp.to_string()))?;
        let minute = timestamp[10..12]
            .parse::<u64>()
            .map_err(|_| ParseError::InvalidTimestamp(timestamp.to_string()))?;
        let second = timestamp[12..14]
            .parse::<u64>()
            .map_err(|_| ParseError::InvalidTimestamp(timestamp.to_string()))?;
        let microsecond = timestamp[14..20]
            .parse::<u64>()
            .map_err(|_| ParseError::InvalidTimestamp(timestamp.to_string()))?;

        // Convert to Unix timestamp (simplified - doesn't handle leap years perfectly)
        let days_since_epoch = (year - 1970) * 365 + (month - 1) * 30 + (day - 1);
        let seconds_since_epoch = days_since_epoch * 86400 + hour * 3600 + minute * 60 + second;
        let nanoseconds = seconds_since_epoch * 1_000_000_000 + microsecond * 1000;

        Ok(nanoseconds)
    }
}

impl KrxA3B6G7Event {
    /// Convert to OrderBookSnapshot if this is an orderbook event
    pub fn to_orderbook_snapshot(&self, adapter: &KrxA3B6G7Adapter) -> Option<OrderBookSnapshot> {
        if self.event_type != KrxEventType::OrderBook {
            return None;
        }

        let indices = &adapter.critical_indices;
        let mut bids = SmallVec::with_capacity(10);
        let mut asks = SmallVec::with_capacity(10);

        // Parse bid levels
        for i in 0..10 {
            let price = self
                .fields
                .get(indices.bid_prices[i])
                .and_then(|s| s.parse::<Decimal>().ok());
            let quantity = self
                .fields
                .get(indices.bid_quantities[i])
                .and_then(|s| s.parse::<Decimal>().ok());
            let order_count = self
                .fields
                .get(indices.bid_counts.get(i).copied().unwrap_or(0))
                .and_then(|s| s.parse::<u32>().ok())
                .unwrap_or(0);

            if let (Some(price), Some(quantity)) = (price, quantity)
                && price > Decimal::ZERO
                && quantity > Decimal::ZERO
            {
                bids.push(Level {
                    price,
                    quantity,
                    order_count,
                });
            }
        }

        // Parse ask levels
        for i in 0..10 {
            let price = self
                .fields
                .get(indices.ask_prices[i])
                .and_then(|s| s.parse::<Decimal>().ok());
            let quantity = self
                .fields
                .get(indices.ask_quantities[i])
                .and_then(|s| s.parse::<Decimal>().ok());
            let order_count = self
                .fields
                .get(indices.ask_counts.get(i).copied().unwrap_or(0))
                .and_then(|s| s.parse::<u32>().ok())
                .unwrap_or(0);

            if let (Some(price), Some(quantity)) = (price, quantity)
                && price > Decimal::ZERO
                && quantity > Decimal::ZERO
            {
                asks.push(Level {
                    price,
                    quantity,
                    order_count,
                });
            }
        }

        Some(OrderBookSnapshot {
            timestamp_ns: self.timestamp_ns,
            symbol: self.symbol.clone(),
            bids,
            asks,
        })
    }

    /// Convert to TradeTick if this is a trade event
    pub fn to_trade_tick(&self, adapter: &KrxA3B6G7Adapter) -> Option<TradeTick> {
        if self.event_type != KrxEventType::Trade {
            return None;
        }

        let indices = &adapter.critical_indices;

        let price = self
            .fields
            .get(indices.trade_price)
            .and_then(|s| s.parse::<Decimal>().ok())?;
        let quantity = self
            .fields
            .get(indices.trade_quantity)
            .and_then(|s| s.parse::<Decimal>().ok())?;
        let side_str = self.fields.get(indices.trade_side)?;

        let side = match side_str.as_str() {
            "B" | "매수" => TradeSide::Buy,
            "S" | "매도" => TradeSide::Sell,
            _ => return None,
        };

        Some(TradeTick {
            timestamp_ns: self.timestamp_ns,
            symbol: self.symbol.clone(),
            side,
            price,
            quantity,
        })
    }

    /// Get a specific field value by name (Korean or English)
    pub fn get_field(&self, field_name: &str, adapter: &KrxA3B6G7Adapter) -> Option<&str> {
        let metadata = adapter.field_map.get(field_name)?;
        self.fields.get(metadata.index).map(|s| s.as_str())
    }

    /// Get market statistics if available
    pub fn get_market_stats(&self, adapter: &KrxA3B6G7Adapter) -> Option<MarketStats> {
        if self.event_type != KrxEventType::MarketStats {
            return None;
        }

        let indices = &adapter.critical_indices;

        Some(MarketStats {
            open: self
                .fields
                .get(indices.open_price)
                .and_then(|s| s.parse::<Decimal>().ok())?,
            high: self
                .fields
                .get(indices.high_price)
                .and_then(|s| s.parse::<Decimal>().ok())?,
            low: self
                .fields
                .get(indices.low_price)
                .and_then(|s| s.parse::<Decimal>().ok())?,
            close: self
                .fields
                .get(indices.close_price)
                .and_then(|s| s.parse::<Decimal>().ok())?,
            volume: self
                .fields
                .get(indices.volume)
                .and_then(|s| s.parse::<Decimal>().ok())?,
        })
    }
}

/// Market statistics data.
#[derive(Debug, Clone)]
pub struct MarketStats {
    /// The opening price.
    pub open: Decimal,
    /// The highest price.
    pub high: Decimal,
    /// The lowest price.
    pub low: Decimal,
    /// The closing price.
    pub close: Decimal,
    /// The trading volume.
    pub volume: Decimal,
}

/// Error types for parsing KRX A3B6G7 data.
#[derive(Debug, Clone)]
pub enum ParseError {
    /// The input has an insufficient number of fields.
    InsufficientFields(usize),
    /// The timestamp in the input is invalid.
    InvalidTimestamp(String),
    /// The event type in the input is invalid.
    InvalidEventType(String),
    /// A field in the input is invalid.
    InvalidField(String),
    /// An I/O error occurred.
    IoError(String),
}

impl std::fmt::Display for ParseError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            ParseError::InsufficientFields(count) => {
                write!(f, "Insufficient fields: expected at least 95, got {count}")
            }
            ParseError::InvalidTimestamp(ts) => write!(f, "Invalid timestamp: {ts}"),
            ParseError::InvalidEventType(et) => write!(f, "Invalid event type: {et}"),
            ParseError::InvalidField(field) => write!(f, "Invalid field: {field}"),
            ParseError::IoError(e) => write!(f, "IO error: {e}"),
        }
    }
}

impl std::error::Error for ParseError {}

/// Iterator for streaming KRX A3B6G7 data
pub struct KrxA3B6G7Iterator<R: Read> {
    reader: BufReader<R>,
    adapter: KrxA3B6G7Adapter,
}

impl<R: Read> KrxA3B6G7Iterator<R> {
    /// Create a new iterator
    #[must_use]
    pub fn new(reader: R) -> Self {
        Self {
            reader: BufReader::new(reader),
            adapter: KrxA3B6G7Adapter::new(),
        }
    }

    /// Set custom field mapping
    #[must_use]
    pub fn with_field_mapping(mut self, metadata: FieldMetadata) -> Self {
        self.adapter.add_field(metadata);
        self
    }

    /// Set custom symbol mapping
    #[must_use]
    pub fn with_symbol_mapping(mut self, krx_code: String, internal_symbol: String) -> Self {
        self.adapter.symbol_map.insert(krx_code, internal_symbol);
        self
    }
}

impl<R: Read> Iterator for KrxA3B6G7Iterator<R> {
    type Item = Result<KrxA3B6G7Event, ParseError>;

    fn next(&mut self) -> Option<Self::Item> {
        let mut line = String::new();
        match self.reader.read_line(&mut line) {
            Ok(0) => None, // EOF
            Ok(_) => {
                let line = line.trim();
                if line.is_empty() || line.starts_with('#') {
                    return self.next(); // Skip empty lines and comments
                }
                Some(self.adapter.parse_line(line))
            }
            Err(e) => Some(Err(ParseError::IoError(e.to_string()))),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use rust_decimal_macros::dec;

    #[test]
    fn test_krx_timestamp_parsing() {
        let adapter = KrxA3B6G7Adapter::new();

        // Test timestamp: 2023-12-25 09:30:00.123456
        let timestamp = "20231225093000123456";
        let result = adapter.parse_krx_timestamp(timestamp);

        assert!(result.is_ok());
        // The actual value would need proper date calculation
        // This is a simplified test
    }

    #[test]
    fn test_orderbook_parsing() {
        let adapter = KrxA3B6G7Adapter::new();

        // Create a sample A3B6G7 line with orderbook data
        let mut fields = vec![""; 160];
        fields[0] = "20231225093000123456"; // timestamp
        fields[1] = "005930"; // Samsung Electronics
        fields[2] = "B1"; // Orderbook event

        // Add some bid levels
        fields[10] = "70000"; // bid price 1
        fields[11] = "100"; // bid quantity 1
        fields[12] = "69900"; // bid price 2
        fields[13] = "200"; // bid quantity 2

        // Add some ask levels
        fields[30] = "70100"; // ask price 1
        fields[31] = "150"; // ask quantity 1
        fields[32] = "70200"; // ask price 2
        fields[33] = "250"; // ask quantity 2

        let line = fields.join("|");
        let event = adapter.parse_line(&line).unwrap();

        assert_eq!(event.event_type, KrxEventType::OrderBook);
        assert_eq!(event.symbol, "SAMSUNG-KRW");

        let snapshot = event.to_orderbook_snapshot(&adapter).unwrap();
        assert_eq!(snapshot.bids.len(), 2);
        assert_eq!(snapshot.asks.len(), 2);
        assert_eq!(snapshot.bids[0].price, dec!(70000));
        assert_eq!(snapshot.asks[0].price, dec!(70100));
    }
}