work on integrating new system

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

@@ -85,56 +85,74 @@ impl BacktestEngine {
         // Load market data
         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);
+        
         // Main event loop
-        while !self.event_queue.read().is_empty() || 
-              self.time_provider.now() < self.config.end_time 
-        {
-            // Get next batch of events
-            let current_time = self.time_provider.now();
-            let events = self.event_queue.write().pop_until(current_time);
-            
-            for event in events {
-                self.process_event(event).await?;
+        let mut iteration = 0;
+        while !self.event_queue.read().is_empty() {
+            iteration += 1;
+            if iteration <= 5 || iteration % 100 == 0 {
+                eprintln!("Processing iteration {} at time {}", iteration, self.time_provider.now());
             }
             
-            // Update portfolio value
-            self.update_portfolio_value();
-            
-            // Check if we should advance time
-            if self.event_queue.read().is_empty() {
-                // Advance to next data point or end time
-                if let Some(next_time) = self.get_next_event_time() {
-                    if next_time < self.config.end_time {
-                        self.advance_time(next_time);
-                    } else {
-                        break;
-                    }
-                } else {
-                    break;
+            // Get the next event's timestamp
+            let next_event_time = self.event_queue.read()
+                .peek_next()
+                .map(|e| e.timestamp);
+                
+            if let Some(event_time) = next_event_time {
+                // Advance time to the next event
+                self.advance_time(event_time);
+                
+                // Get all events at this timestamp
+                let current_time = self.time_provider.now();
+                let events = self.event_queue.write().pop_until(current_time);
+                
+                for event in events {
+                    self.process_event(event).await?;
                 }
+                
+                // Update portfolio value
+                self.update_portfolio_value();
+            } else {
+                // No more events
+                break;
             }
         }
         
+        eprintln!("Backtest complete. Total trades: {}", self.total_trades);
+        
         // Generate results
         Ok(self.generate_results())
     }
     
     async fn load_market_data(&mut self) -> Result<(), String> {
+        eprintln!("load_market_data: Starting");
         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
         data_source.seek_to_time(self.config.start_time)?;
         
+        eprintln!("load_market_data: Loading data");
+        let mut count = 0;
         // Load all data into event queue
         while let Some(update) = data_source.get_next_update().await {
             if update.timestamp > self.config.end_time {
                 break;
             }
             
+            count += 1;
+            if count % 100 == 0 {
+                eprintln!("load_market_data: Loaded {} data points", 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);
         Ok(())
     }
     
@@ -391,8 +409,10 @@ impl BacktestEngine {
     }
     
     fn get_next_event_time(&self) -> Option<DateTime<Utc>> {
-        // In a real implementation, this would look at the next market data point
-        None
+        // Get the timestamp of the next event in the queue
+        self.event_queue.read()
+            .peek_next()
+            .map(|event| event.timestamp)
     }
     
     fn generate_results(&self) -> BacktestResult {