//+------------------------------------------------------------------+
//| DualEA_MasterIntegration.mqh - Complete P0/P1 Integration        |
//| Master include file that initializes all hardened components      |
//| Version: 2.0 - Comprehensive EA Hardening & Intelligence Upgrade |
//+------------------------------------------------------------------+
#ifndef DUALEA_MASTERINTEGRATION_MQH
#define DUALEA_MASTERINTEGRATION_MQH

//+------------------------------------------------------------------+
//| P0 Components - Critical Fixes                                   |
//+------------------------------------------------------------------+
#include "CShadowLogger.mqh"           // P0-1: Atomic CSV writes
#include "CGateFeatureCache.mqh"       // P0-5: Feature caching

//+------------------------------------------------------------------+
//| P1 Components - Architecture Upgrades                              |
//+------------------------------------------------------------------+
#include "CSQLiteKnowledgeBase.mqh"    // P1-1: SQLite KB
#include "CInsightGateBridge.mqh"      // P1-2: O(1) insights bridge
#include "CRegimeAwareStrategy.mqh"    // P1-3: Regime adaptation
#include "CSystemMonitor.mqh"          // P1-4: Health circuit breaker
// Replaced Redis with SQLite - zero external dependencies
#include "CSQLiteExplorationCounter.mqh"// P1-5: Redis counters
#include "CPositionManager.mqh"        // P1-6: Correlation sizing

// Include existing components
#include "EnhancedEfficientGateSystem.mqh"
#include "CMLPolishGateONNX.mqh"

//+------------------------------------------------------------------+
//| Configuration Structure                                            |
//+------------------------------------------------------------------+
struct SDualEAConfig
{
   // P0-1: Shadow logging
   bool   shadow_logging_enabled;
   bool   shadow_mode_only;
   string shadow_log_directory;
   
   // P0-4: ONNX monitoring
   bool   onnx_health_monitor_enabled;
   int    onnx_max_latency_ms;
   
   // P0-5: Feature cache
   int    feature_cache_max_age_seconds;
   
   // P1-1: SQLite
   bool   sqlite_enabled;
   string sqlite_db_name;
   
   // P1-2: Insight bridge
   int    insight_cache_sync_seconds;
   
   // P1-4: System monitor
   bool   circuit_breaker_enabled;
   double max_tick_latency_ms;
   double max_error_rate_per_hour;
   int    circuit_breaker_cooldown_minutes;
   
   // P1-5: Redis
   bool   redis_enabled;
   string redis_host;
   int    redis_port;
   
   // P1-6: Position management
   bool   correlation_sizing_enabled;
   bool   volatility_exits_enabled;
   double max_risk_per_trade_pct;
   double max_total_risk_pct;
   int    max_positions;
   
   void SetDefaults()
   {
      // P0 defaults
      shadow_logging_enabled = true;
      shadow_mode_only = false;
      shadow_log_directory = "DualEA\\ShadowLogs";
      
      // P0-4 defaults
      onnx_health_monitor_enabled = true;
      onnx_max_latency_ms = 100;
      
      // P0-5 defaults
      feature_cache_max_age_seconds = 5;
      
      // P1-1 defaults
      sqlite_enabled = true;
      sqlite_db_name = "dualea_kb.db";
      
      // P1-2 defaults
      insight_cache_sync_seconds = 60;
      
      // P1-4 defaults
      circuit_breaker_enabled = true;
      max_tick_latency_ms = 50.0;
      max_error_rate_per_hour = 50.0;
      circuit_breaker_cooldown_minutes = 15;
      
      // P1-5 defaults
      redis_enabled = false;  // Disabled by default (requires Redis server)
      redis_host = "127.0.0.1";
      redis_port = 6379;
      
      // P1-6 defaults
      correlation_sizing_enabled = true;
      volatility_exits_enabled = true;
      max_risk_per_trade_pct = 1.0;
      max_total_risk_pct = 5.0;
      max_positions = 10;
   }
};

//+------------------------------------------------------------------+
//| Dual EA Master Controller                                        |
//+------------------------------------------------------------------+
class CDualEAMasterController
{
private:
   SDualEAConfig m_config;
   bool          m_initialized;
   datetime      m_last_status_log;
   
   // Component references
   CShadowLogger*          m_shadow_logger;
   CGateFeatureCache*      m_feature_cache;
   CSQLiteKnowledgeBase*   m_sqlite_kb;
   CInsightGateBridge*     m_insight_bridge;
   CRegimeAwareStrategy*   m_regime_strategy;
   CSystemMonitor*         m_system_monitor;
   CSQLiteExplorationCounter* m_explore_counter;
   CPositionManager*       m_position_manager;
   
public:
   // Constructor
   CDualEAMasterController()
   {
      m_config.SetDefaults();
      m_initialized = false;
      m_last_status_log = 0;
      m_shadow_logger = NULL;
      m_feature_cache = NULL;
      m_sqlite_kb = NULL;
      m_insight_bridge = NULL;
      m_regime_strategy = NULL;
      m_system_monitor = NULL;
      m_explore_counter = NULL;
      m_position_manager = NULL;
   }
   
   //+------------------------------------------------------------------+
   //| Initialize all components                                          |
   //+------------------------------------------------------------------+
   bool Initialize(const SDualEAConfig &config)
   {
      m_config = config;
      
      Print("=== DualEA Master Controller v2.0 Initializing ===");
      
      // P0-5: Initialize feature cache first (others depend on it)
      if(!InitializeFeatureCache()) return false;
      
      // P1-1: Initialize SQLite KB
      if(m_config.sqlite_enabled)
      {
         if(!InitializeSQLiteKB()) return false;
      }
      
      // P1-3: Initialize regime strategy (depends on feature cache)
      if(!InitializeRegimeStrategy()) return false;
      
      // P1-2: Initialize insight bridge (depends on SQLite KB)
      if(m_config.sqlite_enabled)
      {
         if(!InitializeInsightBridge()) return false;
      }
      
      // P1-4: Initialize system monitor
      if(m_config.circuit_breaker_enabled)
      {
         if(!InitializeSystemMonitor()) return false;
      }
      
      // P1-5: Initialize exploration counter (SQLite-based)
      if(!InitializeExploreCounter()) return false;
      
      // P1-6: Initialize position manager (depends on feature cache and regime)
      if(!InitializePositionManager()) return false;
      
      // P0-1: Initialize shadow logger
      if(m_config.shadow_logging_enabled)
      {
         if(!InitializeShadowLogger()) return false;
      }
      
      m_initialized = true;
      Print("=== DualEA Master Controller v2.0 Ready ===");
      
      return true;
   }
   
   //+------------------------------------------------------------------+
   //| Component initializers                                           |
   //+------------------------------------------------------------------+
   bool InitializeFeatureCache()
   {
      m_feature_cache = new CGateFeatureCache();
      if(!m_feature_cache.Initialize())
      {
         Print("[MasterController] ERROR: Feature cache initialization failed");
         return false;
      }
      
      // Set global reference for gates
      g_gate_feature_cache = m_feature_cache;
      
      Print("[MasterController] P0-5: Feature cache initialized");
      return true;
   }
   
   bool InitializeSQLiteKB()
   {
      m_sqlite_kb = new CSQLiteKnowledgeBase(m_config.sqlite_db_name);
      if(!m_sqlite_kb.Initialize())
      {
         Print("[MasterController] WARNING: SQLite KB init failed, continuing with reduced functionality");
         // Don't fail completely - we can work without SQLite
         delete m_sqlite_kb;
         m_sqlite_kb = NULL;
         m_config.sqlite_enabled = false;
         return true;
      }
      
      g_sqlite_kb = m_sqlite_kb;
      Print("[MasterController] P1-1: SQLite KB initialized");
      return true;
   }
   
   bool InitializeInsightBridge()
   {
      m_insight_bridge = new CInsightGateBridge(m_sqlite_kb);
      if(!m_insight_bridge.Initialize(m_sqlite_kb))
      {
         Print("[MasterController] WARNING: Insight bridge init failed");
         delete m_insight_bridge;
         m_insight_bridge = NULL;
         return true;  // Don't fail completely
      }
      
      // CRITICAL: Preload historical data to populate bridge stats immediately
      m_insight_bridge.PreloadHotStrategies();
      
      g_insight_gate_bridge = m_insight_bridge;
      Print("[MasterController] P1-2: Insight-Gate bridge initialized with historical data");
      return true;
   }
   
   bool InitializeRegimeStrategy()
   {
      m_regime_strategy = new CRegimeAwareStrategy(m_feature_cache);
      
      g_regime_strategy = m_regime_strategy;
      Print("[MasterController] P1-3: Regime-aware strategy initialized");
      return true;
   }
   
   bool InitializeSystemMonitor()
   {
      m_system_monitor = new CSystemMonitor();
      
      // Thresholds are configured internally via SHealthThresholds.SetDefaults()
      // m_system_monitor.SetThresholds() is not available - using default thresholds
      
      g_system_monitor = m_system_monitor;
      Print("[MasterController] P1-4: System monitor with circuit breaker initialized");
      return true;
   }
   
   bool InitializeExploreCounter()
   {
      m_explore_counter = new CSQLiteExplorationCounter();
      if(!m_explore_counter.Initialize())
      {
         Print("[MasterController] WARNING: Exploration counter init failed, using fallback");
         delete m_explore_counter;
         m_explore_counter = NULL;
         return true;  // Don't fail - fallback is built-in
      }
      
      g_sqliteCounter = m_explore_counter;
      Print("[MasterController] P1-5: SQLite exploration counter initialized");
      return true;
   }
   
   bool InitializePositionManager()
   {
      m_position_manager = new CPositionManager(m_feature_cache, m_regime_strategy);
      
      // Configure
      m_position_manager.SetMaxPositions(m_config.max_positions);
      m_position_manager.SetMaxRiskPerTrade(m_config.max_risk_per_trade_pct);
      m_position_manager.SetMaxTotalRisk(m_config.max_total_risk_pct);
      
      SVolatilityExitConfig vol_config;
      vol_config.SetDefaults();
      m_position_manager.SetVolatilityExitConfig(vol_config);
      
      g_position_manager = m_position_manager;
      Print("[MasterController] P1-6: Position manager with correlation sizing initialized");
      return true;
   }
   
   bool InitializeShadowLogger()
   {
      m_shadow_logger = new CShadowLogger();
      
      if(!m_shadow_logger.Initialize(m_config.shadow_mode_only, m_config.shadow_log_directory))
      {
         Print("[MasterController] WARNING: Shadow logger init failed");
         delete m_shadow_logger;
         m_shadow_logger = NULL;
         return true;  // Don't fail
      }
      
      Print("[MasterController] P0-1: Shadow logger with atomic CSV initialized");
      return true;
   }
   
   //+------------------------------------------------------------------+
   //| OnTick processing - call from EA's OnTick()                      |
   //+------------------------------------------------------------------+
   void OnTick()
   {
      if(!m_initialized) return;
      
      // P0-5: Update feature cache
      if(m_feature_cache != NULL)
         m_feature_cache.Update();
      
      // P1-3: Update regime detection
      if(m_regime_strategy != NULL)
         m_regime_strategy.Update();
      
      // P1-4: Update system monitor
      if(m_system_monitor != NULL)
         m_system_monitor.OnTickUpdate();
      
      // P1-6: Check volatility exits
      if(m_position_manager != NULL)
         m_position_manager.CheckVolatilityExits();
      
      // P1-2: Sync insight bridge periodically
      if(m_insight_bridge != NULL && m_system_monitor != NULL)
      {
         static int tick_counter = 0;
         tick_counter++;
         if(tick_counter % 600 == 0)  // Every ~10 seconds (assuming 60 ticks/sec)
         {
            m_insight_bridge.OnTickSync();
         }
      }
      
      // Log status periodically
      if(TimeCurrent() - m_last_status_log > 300)  // Every 5 minutes
      {
         LogSystemStatus();
         m_last_status_log = TimeCurrent();
      }
   }
   
   //+------------------------------------------------------------------+
   //| Check if trading is allowed (circuit breaker)                    |
   //+------------------------------------------------------------------+
   bool IsTradingAllowed(string &reason)
   {
      reason = "";
      
      // P1-4: Check system monitor circuit breaker
      if(m_system_monitor != NULL && m_system_monitor.IsCircuitBreakerActive())
      {
         reason = "Circuit breaker: " + m_system_monitor.GetCircuitBreakerReason();
         return false;
      }
      
      // P1-3: Check regime allows trading
      if(m_regime_strategy != NULL)
      {
         if(!m_regime_strategy.IsTradingAllowed(reason))
         {
            return false;
         }
      }
      
      return true;
   }
   
   //+------------------------------------------------------------------+
   //| Process trade signal through all gates                           |
   //+------------------------------------------------------------------+
   bool ProcessTradeSignal(TradingSignal &signal, 
                           CEfficientGateManagerEnhanced &gate_manager,
                           string &block_reason)
   {
      // P1-3: Apply regime-adjusted parameters
      if(m_regime_strategy != NULL)
      {
         double min_confidence = m_regime_strategy.GetMinConfidenceThreshold();
         // Could adjust gate thresholds here
      }
      
      // P1-2: Fast gate decision using insights
      if(m_insight_bridge != NULL)
      {
         double signal_confidence = m_insight_bridge.GetSignalConfidence(
            signal.strategy, signal.symbol);
         
         if(signal_confidence < 0.4)
         {
            // Adjust-only mode: do not block, but penalize confidence and annotate reason
            signal.confidence = MathMax(0.05, MathMin(1.0, signal.confidence * signal_confidence));
            block_reason = "Low insight confidence (soft): " + DoubleToString(signal_confidence, 2);
         }
      }
      
      // P1-6: Check position limits
      if(m_position_manager != NULL)
      {
         double risk_amount = 0;  // Calculate based on signal
         if(!m_position_manager.CanOpenPosition(signal.symbol, signal.type, 
                                                  risk_amount, block_reason))
         {
            return false;
         }
      }
      
      // Process through gate cascade
      CSignalDecision decision;
      return gate_manager.ProcessSignalEnhanced(signal, decision, block_reason);
   }
   
   //+------------------------------------------------------------------+
   //| Log gate decision to shadow log                                  |
   //+------------------------------------------------------------------+
   void LogGateDecision(const string &gate_name, const TradingSignal &signal, 
                        bool passed, double confidence, double threshold)
   {
      if(m_shadow_logger != NULL)
      {
         SShadowLogEntry entry;
         entry.Init(signal.symbol, signal.direction == 0 ? "BUY" : "SELL", 
                    signal.price, signal.volume, signal.strategy);
         
         // Convert gate_name to gate number for entry
         int gate_num = 0;
         if(gate_name == "G1") gate_num = 0;
         else if(gate_name == "G2") gate_num = 1;
         else if(gate_name == "G3") gate_num = 2;
         else if(gate_name == "G4") gate_num = 3;
         else if(gate_name == "G5") gate_num = 4;
         else if(gate_name == "G6") gate_num = 5;
         else if(gate_name == "G7") gate_num = 6;
         else if(gate_name == "G8") gate_num = 7;
         
         entry.gate_passed[gate_num] = passed;
         entry.gate_confidence[gate_num] = confidence;
         entry.gate_threshold[gate_num] = threshold;
         entry.gate_block_reason[gate_num] = passed ? "" : "Below threshold";
         
         m_shadow_logger.LogGateDecision(entry);
      }
   }
   
   //+------------------------------------------------------------------+
   //| Record completed trade                                           |
   //+------------------------------------------------------------------+
   void RecordTrade(const STradeRecord &trade)
   {
      // P1-1: Log to SQLite
      if(m_sqlite_kb != NULL)
      {
         m_sqlite_kb.LogTrade(trade);
      }
      
      // P1-2: Update insight bridge
      if(m_insight_bridge != NULL)
      {
         m_insight_bridge.OnTradeCompleted(trade.strategy, trade.symbol, 
                                              trade.pnl, trade.r_multiple);
      }
      
      // P1-4: Update system monitor
      if(m_system_monitor != NULL)
      {
         m_system_monitor.RecordTrade();
      }
      
      // P1-6: Remove from position tracking
      if(m_position_manager != NULL && trade.id > 0)
      {
         // m_position_manager->RemovePosition((ulong)trade.id);
      }
   }
   
   //+------------------------------------------------------------------+
   //| Get position size with all adjustments                           |
   //+------------------------------------------------------------------+
   double CalculatePositionSize(const TradingSignal &signal, double risk_pct)
   {
      if(m_position_manager == NULL) return 0;
      
      double account_balance = AccountInfoDouble(ACCOUNT_BALANCE);
      
      return m_position_manager.CalculatePositionSize(
         signal.symbol,
         signal.type,
         signal.price,
         signal.sl,
         risk_pct,
         account_balance
      );
   }
   
   //+------------------------------------------------------------------+
   //| Log system status                                                |
   //+------------------------------------------------------------------+
   void LogSystemStatus()
   {
      string status = "=== DualEA System Status ===\n";
      
      // P1-4: System monitor status
      if(m_system_monitor != NULL)
      {
         status += "Health: " + m_system_monitor.GetHealthReport() + "\n";
      }
      
      // P1-3: Regime status
      if(m_regime_strategy != NULL)
      {
         status += "Regime: " + m_regime_strategy.RegimeToString(
            m_regime_strategy.GetCurrentRegime()) + "\n";
      }
      
      // P1-6: Position status
      if(m_position_manager != NULL)
      {
         status += "Positions: " + m_position_manager.GetRiskReport() + "\n";
      }
      
      // P1-2: Bridge status
      if(m_insight_bridge != NULL)
      {
         double hit_rate, avg_lookup;
         int cache_size;
         m_insight_bridge.GetStats(hit_rate, avg_lookup, cache_size);
         status += StringFormat("Insights: HitRate=%.1f%% Latency=%.2fus Cache=%d\n",
            hit_rate * 100, avg_lookup, cache_size);
      }
      
      Print(status);
   }
   
   //+------------------------------------------------------------------+
   //| Shutdown all components                                            |
   //+------------------------------------------------------------------+
   void Shutdown()
   {
      Print("=== DualEA Master Controller v2.0 Shutting Down ===");
      
      // Save all data
      if(m_sqlite_kb != NULL) m_sqlite_kb.Close();
      
      // Cleanup
      if(m_shadow_logger != NULL) { delete m_shadow_logger; m_shadow_logger = NULL; }
      if(m_position_manager != NULL) { delete m_position_manager; m_position_manager = NULL; }
      if(m_system_monitor != NULL) { delete m_system_monitor; m_system_monitor = NULL; }
      if(m_insight_bridge != NULL) { delete m_insight_bridge; m_insight_bridge = NULL; }
      if(m_regime_strategy != NULL) { delete m_regime_strategy; m_regime_strategy = NULL; }
      if(m_sqlite_kb != NULL) { delete m_sqlite_kb; m_sqlite_kb = NULL; }
      if(m_feature_cache != NULL) { delete m_feature_cache; m_feature_cache = NULL; }
      
      m_initialized = false;
      Print("=== DualEA Master Controller v2.0 Shutdown Complete ===");
   }
   
   //+------------------------------------------------------------------+
   //| Getters                                                          |
   //+------------------------------------------------------------------+
   CRegimeAwareStrategy* GetRegimeStrategy() { return m_regime_strategy; }
   CPositionManager* GetPositionManager() { return m_position_manager; }
   CSystemMonitor* GetSystemMonitor() { return m_system_monitor; }
   CInsightGateBridge* GetInsightBridge() { return m_insight_bridge; }
   CSQLiteKnowledgeBase* GetSQLiteKB() { return m_sqlite_kb; }
   bool IsInitialized() { return m_initialized; }
};

// Global master controller instance
CDualEAMasterController* g_master_controller = NULL;

//+------------------------------------------------------------------+
//| Initialize DualEA Master Controller                                |
//+------------------------------------------------------------------+
bool InitializeDualEAMasterController(const SDualEAConfig &config)
{
   if(g_master_controller != NULL)
   {
      g_master_controller.Shutdown();
      delete g_master_controller;
   }
   
   g_master_controller = new CDualEAMasterController();
   return g_master_controller.Initialize(config);
}

//+------------------------------------------------------------------+
//| Shutdown DualEA Master Controller                                  |
//+------------------------------------------------------------------+
void ShutdownDualEAMasterController()
{
   if(g_master_controller != NULL)
   {
      g_master_controller.Shutdown();
      delete g_master_controller;
      g_master_controller = NULL;
   }
}

#endif // DUALEA_MASTERINTEGRATION_MQH