fixed up rust system

apps/stock/core/src/backtest/engine.rs

@@ -75,18 +75,29 @@ impl BacktestEngine {
     }
     
     pub async fn run(&mut self) -> Result<BacktestResult, String> {
+        eprintln!("=== BacktestEngine::run() START ===");
+        eprintln!("Config: start={}, end={}, symbols={:?}", 
+            self.config.start_time, self.config.end_time, self.config.symbols);
+        eprintln!("Number of strategies loaded: {}", self.strategies.read().len());
+        
         // Initialize start time
         if let Some(simulated_time) = self.time_provider.as_any()
             .downcast_ref::<crate::core::time_providers::SimulatedTime>() 
         {
             simulated_time.advance_to(self.config.start_time);
+            eprintln!("Time initialized to: {}", self.config.start_time);
         }
         
         // Load market data
+        eprintln!("Loading market data from data source...");
         self.load_market_data().await?;
         
-        eprintln!("Event queue empty: {}, length: {}", self.event_queue.read().is_empty(), self.event_queue.read().len());
-        eprintln!("Current time: {}, End time: {}", self.time_provider.now(), self.config.end_time);
+        let queue_len = self.event_queue.read().len();
+        eprintln!("Event queue length after loading: {}", queue_len);
+        
+        if queue_len == 0 {
+            eprintln!("WARNING: No events loaded! Check data source.");
+        }
         
         // Main event loop
         let mut iteration = 0;
@@ -128,31 +139,56 @@ impl BacktestEngine {
     }
     
     async fn load_market_data(&mut self) -> Result<(), String> {
-        eprintln!("load_market_data: Starting");
+        eprintln!("=== load_market_data START ===");
         let mut data_source = self.market_data_source.write();
         
-        eprintln!("load_market_data: Seeking to start time: {}", self.config.start_time);
-        // Seek to start time
+        // Check if it's a HistoricalDataSource
+        if let Some(historical) = data_source.as_any()
+            .downcast_ref::<crate::core::market_data_sources::HistoricalDataSource>() {
+            eprintln!("Data source is HistoricalDataSource");
+            eprintln!("Historical data points available: {}", historical.data_len());
+        } else {
+            eprintln!("WARNING: Data source is NOT HistoricalDataSource!");
+        }
+        
+        eprintln!("Seeking to start time: {}", self.config.start_time);
         data_source.seek_to_time(self.config.start_time)?;
         
-        eprintln!("load_market_data: Loading data");
         let mut count = 0;
+        let mut first_few = 0;
+        
         // Load all data into event queue
         while let Some(update) = data_source.get_next_update().await {
             if update.timestamp > self.config.end_time {
+                eprintln!("Reached end time at {} data points", count);
                 break;
             }
             
             count += 1;
+            
+            // Log first few data points
+            if first_few < 3 {
+                eprintln!("Data point {}: symbol={}, time={}, type={:?}", 
+                    count, update.symbol, update.timestamp, 
+                    match &update.data {
+                        MarketDataType::Bar(b) => format!("Bar(close={})", b.close),
+                        MarketDataType::Quote(q) => format!("Quote(bid={}, ask={})", q.bid, q.ask),
+                        MarketDataType::Trade(t) => format!("Trade(price={})", t.price),
+                    }
+                );
+                first_few += 1;
+            }
+            
             if count % 100 == 0 {
-                eprintln!("load_market_data: Loaded {} data points", count);
+                eprintln!("Loaded {} data points so far...", count);
             }
             
             let event = BacktestEvent::market_data(update.timestamp, update);
             self.event_queue.write().push(event);
         }
         
-        eprintln!("load_market_data: Complete. Loaded {} total data points", count);
+        eprintln!("=== load_market_data COMPLETE ===");
+        eprintln!("Total data points loaded: {}", count);
         Ok(())
     }
     
@@ -164,10 +200,10 @@ impl BacktestEngine {
             EventType::OrderSubmitted(order) => {
                 self.process_order_submission(order).await?;
             }
-            EventType::OrderFilled(fill) => {
+            EventType::OrderFilled(_fill) => {
                 // Fills are already processed when orders are executed
                 // This event is just for recording
-                self.state.write().record_fill(fill);
+                // Note: We now record fills in process_fill with symbol info
             }
             EventType::OrderCancelled(order_id) => {
                 self.process_order_cancellation(&order_id)?;
@@ -181,6 +217,15 @@ impl BacktestEngine {
     }
     
     async fn process_market_data(&mut self, data: MarketUpdate) -> Result<(), String> {
+        static mut MARKET_DATA_COUNT: usize = 0;
+        unsafe {
+            MARKET_DATA_COUNT += 1;
+            if MARKET_DATA_COUNT <= 3 || MARKET_DATA_COUNT % 100 == 0 {
+                eprintln!("process_market_data #{}: symbol={}, time={}", 
+                    MARKET_DATA_COUNT, data.symbol, data.timestamp);
+            }
+        }
+        
         // Update price tracking
         match &data.data {
             MarketDataType::Bar(bar) => {
@@ -203,14 +248,18 @@ impl BacktestEngine {
         let mut all_signals = Vec::new();
         {
             let mut strategies = self.strategies.write();
-            for strategy in strategies.iter_mut() {
+            for (i, strategy) in strategies.iter_mut().enumerate() {
                 let signals = strategy.on_market_data(&market_data);
+                if !signals.is_empty() {
+                    eprintln!("Strategy {} generated {} signals!", i, signals.len());
+                }
                 all_signals.extend(signals);
             }
         }
         
         // Process signals
         for signal in all_signals {
+            eprintln!("Processing signal: {:?}", signal);
             self.process_signal(signal).await?;
         }
         
@@ -342,8 +391,8 @@ impl BacktestEngine {
             order.side,
         );
         
-        // Record the fill
-        self.state.write().record_fill(fill.clone());
+        // Record the fill with symbol and side information
+        self.state.write().record_fill(order.symbol.clone(), order.side, fill.clone());
         
         // Update cash
         let cash_change = match order.side {