//+------------------------------------------------------------------+
//| PerformanceMetricsCollector.mqh - Per-Component Latency Tracking  |
//+------------------------------------------------------------------+
#ifndef PERFORMANCE_METRICS_COLLECTOR_MQH
#define PERFORMANCE_METRICS_COLLECTOR_MQH

//+------------------------------------------------------------------+
//| Component latency metric entry                                   |
//+------------------------------------------------------------------+
struct SComponentLatencyMetric
{
   string    component_name;
   datetime  timestamp;
   ulong     latency_us;      // Microseconds
   ulong     count;           // Call count
   bool      budget_exceeded; // Whether latency exceeded budget
   string    context;         // Additional context (e.g., "gate_G1", "trade_BTCUSD")
};

//+------------------------------------------------------------------+
//| Rolling window latency statistics                                  |
//+------------------------------------------------------------------+
struct SLatencyStats
{
   string    component_name;
   double    avg_latency_us;
   double    max_latency_us;
   double    min_latency_us;
   double    p95_latency_us;
   ulong     total_calls;
   ulong     budget_violations;
   datetime  last_updated;
   
   void Reset()
   {
      component_name = "";
      avg_latency_us = 0.0;
      max_latency_us = 0.0;
      min_latency_us = 1e9;
      p95_latency_us = 0.0;
      total_calls = 0;
      budget_violations = 0;
      last_updated = 0;
   }
};

//+------------------------------------------------------------------+
//| Performance Metrics Collector Class                                |
//+------------------------------------------------------------------+
class CPerformanceMetricsCollector
{
private:
   SComponentLatencyMetric m_metrics[];
   int                     m_metrics_count;
   int                     m_max_metrics;
   
   SLatencyStats           m_stats[];
   int                     m_stats_count;
   
   ulong                   m_component_budgets[]; // Per-component budgets in us
   
   // Rolling window for P95 calculation (last 100 samples per component)
   double                  m_latency_history[][100];
   int                     m_history_index[];
   int                     m_history_count[];
   
public:
   // Constructor
   CPerformanceMetricsCollector(int max_metrics = 1000)
   {
      m_metrics_count = 0;
      m_max_metrics = max_metrics;
      m_stats_count = 0;
      
      ArrayResize(m_metrics, 0);
      ArrayResize(m_stats, 0);
      ArrayResize(m_component_budgets, 0);
      ArrayResize(m_latency_history, 0);
      ArrayResize(m_history_index, 0);
      ArrayResize(m_history_count, 0);
   }
   
   //+------------------------------------------------------------------+
   //| Register a component with its latency budget                      |
   //+------------------------------------------------------------------+
   void RegisterComponent(string component_name, ulong budget_us)
   {
      int idx = FindOrCreateComponentIndex(component_name);
      if(idx >= 0)
      {
         // Ensure arrays are sized
         if(idx >= ArraySize(m_component_budgets))
         {
            int old_size = ArraySize(m_component_budgets);
            ArrayResize(m_component_budgets, idx + 1);
            ArrayResize(m_latency_history, idx + 1);
            ArrayResize(m_history_index, idx + 1);
            ArrayResize(m_history_count, idx + 1);
            
            // Initialize new entries
            for(int i = old_size; i <= idx; i++)
            {
               m_component_budgets[i] = 5000; // Default 5ms
               m_history_index[i] = 0;
               m_history_count[i] = 0;
            }
         }
         
         m_component_budgets[idx] = budget_us;
         
         // Initialize stats entry
         if(idx >= m_stats_count)
         {
            int old_stats = m_stats_count;
            m_stats_count = idx + 1;
            ArrayResize(m_stats, m_stats_count);
            
            for(int i = old_stats; i < m_stats_count; i++)
               m_stats[i].Reset();
         }
         
         m_stats[idx].component_name = component_name;
      }
   }
   
   //+------------------------------------------------------------------+
   //| Record a latency measurement                                      |
   //+------------------------------------------------------------------+
   void RecordLatency(string component_name, ulong latency_us, string context = "")
   {
      // Add to metrics log (if not at capacity)
      if(m_metrics_count < m_max_metrics)
      {
         int idx = m_metrics_count;
         ArrayResize(m_metrics, m_metrics_count + 1);
         
         m_metrics[idx].component_name = component_name;
         m_metrics[idx].timestamp = TimeCurrent();
         m_metrics[idx].latency_us = latency_us;
         m_metrics[idx].count = 1;
         m_metrics[idx].context = context;
         
         int comp_idx = FindOrCreateComponentIndex(component_name);
         if(comp_idx >= 0 && comp_idx < ArraySize(m_component_budgets))
         {
            m_metrics[idx].budget_exceeded = (latency_us > m_component_budgets[comp_idx]);
         }
         else
         {
            m_metrics[idx].budget_exceeded = false;
         }
         
         m_metrics_count++;
      }
      
      // Update rolling statistics
      UpdateStats(component_name, latency_us);
      
      // Update history for P95
      UpdateHistory(component_name, latency_us);
   }
   
   //+------------------------------------------------------------------+
   //| Get latency statistics for a component                            |
   //+------------------------------------------------------------------+
   bool GetComponentStats(string component_name, SLatencyStats &out_stats)
   {
      int idx = FindComponentIndex(component_name);
      if(idx < 0 || idx >= m_stats_count)
         return false;
      
      // Calculate P95 from history
      CalculateP95(idx);
      
      out_stats = m_stats[idx];
      return true;
   }
   
   //+------------------------------------------------------------------+
   //| Check if component exceeded its budget                             |
   //+------------------------------------------------------------------+
   bool DidExceedBudget(string component_name, ulong latency_us)
   {
      int idx = FindComponentIndex(component_name);
      if(idx < 0 || idx >= ArraySize(m_component_budgets))
         return false;
      
      return latency_us > m_component_budgets[idx];
   }
   
   //+------------------------------------------------------------------+
   //| Get budget violation report                                       |
   //+------------------------------------------------------------------+
   string GetBudgetViolationReport()
   {
      string report = "=== Performance Budget Violations ===\n";
      bool has_violations = false;
      
      for(int i = 0; i < m_stats_count; i++)
      {
         if(m_stats[i].budget_violations > 0)
         {
            has_violations = true;
            report += StringFormat("%s: %d violations (%.2f%% of calls)\n",
               m_stats[i].component_name,
               (int)m_stats[i].budget_violations,
               100.0 * m_stats[i].budget_violations / MathMax(1, (double)m_stats[i].total_calls));
         }
      }
      
      if(!has_violations)
         report += "No budget violations recorded.\n";
      
      return report;
   }
   
   //+------------------------------------------------------------------+
   //| Get full performance report                                         |
   //+------------------------------------------------------------------+
   string GetFullReport()
   {
      string report = "=== Performance Metrics Report ===\n";
      report += StringFormat("Total components: %d\n", m_stats_count);
      report += StringFormat("Total measurements: %d\n\n", m_metrics_count);
      
      for(int i = 0; i < m_stats_count; i++)
      {
         // Calculate P95
         CalculateP95(i);
         
         report += StringFormat(
            "%s:\n"
            "  Avg: %.2fms | P95: %.2fms | Min: %.2fms | Max: %.2fms\n"
            "  Calls: %I64u | Budget violations: %I64u\n\n",
            m_stats[i].component_name,
            m_stats[i].avg_latency_us / 1000.0,
            m_stats[i].p95_latency_us / 1000.0,
            m_stats[i].min_latency_us / 1000.0,
            m_stats[i].max_latency_us / 1000.0,
            m_stats[i].total_calls,
            m_stats[i].budget_violations
         );
      }
      
      return report;
   }
   
   //+------------------------------------------------------------------+
   //| Clear old metrics (keep last N measurements per component)        |
   //+------------------------------------------------------------------+
   void TrimOldMetrics(int keep_per_component = 100)
   {
      // Simple implementation: if we exceed max, clear half
      if(m_metrics_count >= m_max_metrics)
      {
         int new_count = m_metrics_count / 2;
         ArrayResize(m_metrics, new_count);
         m_metrics_count = new_count;
      }
   }
   
private:
   //+------------------------------------------------------------------+
   //| Find or create component index                                     |
   //+------------------------------------------------------------------+
   int FindOrCreateComponentIndex(string component_name)
   {
      int idx = FindComponentIndex(component_name);
      if(idx >= 0)
         return idx;
      
      // Create new entry
      idx = m_stats_count;
      m_stats_count++;
      ArrayResize(m_stats, m_stats_count);
      m_stats[idx].Reset();
      m_stats[idx].component_name = component_name;
      
      return idx;
   }
   
   //+------------------------------------------------------------------+
   //| Find component index                                               |
   //+------------------------------------------------------------------+
   int FindComponentIndex(string component_name)
   {
      for(int i = 0; i < m_stats_count; i++)
      {
         if(m_stats[i].component_name == component_name)
            return i;
      }
      return -1;
   }
   
   //+------------------------------------------------------------------+
   //| Update statistics for a component                                 |
   //+------------------------------------------------------------------+
   void UpdateStats(string component_name, ulong latency_us)
   {
      int idx = FindOrCreateComponentIndex(component_name);
      if(idx < 0 || idx >= m_stats_count)
         return;
      
      SLatencyStats &stats = m_stats[idx];
      
      // Update running average
      double old_avg = stats.avg_latency_us;
      ulong n = stats.total_calls;
      stats.avg_latency_us = (old_avg * n + latency_us) / (n + 1);
      
      // Update min/max
      stats.max_latency_us = MathMax(stats.max_latency_us, latency_us);
      stats.min_latency_us = MathMin(stats.min_latency_us, latency_us);
      
      // Increment call count
      stats.total_calls++;
      
      // Check budget violation
      if(idx < ArraySize(m_component_budgets) && latency_us > m_component_budgets[idx])
         stats.budget_violations++;
      
      stats.last_updated = TimeCurrent();
   }
   
   //+------------------------------------------------------------------+
   //| Update latency history for P95 calculation                        |
   //+------------------------------------------------------------------+
   void UpdateHistory(string component_name, ulong latency_us)
   {
      int idx = FindOrCreateComponentIndex(component_name);
      if(idx < 0 || idx >= ArraySize(m_history_index))
         return;
      
      // Store in circular buffer
      int h_idx = m_history_index[idx];
      m_latency_history[idx][h_idx] = (double)latency_us;
      m_history_index[idx] = (h_idx + 1) % 100;
      
      if(m_history_count[idx] < 100)
         m_history_count[idx]++;
   }
   
   //+------------------------------------------------------------------+
   //| Calculate P95 for a component                                     |
   //+------------------------------------------------------------------+
   void CalculateP95(int component_idx)
   {
      if(component_idx < 0 || component_idx >= ArraySize(m_history_count))
         return;
      
      int count = m_history_count[component_idx];
      if(count == 0)
      {
         m_stats[component_idx].p95_latency_us = 0.0;
         return;
      }
      
      // Copy and sort
      double sorted[];
      ArrayResize(sorted, count);
      ArrayCopy(sorted, m_latency_history[component_idx], 0, 0, count);
      ArraySort(sorted);
      
      // Get P95 index
      int p95_idx = (int)MathFloor(count * 0.95);
      if(p95_idx >= count) p95_idx = count - 1;
      
      m_stats[component_idx].p95_latency_us = sorted[p95_idx];
   }
};

// Global instance
CPerformanceMetricsCollector* g_performance_collector = NULL;

//+------------------------------------------------------------------+
//| Initialize performance collector                                  |
//+------------------------------------------------------------------+
bool InitializePerformanceCollector()
{
   if(g_performance_collector != NULL)
      delete g_performance_collector;
   
   g_performance_collector = new CPerformanceMetricsCollector(10000);
   
   // Register standard components with budgets
   g_performance_collector.RegisterComponent("OnTick", 5000);          // 5ms
   g_performance_collector.RegisterComponent("OnTimer", 10000);         // 10ms
   g_performance_collector.RegisterComponent("GateEvaluation", 2000);    // 2ms per gate
   g_performance_collector.RegisterComponent("TradeExecution", 5000);    // 5ms
   g_performance_collector.RegisterComponent("PolicyUpdate", 5000);    // 5ms
   g_performance_collector.RegisterComponent("FeatureCache", 1000);      // 1ms
   g_performance_collector.RegisterComponent("PositionSync", 3000);    // 3ms
   
   LOG("[PerformanceCollector] Initialized with component budgets");
   return true;
}

//+------------------------------------------------------------------+
//| Shutdown performance collector                                    |
//+------------------------------------------------------------------+
void ShutdownPerformanceCollector()
{
   if(g_performance_collector != NULL)
   {
      delete g_performance_collector;
      g_performance_collector = NULL;
   }
}

//+------------------------------------------------------------------+
//| Convenience macros for timing                                      |
//+------------------------------------------------------------------+
#define PERF_START(name) \
   ulong __perf_start_##name = GetMicrosecondCount();

#define PERF_END(name) \
   do { \
      if(g_performance_collector != NULL) { \
         g_performance_collector.RecordLatency(#name, GetMicrosecondCount() - __perf_start_##name); \
      } \
   } while(0)

#define PERF_END_CTX(name, context) \
   do { \
      if(g_performance_collector != NULL) { \
         g_performance_collector.RecordLatency(#name, GetMicrosecondCount() - __perf_start_##name, context); \
      } \
   } while(0)

#endif // PERFORMANCE_METRICS_COLLECTOR_MQH