mql5/Experts/Archive/ERMT_7.1_main.mq5

//+------------------------------------------------------------------+
//|                    Risk Management Overlay EA v7.1               |
//|                    Fully Optimized Version                       |
//|                    Fixed Multi-Symbol Detection                  |
//+------------------------------------------------------------------+
#property copyright "Institutional Risk Management System v7.1"
#property version   "7.0"
#property strict
#property description "Modular risk management system with advanced monitoring"

//--- Include system modules
#include <Trade/Trade.mqh>
#include "Modules/RiskManager.mqh"
#include "Modules/TradeManager.mqh"
#include "Modules/EntrySystem.mqh"
#include "Modules/TechnicalAnalysis.mqh"
#include "Modules/Dashboard_Enhanced.mqh"
#include "Modules/Utilities.mqh"
#include "Modules/MultiTradeReporter.mqh"

//+------------------------------------------------------------------+
//| INPUT PARAMETERS - GROUPED BY MODULE                             |
//+------------------------------------------------------------------+

//--- System Configuration
input group "=== SYSTEM CONFIGURATION ==="
input bool     SystemEnabled = true;                     // Enable System
input int      TradingMagic = 12345;                     // EA Magic Number
input bool     ManageExternalTrades = true;              // Manage External Trades
input int      MagicNumberFilter = 0;                    // External Magic Filter (0=all)
input ENUM_LOG_LEVEL LogLevel = LOG_INFO;               // Logging Level

//--- Entry System Parameters
input group "=== ENTRY SYSTEM ==="
input ENUM_ENTRY_MODE EntryMode = ENTRY_MA_CROSS;       // Entry System Type
input bool     EnableMultipleEntries = false;            // Allow Multiple Entries
input int      MaxPositions = 3;                         // Maximum Positions
input double   MinTimeBetweenTrades = 60;                // Min Minutes Between Trades

//--- Risk Management Parameters
input group "=== RISK MANAGEMENT ==="
input ENUM_POSITION_SIZING SizingMode = PS_RISK_PERCENT; // Position Sizing Mode
input double   RiskPercent = 2.5;                        // Risk Per Trade (%)
input double   MaxRiskPercent = 5.0;                     // Maximum Risk (%)
input double   MaxDailyDrawdown = 5.0;                   // Max Daily Drawdown (%)
input double   MaxTotalExposure = 10.0;                  // Max Total Exposure (%)
input bool     UseKellyCriterion = false;               // Use Kelly Criterion
input double   KellyFraction = 0.25;                     // Kelly Fraction
input double   MinLotSize = 0.01;                        // Minimum Lot Size
input double   MaxLotSize = 10.0;                        // Maximum Lot Size

//--- Trade Management Parameters
input group "=== TRADE MANAGEMENT ==="
input ENUM_TP_MODE TPMode = TP_ADAPTIVE;                // Take Profit Mode
input ENUM_SL_MODE SLMode = SL_ATR;                     // Stop Loss Mode
input bool     EnableBreakeven = true;                   // Enable Breakeven
input double   BreakevenTrigger = 1.0;                   // Breakeven at X:1
input bool     EnableTrailing = true;                    // Enable Trailing Stop
input double   TrailingStart = 1.5;                      // Start Trailing at X:1
input bool     EnablePartialClose = true;                // Enable Partial Closes
input string   PartialLevels = "1.0:33,2.0:33,3.0:20";   // Partial Close Levels

//--- External Trade Management
input group "=== EXTERNAL TRADE RULES ==="
input bool     ForceRiskRules = true;                   // Force Risk Rules
input bool     ForceStopLoss = true;                    // Force Stop Loss
input bool     ForceTakeProfit = true;                  // Force Take Profit
input bool     OverrideExternalSL = false;              // Override Existing SL
input bool     OverrideExternalTP = false;              // Override Existing TP
input double   DefaultExternalRisk = 1.0;               // Default External Risk (%)
input bool     CloseExcessiveRisk = true;               // Close Excessive Risk

//--- Technical Analysis Parameters
input group "=== TECHNICAL ANALYSIS ==="
input bool     UseSupportResistance = true;             // Use S/R Levels
input bool     UseFibonacci = true;                     // Use Fibonacci
input bool     UsePivotPoints = true;                   // Use Pivot Points
input bool     UseMarketStructure = true;               // Use Market Structure
input bool     EnableLogging = true;                    // Enable Detailed Logging
input int      TechnicalLookback = 200;                 // Technical Lookback Bars

//--- Dashboard Parameters
input group "=== DASHBOARD SETTINGS ==="
input bool     ShowDashboard = true;                    // Show Dashboard
input int      DashboardX = 20;                         // Dashboard X Position
input int      DashboardY = 30;                         // Dashboard Y Position
input color    DashboardColor = clrWhiteSmoke;          // Dashboard Text Color
input color    ProfitColor = clrLime;                   // Profit Color
input color    LossColor = clrRed;                      // Loss Color
input int      UpdateFrequency = 1;                     // Update Frequency (seconds)

//--- Enhanced Display Settings
input group "=== ENHANCED DISPLAY SETTINGS ==="
input int      MaxTradesDisplay = 10;                   // Maximum Trades to Display
input bool     GroupBySource = true;                    // Group Trades by Source
input bool     ShowCorrelation = true;                  // Show Position Correlation
input color    InternalTradeColor = clrAqua;            // Internal Trade Color
input color    ExternalTradeColor = clrOrange;          // External Trade Color
input color    WarningColor = clrYellow;                // Warning Color

//--- Reporting Options
input group "=== REPORTING OPTIONS ==="
input bool     GenerateReports = true;                  // Generate Periodic Reports
input bool     ExportCSV = true;                        // Export Reports to CSV
input bool     DetectEAsOnStartup = true;               // Detect All EAs on Startup
input bool     AutoDetectSymbols = true;                // Auto-Detect Traded Symbols
input bool     DebugMode = false;                       // Enable Debug Mode

//+------------------------------------------------------------------+
//| GLOBAL OBJECTS                                                   |
//+------------------------------------------------------------------+

//--- Module instances
CRiskManager        *RiskMgr;
CTradeManager       *TradeMgr;
CEntrySystem        *EntrySys;
CTechnicalAnalysis  *TechAnalysis;
CDashboardEnhanced  *Dashboard;
CUtilities          *Utils;
CMultiTradeReporter *Reporter;

//--- System state
SystemState         g_SystemState;
PerformanceMetrics  g_Performance;
MarketConditions    g_MarketConditions;

//--- Trade tracking
ManagedTrade        g_ManagedTrades[];
int                 g_TotalTrades = 0;

//--- Multi-symbol monitoring
string              g_MonitoredSymbols[];
int                 g_SymbolCount = 0;

//--- Timing variables
datetime            g_LastUpdateTime = 0;
datetime            g_LastTradeTime = 0;
datetime            g_LastReportTime = 0;
datetime            g_LastSymbolScan = 0;
datetime            g_LastDiagnostic = 0;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
   //--- Initialize system state
   g_SystemState.is_active = SystemEnabled;
   g_SystemState.magic_number = TradingMagic;
   g_SystemState.start_balance = AccountInfoDouble(ACCOUNT_BALANCE);
   g_SystemState.peak_balance = g_SystemState.start_balance;
   g_SystemState.session_start = TimeCurrent();
   
   //--- Create module instances
   RiskMgr = new CRiskManager();
   TradeMgr = new CTradeManager();
   EntrySys = new CEntrySystem();
   TechAnalysis = new CTechnicalAnalysis();
   Dashboard = new CDashboardEnhanced();
   Utils = new CUtilities();
   Reporter = new CMultiTradeReporter();
   
   //--- Initialize modules
   if(!InitializeModules())
   {
      Print("Failed to initialize modules");
      return(INIT_FAILED);
   }
   
   //--- Wait for indicators to be ready
   if(MQLInfoInteger(MQL_TESTER))
   {
      Print("Backtest mode: Waiting for indicators to initialize...");
      
      int required_bars = MathMax(200, TechnicalLookback);
      if(Bars(_Symbol, PERIOD_CURRENT) < required_bars)
      {
         Print("Insufficient bars for indicator calculation. Need ", required_bars, 
               ", have ", Bars(_Symbol, PERIOD_CURRENT));
         return(INIT_FAILED);
      }
      
      double test_atr = (*TechAnalysis).GetATR(14);
      if(test_atr <= 0)
      {
         Print("ATR indicator not ready. Please ensure sufficient historical data.");
         return(INIT_FAILED);
      }
      
      Print("Indicators initialized successfully. ATR: ", test_atr);
   }
   
   //--- Initialize performance metrics
   ZeroMemory(g_Performance);
   
   //--- Initialize managed trades array
   ArrayResize(g_ManagedTrades, 0);
   ArraySetAsSeries(g_ManagedTrades, false);
   
   //--- Initialize multi-symbol monitoring
   if(ManageExternalTrades)
   {
      InitializeSymbolMonitoring();
      
      //--- Initial detection
      if(DetectEAsOnStartup)
      {
         DetectAllEAs();
      }
      
      //--- Initial external trade scan
      Print("Performing initial external trade scan...");
      CheckForNewExternalTradesEnhanced();
      
      //--- Run diagnostic if in debug mode
      if(DebugMode)
      {
         RunExternalTradeDiagnostics();
      }
   }
   
   //--- Load existing positions
   LoadExistingPositions();
   
   //--- Create dashboard
   if(ShowDashboard)
   {
      (*Dashboard).Create(DashboardX, DashboardY, DashboardColor, ProfitColor, LossColor);
      (*Dashboard).Update(g_Performance, g_ManagedTrades, g_MarketConditions);
   }
   
   //--- Initialize reporter
   if(Reporter != NULL && GenerateReports)
   {
      (*Reporter).Initialize("Reports");
   }
   
   //--- Set timer for periodic updates
   EventSetTimer(UpdateFrequency);
   
   //--- Log initialization
   (*Utils).Log(LOG_INFO, StringFormat("Risk Management Overlay v7.1 initialized. Balance: %.2f", 
                                      g_SystemState.start_balance));
   
   return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   //--- Kill timer
   EventKillTimer();
   
   //--- Save final report
   if(Utils != NULL && GenerateReports)
      (*Utils).GenerateReport(g_Performance, g_ManagedTrades);
   
   //--- Cleanup modules
   if(Dashboard != NULL && ShowDashboard)
      (*Dashboard).Destroy();
      
   //--- Delete module instances
   delete Reporter;
   delete RiskMgr;
   delete TradeMgr;
   delete EntrySys;
   delete TechAnalysis;
   delete Dashboard;
   delete Utils;
   
   //--- Log shutdown
   Print("Risk Management Overlay shutdown: ", (*Utils).GetUninitReasonText(reason));
}

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
   //--- Check if system is enabled
   if(!g_SystemState.is_active || !SystemEnabled)
      return;
      
   //--- Check terminal connection
   if(!TerminalInfoInteger(TERMINAL_CONNECTED))
      return;
      
   //--- Check terminal connection and auto trading
   if(Utils != NULL)
   {
      if(!(*Utils).CheckTerminalConnection())
         return;
         
      if(!(*Utils).CheckAutoTrading())
         return;
   }
      
   //--- Update market conditions
   UpdateMarketConditions();
   
   //--- Process existing trades
   ProcessManagedTrades();
   
   //--- Check for new external trades (enhanced multi-symbol)
   if(ManageExternalTrades)
   {
      CheckForNewExternalTradesEnhanced();
   }
   
   //--- Check entry signals (if enabled)
   if(EntryMode != ENTRY_DISABLED)
      CheckEntrySignals();
   
   //--- Update dashboard
   if(ShowDashboard && TimeCurrent() - g_LastUpdateTime >= UpdateFrequency)
   {
      (*Dashboard).Update(g_Performance, g_ManagedTrades, g_MarketConditions);
      g_LastUpdateTime = TimeCurrent();
   }
   
   //--- Periodic tasks
   PerformPeriodicTasks();
   
   //--- Debug output if enabled
   if(DebugMode)
   {
      static datetime last_debug = 0;
      if(TimeCurrent() - last_debug > 2)
      {
         string debug = StringFormat("DEBUG: Pos=%d Array=%d Ext=%d", 
                                    PositionsTotal(), 
                                    ArraySize(g_ManagedTrades),
                                    CountExternalTrades());
         Comment(debug);
         last_debug = TimeCurrent();
      }
   }
}

//+------------------------------------------------------------------+
//| Timer function for periodic updates                              |
//+------------------------------------------------------------------+
void OnTimer()
{
   //--- Update dashboard
   if(ShowDashboard)
   {
      (*Dashboard).Update(g_Performance, g_ManagedTrades, g_MarketConditions);
   }
   
   //--- Monitor positions
   if(DebugMode)
   {
      MonitorPositions();
   }
   
   //--- Periodic EA detection
   static datetime last_ea_detect = 0;
   if(ManageExternalTrades && TimeCurrent() - last_ea_detect > 300) // Every 5 minutes
   {
      if(AutoDetectSymbols)
      {
         DetectTradedSymbols();
      }
      last_ea_detect = TimeCurrent();
   }
}

//+------------------------------------------------------------------+
//| Initialize symbol monitoring list                                 |
//+------------------------------------------------------------------+
void InitializeSymbolMonitoring()
{
   if(AutoDetectSymbols)
   {
      // Auto-detect all symbols with open positions
      DetectTradedSymbols();
   }
   else
   {
      // Manual symbol list - customize as needed
      g_SymbolCount = 10;
      ArrayResize(g_MonitoredSymbols, g_SymbolCount);
      g_MonitoredSymbols[0] = "EURUSD";
      g_MonitoredSymbols[1] = "GBPUSD";
      g_MonitoredSymbols[2] = "USDJPY";
      g_MonitoredSymbols[3] = "AUDUSD";
      g_MonitoredSymbols[4] = "USDCAD";
      g_MonitoredSymbols[5] = "NZDUSD";
      g_MonitoredSymbols[6] = "USDCHF";
      g_MonitoredSymbols[7] = "EURJPY";
      g_MonitoredSymbols[8] = "GBPJPY";
      g_MonitoredSymbols[9] = "GOLD";
   }
   
   Print("Symbol Monitoring initialized with ", g_SymbolCount, " symbols");
}

//+------------------------------------------------------------------+
//| Auto-detect all symbols with positions                           |
//+------------------------------------------------------------------+
void DetectTradedSymbols()
{
   // Clear existing array
   ArrayFree(g_MonitoredSymbols);
   g_SymbolCount = 0;
   
   // Temporary array to collect unique symbols
   string temp_symbols[];
   int temp_count = 0;
   
   // Scan all positions
   int total_positions = PositionsTotal();
   for(int i = 0; i < total_positions; i++)
   {
      ulong ticket = PositionGetTicket(i);
      if(PositionSelectByTicket(ticket))
      {
         string symbol = PositionGetString(POSITION_SYMBOL);
         
         // Check if symbol already in list
         bool found = false;
         for(int j = 0; j < temp_count; j++)
         {
            if(temp_symbols[j] == symbol)
            {
               found = true;
               break;
            }
         }
         
         // Add new symbol
         if(!found)
         {
            ArrayResize(temp_symbols, temp_count + 1);
            temp_symbols[temp_count] = symbol;
            temp_count++;
         }
      }
   }
   
   // Also add current chart symbol if not already included
   bool current_found = false;
   for(int i = 0; i < temp_count; i++)
   {
      if(temp_symbols[i] == _Symbol)
      {
         current_found = true;
         break;
      }
   }
   
   if(!current_found)
   {
      ArrayResize(temp_symbols, temp_count + 1);
      temp_symbols[temp_count] = _Symbol;
      temp_count++;
   }
   
   // Copy to global array
   g_SymbolCount = temp_count;
   ArrayResize(g_MonitoredSymbols, g_SymbolCount);
   for(int i = 0; i < g_SymbolCount; i++)
   {
      g_MonitoredSymbols[i] = temp_symbols[i];
   }
   
   // Log detected symbols
   if(g_SymbolCount > 0)
   {
      string symbol_list = "Detected symbols: ";
      for(int i = 0; i < g_SymbolCount; i++)
      {
         symbol_list += g_MonitoredSymbols[i];
         if(i < g_SymbolCount - 1) symbol_list += ", ";
      }
      (*Utils).Log(LOG_INFO, symbol_list);
   }
}

//+------------------------------------------------------------------+
//| Enhanced multi-symbol external trade detection                   |
//+------------------------------------------------------------------+
void CheckForNewExternalTradesEnhanced()
{
   static datetime last_symbol_update = 0;
   
   // Update symbol list periodically (every 60 seconds)
   if(AutoDetectSymbols && TimeCurrent() - last_symbol_update > 60)
   {
      DetectTradedSymbols();
      last_symbol_update = TimeCurrent();
   }
   
   // Scan all positions
   int total_positions = PositionsTotal();
   int external_trades_found = 0;
   int trades_added = 0;
   
   for(int i = 0; i < total_positions; i++)
   {
      ulong ticket = PositionGetTicket(i);
      if(!ticket) continue;
      
      if(PositionSelectByTicket(ticket))
      {
         // Get position details
         string symbol = PositionGetString(POSITION_SYMBOL);
         ulong magic = PositionGetInteger(POSITION_MAGIC);
         
         // Skip our own trades
         if(magic == TradingMagic)
         {
            continue;
         }
         
         // Check if already managed
         if(IsTradeManaged(ticket))
         {
            continue;
         }
         
         // Apply magic number filter
         if(MagicNumberFilter != 0 && magic != MagicNumberFilter)
         {
            continue;
         }
         
         external_trades_found++;
         
         // Create managed trade entry
         ManagedTrade trade;
         if(CreateManagedTradeEnhanced(trade, ticket, symbol))
         {
            // Mark as external trade
            trade.is_external = true;
            trade.entry_reason = "External: " + GetEANameFromMagic(magic);
            
            // Apply risk rules if configured
            if(ForceRiskRules)
            {
               (*Utils).Log(LOG_INFO, StringFormat("Applying risk rules to external trade #%d on %s", 
                                                  ticket, symbol));
               (*RiskMgr).EnforceRiskRules(trade, DefaultExternalRisk, CloseExcessiveRisk);
            }
            
            // Add to managed trades array
            if(AddManagedTrade(trade))
            {
               trades_added++;
               (*Utils).Log(LOG_INFO, StringFormat("Added external trade #%d (%s %.2f lots) from %s to management", 
                                                  ticket, symbol, trade.volume, GetEANameFromMagic(magic)));
               
               // Apply default stops if needed
               if((trade.sl == 0 && ForceStopLoss) || (trade.tp == 0 && ForceTakeProfit))
               {
                  (*Utils).Log(LOG_INFO, "Applying default stops to external trade");
                  // Get ATR for the specific symbol
                  double symbol_atr = GetSymbolATR(symbol);
                  (*TradeMgr).ApplyDefaultStops(trade, symbol_atr);
               }
            }
         }
      }
   }
   
   if(external_trades_found > 0 || trades_added > 0)
   {
      (*Utils).Log(LOG_DEBUG, StringFormat("External trade scan complete: Found %d, Added %d new trades", 
                                          external_trades_found, trades_added));
   }
}

//+------------------------------------------------------------------+
//| Create managed trade with multi-symbol support                   |
//+------------------------------------------------------------------+
bool CreateManagedTradeEnhanced(ManagedTrade &trade, ulong ticket, string symbol)
{
   // Ensure we're working with the correct position
   if(!PositionSelectByTicket(ticket))
   {
      (*Utils).Log(LOG_ERROR, StringFormat("Failed to select position #%d", ticket));
      return false;
   }
   
   // Verify symbol matches
   if(PositionGetString(POSITION_SYMBOL) != symbol)
   {
      (*Utils).Log(LOG_ERROR, StringFormat("Symbol mismatch for position #%d", ticket));
      return false;
   }
   
   // Fill trade structure
   trade.ticket = ticket;
   trade.symbol = symbol;
   trade.magic = PositionGetInteger(POSITION_MAGIC);
   trade.type = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
   trade.volume = PositionGetDouble(POSITION_VOLUME);
   trade.current_volume = trade.volume;
   trade.open_price = PositionGetDouble(POSITION_PRICE_OPEN);
   trade.open_time = (datetime)PositionGetInteger(POSITION_TIME);
   trade.sl = PositionGetDouble(POSITION_SL);
   trade.tp = PositionGetDouble(POSITION_TP);
   trade.profit = PositionGetDouble(POSITION_PROFIT);
   trade.swap = PositionGetDouble(POSITION_SWAP);
   trade.comment = PositionGetString(POSITION_COMMENT);
   
   // Get commission from deals
   trade.commission = (*Utils).CalculatePositionCommission(ticket);
   
   // Calculate risk metrics for the specific symbol
   if(trade.sl > 0)
   {
      double tick_value = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_VALUE);
      double tick_size = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_SIZE);
      double stop_distance;
      
      if(trade.type == POSITION_TYPE_BUY)
         stop_distance = trade.open_price - trade.sl;
      else
         stop_distance = trade.sl - trade.open_price;
         
      if(stop_distance > 0 && tick_size > 0)
      {
         double potential_loss = (stop_distance / tick_size) * tick_value * trade.volume;
         trade.risk_amount = potential_loss;
         trade.risk_percent = (potential_loss / AccountInfoDouble(ACCOUNT_BALANCE)) * 100;
      }
   }
   else
   {
      // No stop loss - use default risk calculation
      trade.risk_amount = 0;
      trade.risk_percent = DefaultExternalRisk;
   }
   
   // Calculate current metrics
   double current_price = (trade.type == POSITION_TYPE_BUY) ? 
                         SymbolInfoDouble(symbol, SYMBOL_BID) : 
                         SymbolInfoDouble(symbol, SYMBOL_ASK);
   
   // Calculate R-multiple
   if(trade.risk_amount > 0)
   {
      double current_pl = trade.profit + trade.swap + trade.commission;
      trade.r_multiple = current_pl / trade.risk_amount;
   }
   else
   {
      trade.r_multiple = 0;
   }
   
   // Calculate MAE/MFE (simplified for initial creation)
   trade.mae = 0;
   trade.mfe = 0;
   
   // Management flags
   trade.is_managed = true;
   trade.is_external = true;
   trade.be_activated = false;
   trade.trailing_activated = false;
   trade.partial_count = 0;
   
   // Time tracking
   trade.bars_in_trade = 0;
   trade.management_start = TimeCurrent();
   
   return true;
}

//+------------------------------------------------------------------+
//| Get ATR for specific symbol                                      |
//+------------------------------------------------------------------+
double GetSymbolATR(string symbol, int period = 14)
{
   int atr_handle = iATR(symbol, PERIOD_CURRENT, period);
   if(atr_handle == INVALID_HANDLE)
   {
      (*Utils).Log(LOG_ERROR, "Failed to create ATR handle for " + symbol);
      return 50 * SymbolInfoDouble(symbol, SYMBOL_POINT); // Default fallback
   }
   
   double atr_buffer[1];
   if(CopyBuffer(atr_handle, 0, 0, 1, atr_buffer) > 0 && atr_buffer[0] > 0)
   {
      IndicatorRelease(atr_handle);
      return atr_buffer[0];
   }
   
   IndicatorRelease(atr_handle);
   
   // Fallback calculation
   double sum = 0;
   for(int i = 1; i <= period; i++)
   {
      double high = iHigh(symbol, PERIOD_CURRENT, i);
      double low = iLow(symbol, PERIOD_CURRENT, i);
      double close_prev = iClose(symbol, PERIOD_CURRENT, i + 1);
      
      if(high > 0 && low > 0 && close_prev > 0)
      {
         double tr = MathMax(high - low, MathMax(MathAbs(high - close_prev), MathAbs(low - close_prev)));
         sum += tr;
      }
   }
   
   return (sum > 0) ? sum / period : 50 * SymbolInfoDouble(symbol, SYMBOL_POINT);
}

//+------------------------------------------------------------------+
//| Count external trades in array                                   |
//+------------------------------------------------------------------+
int CountExternalTrades()
{
   int count = 0;
   for(int i = 0; i < ArraySize(g_ManagedTrades); i++)
   {
      if(g_ManagedTrades[i].is_external)
         count++;
   }
   return count;
}

//+------------------------------------------------------------------+
//| Monitor positions (debug function)                               |
//+------------------------------------------------------------------+
void MonitorPositions()
{
   static datetime last_check = 0;
   static int last_total = -1;
   
   // Check every 5 seconds
   if(TimeCurrent() - last_check < 5) return;
   last_check = TimeCurrent();
   
   int total = PositionsTotal();
   
   // Only print if changed
   if(total != last_total)
   {
      last_total = total;
      
      string summary = StringFormat("\n[POSITION MONITOR] Total: %d | Managed Array: %d | ",
                                   total, ArraySize(g_ManagedTrades));
      
      // Count by type
      int own = 0, ext = 0, managed_ext = 0;
      
      for(int i = 0; i < total; i++)
      {
         if(PositionSelectByTicket(PositionGetTicket(i)))
         {
            ulong magic = PositionGetInteger(POSITION_MAGIC);
            if(magic == TradingMagic)
               own++;
            else
            {
               ext++;
               if(IsTradeManaged(PositionGetTicket(i)))
                  managed_ext++;
            }
         }
      }
      
      summary += StringFormat("Own: %d | External: %d (Managed: %d)", 
                             own, ext, managed_ext);
      
      Print(summary);
      
      // If external trades exist but aren't managed, run diagnostic
      if(ext > 0 && managed_ext == 0 && ManageExternalTrades)
      {
         Print("⚠️ External trades not being managed! Running diagnostic...");
         RunExternalTradeDiagnostics();
      }
   }
}

//+------------------------------------------------------------------+
//| Run external trade diagnostics                                   |
//+------------------------------------------------------------------+
void RunExternalTradeDiagnostics()
{
   Print("\n========== EXTERNAL TRADE DETECTION DIAGNOSTICS ==========");
   Print("Timestamp: ", TimeToString(TimeCurrent()));
   Print("Running from: ", _Symbol, " ", EnumToString((ENUM_TIMEFRAMES)_Period));
   
   //--- 1. Check EA Settings
   Print("\n[1] EA CONFIGURATION CHECK:");
   Print("   SystemEnabled: ", SystemEnabled ? "YES" : "NO");
   Print("   ManageExternalTrades: ", ManageExternalTrades ? "ENABLED" : "DISABLED");
   Print("   MagicNumberFilter: ", MagicNumberFilter, (MagicNumberFilter == 0) ? " (All external trades)" : " (Specific magic only)");
   Print("   TradingMagic (Own): ", TradingMagic);
   Print("   ForceRiskRules: ", ForceRiskRules ? "YES" : "NO");
   Print("   DefaultExternalRisk: ", DoubleToString(DefaultExternalRisk, 2), "%");
   Print("   AutoDetectSymbols: ", AutoDetectSymbols ? "YES" : "NO");
   
   //--- 2. Scan all open positions
   Print("\n[2] POSITION SCAN:");
   int total_positions = PositionsTotal();
   Print("   Total positions in terminal: ", total_positions);
   
   if(total_positions == 0)
   {
      Print("   ⚠️ NO OPEN POSITIONS FOUND!");
      Print("   Make sure other EAs have open trades.");
      return;
   }
   
   //--- Categorize positions
   int own_trades = 0;
   int external_trades = 0;
   int filtered_trades = 0;
   int managed_trades = 0;
   
   Print("\n[3] POSITION DETAILS:");
   for(int i = 0; i < total_positions; i++)
   {
      ulong ticket = PositionGetTicket(i);
      if(ticket == 0) 
      {
         Print("   Error getting ticket at index ", i);
         continue;
      }
      
      if(!PositionSelectByTicket(ticket))
      {
         Print("   Error selecting position ", ticket);
         continue;
      }
      
      string symbol = PositionGetString(POSITION_SYMBOL);
      ulong magic = PositionGetInteger(POSITION_MAGIC);
      double volume = PositionGetDouble(POSITION_VOLUME);
      string type = (PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY) ? "BUY" : "SELL";
      bool is_managed = IsTradeManaged(ticket);
      
      Print("\n   Position #", ticket, ":");
      Print("   - Symbol: ", symbol);
      Print("   - Type: ", type);
      Print("   - Volume: ", DoubleToString(volume, 2));
      Print("   - Magic: ", magic, " (", GetEANameFromMagic(magic), ")");
      
      // Determine status
      if(magic == TradingMagic)
      {
         own_trades++;
         Print("   - Status: OWN TRADE (will skip)");
      }
      else if(MagicNumberFilter != 0 && magic != MagicNumberFilter)
      {
         filtered_trades++;
         Print("   - Status: FILTERED OUT (magic doesn't match filter ", MagicNumberFilter, ")");
      }
      else if(is_managed)
      {
         managed_trades++;
         Print("   - Status: ALREADY MANAGED ✓");
      }
      else
      {
         external_trades++;
         Print("   - Status: EXTERNAL TRADE - SHOULD BE ADDED! ⚠️");
         
         if(!ManageExternalTrades)
         {
            Print("     → ISSUE: ManageExternalTrades is DISABLED!");
         }
      }
   }
   
   //--- 4. Summary
   Print("\n[4] SUMMARY:");
   Print("   Own trades: ", own_trades);
   Print("   External trades (eligible): ", external_trades);
   Print("   Filtered out: ", filtered_trades);
   Print("   Already managed: ", managed_trades);
   
   //--- 5. Check managed trades array
   Print("\n[5] MANAGED TRADES ARRAY:");
   int array_size = ArraySize(g_ManagedTrades);
   Print("   Size of g_ManagedTrades: ", array_size);
   
   if(array_size > 0)
   {
      int internal_count = 0;
      int external_count = 0;
      
      for(int i = 0; i < array_size; i++)
      {
         if(g_ManagedTrades[i].is_external)
            external_count++;
         else
            internal_count++;
            
         Print("   Trade[", i, "]: #", g_ManagedTrades[i].ticket, 
               " ", g_ManagedTrades[i].symbol,
               " Magic: ", g_ManagedTrades[i].magic,
               " External: ", g_ManagedTrades[i].is_external ? "YES" : "NO",
               " Valid: ", (g_ManagedTrades[i].ticket > 0) ? "YES" : "NO");
      }
      
      Print("   Internal trades in array: ", internal_count);
      Print("   External trades in array: ", external_count);
   }
   else
   {
      Print("   ⚠️ Managed trades array is EMPTY!");
   }
   
   //--- 6. Symbol monitoring
   Print("\n[6] SYMBOL MONITORING:");
   Print("   Monitored symbols: ", g_SymbolCount);
   for(int i = 0; i < g_SymbolCount; i++)
   {
      Print("   - ", g_MonitoredSymbols[i]);
   }
   
   //--- 7. Dashboard check
   Print("\n[7] DASHBOARD STATUS:");
   Print("   ShowDashboard: ", ShowDashboard ? "ENABLED" : "DISABLED");
   Print("   Dashboard pointer: ", (Dashboard != NULL) ? "VALID" : "NULL");
   
   //--- 8. Recommendations
   Print("\n[8] DIAGNOSTIC RECOMMENDATIONS:");
   
   if(!SystemEnabled)
   {
      Print("   ❌ CRITICAL: SystemEnabled is FALSE - EA is disabled!");
   }
   
   if(!ManageExternalTrades)
   {
      Print("   ❌ CRITICAL: Enable ManageExternalTrades to detect external trades!");
   }
   
   if(external_trades > 0 && external_count == 0)
   {
      Print("   ❌ ISSUE: External trades exist but none in managed array!");
      Print("   → Verify CheckForNewExternalTradesEnhanced() is being called in OnTick()");
      Print("   → Check if AddManagedTrade() function is working correctly");
      Print("   → Ensure CreateManagedTradeEnhanced() is creating valid trade objects");
   }
   
   if(MagicNumberFilter != 0 && filtered_trades > 0)
   {
      Print("   ⚠️ WARNING: ", filtered_trades, " trades filtered out by MagicNumberFilter");
      Print("   → Set MagicNumberFilter = 0 to manage ALL external trades");
   }
   
   if(array_size == 0 && (own_trades > 0 || external_trades > 0))
   {
      Print("   ❌ CRITICAL: Managed trades array is empty but trades exist!");
      Print("   → Check array initialization in OnInit()");
      Print("   → Verify ProcessManagedTrades() isn't clearing the array");
   }
   
   Print("\n========== END OF DIAGNOSTICS ==========\n");
}

//+------------------------------------------------------------------+
//| Add managed trade to array with validation                       |
//+------------------------------------------------------------------+
bool AddManagedTrade(ManagedTrade &trade)
{
   // Validate trade
   if(trade.ticket == 0)
   {
      (*Utils).Log(LOG_ERROR, "Cannot add trade with ticket 0");
      return false;
   }
   
   // Check if already exists
   if(IsTradeManaged(trade.ticket))
   {
      (*Utils).Log(LOG_WARNING, StringFormat("Trade #%d already managed", trade.ticket));
      return false;
   }
   
   // Add to array
   int size = ArraySize(g_ManagedTrades);
   if(ArrayResize(g_ManagedTrades, size + 1) < 0)
   {
      (*Utils).Log(LOG_ERROR, "Failed to resize managed trades array");
      return false;
   }
   
   g_ManagedTrades[size] = trade;
   g_TotalTrades++;
   
   (*Utils).Log(LOG_DEBUG, StringFormat("Added trade #%d to position %d in array", 
                                       trade.ticket, size));
   
   return true;
}

//+------------------------------------------------------------------+
//| Create managed trade structure (for compatibility)               |
//+------------------------------------------------------------------+
bool CreateManagedTrade(ManagedTrade &trade, ulong ticket)
{
   if(!PositionSelectByTicket(ticket))
      return false;
      
   string symbol = PositionGetString(POSITION_SYMBOL);
   return CreateManagedTradeEnhanced(trade, ticket, symbol);
}

//+------------------------------------------------------------------+
//| Initialize all modules                                           |
//+------------------------------------------------------------------+
bool InitializeModules()
{
   //--- Initialize Risk Manager
   RiskManagerConfig riskConfig;
   riskConfig.sizing_mode = SizingMode;
   riskConfig.risk_percent = RiskPercent;
   riskConfig.max_risk_percent = MaxRiskPercent;
   riskConfig.max_daily_dd = MaxDailyDrawdown;
   riskConfig.max_exposure = MaxTotalExposure;
   riskConfig.use_kelly = UseKellyCriterion;
   riskConfig.kelly_fraction = KellyFraction;
   riskConfig.min_lot_size = MinLotSize;
   riskConfig.max_lot_size = MaxLotSize;
   
   if(!(*RiskMgr).Initialize(riskConfig))
      return false;
      
   //--- Initialize Trade Manager
   TradeManagerConfig tradeConfig;
   tradeConfig.tp_mode = TPMode;
   tradeConfig.sl_mode = SLMode;
   tradeConfig.enable_breakeven = EnableBreakeven;
   tradeConfig.breakeven_trigger = BreakevenTrigger;
   tradeConfig.enable_trailing = EnableTrailing;
   tradeConfig.trailing_start = TrailingStart;
   tradeConfig.enable_partial = EnablePartialClose;
   tradeConfig.partial_levels = PartialLevels;
   tradeConfig.force_sl = ForceStopLoss;
   tradeConfig.force_tp = ForceTakeProfit;
   tradeConfig.override_sl = OverrideExternalSL;
   tradeConfig.override_tp = OverrideExternalTP;
   
   if(!(*TradeMgr).Initialize(tradeConfig, TradingMagic))
      return false;
      
   //--- Initialize Entry System
   EntrySystemConfig entryConfig;
   entryConfig.entry_mode = EntryMode;
   entryConfig.max_positions = MaxPositions;
   entryConfig.min_time_between = MinTimeBetweenTrades;
   entryConfig.allow_multiple = EnableMultipleEntries;
   
   if(!(*EntrySys).Initialize(entryConfig))
      return false;
      
   //--- Initialize Technical Analysis
   TechnicalConfig techConfig;
   techConfig.use_sr = UseSupportResistance;
   techConfig.use_fib = UseFibonacci;
   techConfig.use_pivot = UsePivotPoints;
   techConfig.use_structure = UseMarketStructure;
   techConfig.lookback = TechnicalLookback;
   
   if(!(*TechAnalysis).Initialize(techConfig))
      return false;
      
   //--- Initialize Utilities
   if(!(*Utils).Initialize(LogLevel))
      return false;
      
   return true;
}

//+------------------------------------------------------------------+
//| Load existing positions into management system                   |
//+------------------------------------------------------------------+
void LoadExistingPositions()
{
   int total = PositionsTotal();
   int loaded = 0;
   
   for(int i = 0; i < total; i++)
   {
      ulong ticket = PositionGetTicket(i);
      if(!PositionSelectByTicket(ticket))
         continue;
         
      string symbol = PositionGetString(POSITION_SYMBOL);
      ulong magic = PositionGetInteger(POSITION_MAGIC);
      bool should_manage = false;
      
      //--- Check if we should manage this position
      if(magic == TradingMagic)
      {
         should_manage = true;
      }
      else if(ManageExternalTrades && (MagicNumberFilter == 0 || magic == MagicNumberFilter))
      {
         should_manage = true;
      }
         
      if(should_manage && !IsTradeManaged(ticket))
      {
         ManagedTrade trade;
         if(CreateManagedTradeEnhanced(trade, ticket, symbol))
         {
            if(magic != TradingMagic)
               trade.is_external = true;
               
            if(AddManagedTrade(trade))
            {
               loaded++;
               (*Utils).Log(LOG_INFO, StringFormat("Loaded position #%d (%s) into management", 
                                                  ticket, symbol));
            }
         }
      }
   }
   
   if(loaded > 0)
   {
      (*Utils).Log(LOG_INFO, StringFormat("Loaded %d existing positions", loaded));
   }
}

//+------------------------------------------------------------------+
//| Update market conditions                                          |
//+------------------------------------------------------------------+
void UpdateMarketConditions()
{
   // Get fresh market analysis
   g_MarketConditions = (*TechAnalysis).AnalyzeMarket();
   
   // Additional validation and fallback
   if(g_MarketConditions.volatility <= 0)
   {
      Print("UpdateMarketConditions: Invalid volatility from TechAnalysis, calculating fallback");
      
      // Direct ATR calculation
      double atr = (*TechAnalysis).GetATR(14);
      if(atr > 0)
      {
         g_MarketConditions.volatility = atr;
         Print("UpdateMarketConditions: Set volatility to ", atr);
      }
      else
      {
         // Emergency fallback
         double price = SymbolInfoDouble(_Symbol, SYMBOL_BID);
         g_MarketConditions.volatility = price * 0.001; // 0.1% of price
         Print("UpdateMarketConditions: Using emergency volatility: ", g_MarketConditions.volatility);
      }
   }
   
   g_MarketConditions.spread = (double)SymbolInfoInteger(_Symbol, SYMBOL_SPREAD);
   
   //--- Update risk manager with market conditions
   (*RiskMgr).UpdateMarketConditions(g_MarketConditions);
}

//+------------------------------------------------------------------+
//| Process all managed trades                                       |
//+------------------------------------------------------------------+
void ProcessManagedTrades()
{
   for(int i = ArraySize(g_ManagedTrades) - 1; i >= 0; i--)
   {
      //--- Check if position still exists
      if(!PositionSelectByTicket(g_ManagedTrades[i].ticket))
      {
         //--- Position closed, update performance
         UpdatePerformanceMetrics(g_ManagedTrades[i]);
         
         //--- Save to history if external
         if(g_ManagedTrades[i].is_external)
         {
            (*Utils).SaveTradeHistory(g_ManagedTrades[i]);
         }
         
         RemoveManagedTrade(i);
         continue;
      }
      
      //--- Update trade information
      UpdateTradeInfo(g_ManagedTrades[i]);
      
      //--- Apply risk management
      (*RiskMgr).ValidateAndAdjustRisk(g_ManagedTrades[i]);
      
      //--- Apply trade management
      (*TradeMgr).ManageTrade(g_ManagedTrades[i], g_MarketConditions);
   }
}

//+------------------------------------------------------------------+
//| Check entry signals                                              |
//+------------------------------------------------------------------+
void CheckEntrySignals()
{
   //--- Check position limits
   if(ArraySize(g_ManagedTrades) >= MaxPositions)
   {
      if(EnableLogging) 
         (*Utils).Log(LOG_DEBUG, "Max positions reached");
      return;
   }
      
   //--- Check time restriction
   if(TimeCurrent() - g_LastTradeTime < MinTimeBetweenTrades * 60)
   {
      if(EnableLogging) 
         (*Utils).Log(LOG_DEBUG, "Time restriction active");
      return;
   }
   
   //--- Ensure valid market conditions
   if(g_MarketConditions.volatility <= 0)
   {
      UpdateMarketConditions();
   }
   
   //--- Get entry signal
   EntrySignal signal = (*EntrySys).CheckSignal(g_MarketConditions);
   
   if(signal.signal_type != SIGNAL_NONE)
   {
      // Additional safety check
      if(signal.stop_loss_distance <= 0)
      {
         (*Utils).Log(LOG_ERROR, StringFormat("Zero stop distance detected! Signal: %s", 
                                            signal.comment));
         
         // Emergency fallback
         double emergency_stop = 50 * SymbolInfoDouble(_Symbol, SYMBOL_POINT);
         signal.stop_loss_distance = emergency_stop;
         signal.take_profit_distance = emergency_stop * 2;
         
         (*Utils).Log(LOG_WARNING, StringFormat("Applied emergency stop: %.5f", emergency_stop));
      }
      
      //--- Calculate position size
      double lotSize = (*RiskMgr).CalculatePositionSize(signal.stop_loss_distance);
      
      if(lotSize > 0 && (*RiskMgr).ValidateNewPosition(lotSize, signal.stop_loss_distance))
      {
         //--- Prepare trade request
         TradeRequest request;
         request.symbol = _Symbol;
         request.volume = lotSize;
         request.type = (signal.signal_type == SIGNAL_BUY) ? ORDER_TYPE_BUY : ORDER_TYPE_SELL;
         request.sl_distance = signal.stop_loss_distance;
         request.tp_distance = signal.take_profit_distance;
         request.comment = signal.comment;
         
         //--- Execute trade
         ulong ticket = (*TradeMgr).OpenPosition(request);
         
         if(ticket > 0)
         {
            g_LastTradeTime = TimeCurrent();
            
            //--- Add to managed trades
            ManagedTrade trade;
            if(CreateManagedTrade(trade, ticket))
            {
               trade.entry_reason = signal.comment;
               trade.entry_signal = signal;
               trade.is_external = false;
               
               if(AddManagedTrade(trade))
               {
                  (*Utils).Log(LOG_INFO, StringFormat("Opened %s position #%d, Lots: %.2f, Risk: %.2f%%", 
                                                     (signal.signal_type == SIGNAL_BUY) ? "BUY" : "SELL", 
                                                     ticket, lotSize, RiskPercent));
               }
            }
         }
      }
   }
}

//+------------------------------------------------------------------+
//| Perform periodic maintenance tasks                               |
//+------------------------------------------------------------------+
void PerformPeriodicTasks()
{
   //--- Daily reset check
   MqlDateTime current_time;
   TimeToStruct(TimeCurrent(), current_time);
   
   static int last_day = -1;
   if(current_time.day != last_day)
   {
      last_day = current_time.day;
      ResetDailyMetrics();
   }
   
   //--- Generate periodic reports
   if(GenerateReports && TimeCurrent() - g_LastReportTime > 3600) // Hourly
   {
      (*Utils).GenerateReport(g_Performance, g_ManagedTrades);
      
      if(Reporter != NULL)
      {
         (*Reporter).GenerateFullReport(g_ManagedTrades, g_Performance);
      }
      
      g_LastReportTime = TimeCurrent();
   }
   
   //--- Check for news events
   if((*Utils).IsNewsTime())
   {
      g_MarketConditions.news_event = true;
   }
}

//+------------------------------------------------------------------+
//| Remove trade from managed array                                  |
//+------------------------------------------------------------------+
void RemoveManagedTrade(int index)
{
   int size = ArraySize(g_ManagedTrades);
   if(index < 0 || index >= size)
      return;
      
   for(int i = index; i < size - 1; i++)
   {
      g_ManagedTrades[i] = g_ManagedTrades[i + 1];
   }
   
   ArrayResize(g_ManagedTrades, size - 1);
}

//+------------------------------------------------------------------+
//| Check if trade is already managed                                |
//+------------------------------------------------------------------+
bool IsTradeManaged(ulong ticket)
{
   for(int i = 0; i < ArraySize(g_ManagedTrades); i++)
   {
      if(g_ManagedTrades[i].ticket == ticket)
         return true;
   }
   return false;
}

//+------------------------------------------------------------------+
//| Update trade information                                         |
//+------------------------------------------------------------------+
void UpdateTradeInfo(ManagedTrade &trade)
{
   if(!PositionSelectByTicket(trade.ticket))
      return;
      
   trade.current_volume = PositionGetDouble(POSITION_VOLUME);
   trade.sl = PositionGetDouble(POSITION_SL);
   trade.tp = PositionGetDouble(POSITION_TP);
   trade.profit = PositionGetDouble(POSITION_PROFIT);
   trade.commission = (*Utils).CalculatePositionCommission(trade.ticket);
   trade.swap = PositionGetDouble(POSITION_SWAP);
   
   //--- Update max profit/drawdown
   double total_profit = trade.profit + trade.commission + trade.swap;
   if(total_profit > trade.max_profit)
      trade.max_profit = total_profit;
   if(total_profit < trade.max_drawdown)
      trade.max_drawdown = total_profit;
      
   //--- Update R-multiple
   if(trade.risk_amount > 0)
   {
      trade.r_multiple = total_profit / trade.risk_amount;
   }
}

//+------------------------------------------------------------------+
//| Update performance metrics                                       |
//+------------------------------------------------------------------+
void UpdatePerformanceMetrics(ManagedTrade &trade)
{
   double final_profit = trade.profit + trade.commission + trade.swap;
   
   //--- Update counts
   g_Performance.total_trades++;
   if(final_profit > 0)
   {
      g_Performance.winning_trades++;
      g_Performance.gross_profit += final_profit;
      g_Performance.consecutive_wins++;
      g_Performance.consecutive_losses = 0;
   }
   else
   {
      g_Performance.losing_trades++;
      g_Performance.gross_loss += MathAbs(final_profit);
      g_Performance.consecutive_losses++;
      g_Performance.consecutive_wins = 0;
   }
   
   //--- Update max consecutive
   if(g_Performance.consecutive_wins > g_Performance.max_consecutive_wins)
      g_Performance.max_consecutive_wins = g_Performance.consecutive_wins;
   if(g_Performance.consecutive_losses > g_Performance.max_consecutive_losses)
      g_Performance.max_consecutive_losses = g_Performance.consecutive_losses;
      
   //--- Update profit factor and win rate
   if(g_Performance.gross_loss > 0)
      g_Performance.profit_factor = g_Performance.gross_profit / g_Performance.gross_loss;
   else
      g_Performance.profit_factor = (g_Performance.gross_profit > 0) ? 999.99 : 0;
      
   g_Performance.win_rate = (g_Performance.total_trades > 0) ? 
                           (double)g_Performance.winning_trades / g_Performance.total_trades * 100 : 0;
                           
   //--- Update drawdown
   double current_balance = AccountInfoDouble(ACCOUNT_BALANCE);
   if(current_balance > g_SystemState.peak_balance)
      g_SystemState.peak_balance = current_balance;
      
   double drawdown = (g_SystemState.peak_balance - current_balance) / g_SystemState.peak_balance * 100;
   if(drawdown > g_Performance.max_drawdown_percent)
      g_Performance.max_drawdown_percent = drawdown;
      
   //--- Update net profit
   g_Performance.net_profit = g_Performance.gross_profit - g_Performance.gross_loss;
   
   //--- Update expectancy
   if(g_Performance.total_trades > 0)
      g_Performance.expectancy = g_Performance.net_profit / g_Performance.total_trades;
      
   //--- Update average win/loss
   if(g_Performance.winning_trades > 0)
      g_Performance.avg_win = g_Performance.gross_profit / g_Performance.winning_trades;
   if(g_Performance.losing_trades > 0)
      g_Performance.avg_loss = g_Performance.gross_loss / g_Performance.losing_trades;
      
   //--- Update daily metrics
   g_Performance.daily_trades++;
   g_Performance.daily_profit += final_profit;
}

//+------------------------------------------------------------------+
//| Reset daily metrics                                              |
//+------------------------------------------------------------------+
void ResetDailyMetrics()
{
   g_Performance.daily_profit = 0;
   g_Performance.daily_trades = 0;
   g_Performance.daily_volume = 0;
   
   (*Utils).Log(LOG_INFO, "Daily metrics reset");
}

//+------------------------------------------------------------------+
//| Trade transaction event                                          |
//+------------------------------------------------------------------+
void OnTradeTransaction(const MqlTradeTransaction& trans,
                        const MqlTradeRequest& request,
                        const MqlTradeResult& result)
{
   //--- Handle trade events
   if(trans.type == TRADE_TRANSACTION_DEAL_ADD)
   {
      if(trans.deal_type == DEAL_TYPE_BUY || trans.deal_type == DEAL_TYPE_SELL)
      {
         (*Utils).Log(LOG_DEBUG, StringFormat("New deal: #%d, Volume: %.2f", 
                                            trans.deal, trans.volume));
      }
   }
}

//+------------------------------------------------------------------+
//| Chart event handler                                              |
//+------------------------------------------------------------------+
void OnChartEvent(const int id,
                  const long &lparam,
                  const double &dparam,
                  const string &sparam)
{
   //--- Handle keyboard shortcuts for debugging
   if(id == CHARTEVENT_KEYDOWN)
   {
      if(lparam == 'D' || lparam == 'd') // D key
      {
         RunExternalTradeDiagnostics();
      }
      else if(lparam == 'R' || lparam == 'r') // R key
      {
         Print("Forcing external trade refresh...");
         CheckForNewExternalTradesEnhanced();
      }
      else if(lparam == 'T' || lparam == 't') // T key
      {
         (*Utils).GenerateReport(g_Performance, g_ManagedTrades);
      }
   }
}

//+------------------------------------------------------------------+
//| EA Detection and Monitoring Functions                            |
//+------------------------------------------------------------------+

struct EAInfo
{
   string symbol;
   long   magic_number;
   string ea_name;
   int    trade_count;
   double total_volume;
   double total_risk;
   double total_profit;
};

//+------------------------------------------------------------------+
//| Detect all EAs running on the account                            |
//+------------------------------------------------------------------+
void DetectAllEAs()
{
   Print("=== DETECTING ALL EXPERT ADVISORS ===");
   
   EAInfo detected_eas[];
   int ea_count = 0;
   
   // Scan all open positions
   int total_positions = PositionsTotal();
   
   for(int i = 0; i < total_positions; i++)
   {
      if(PositionSelectByTicket(PositionGetTicket(i)))
      {
         string symbol = PositionGetString(POSITION_SYMBOL);
         long magic = PositionGetInteger(POSITION_MAGIC);
         double volume = PositionGetDouble(POSITION_VOLUME);
         double profit = PositionGetDouble(POSITION_PROFIT);
         
         // Check if this magic number already recorded
         bool found = false;
         int index = -1;
         
         for(int j = 0; j < ea_count; j++)
         {
            if(detected_eas[j].magic_number == magic && 
               detected_eas[j].symbol == symbol)
            {
               found = true;
               index = j;
               break;
            }
         }
         
         // Add new EA or update existing
         if(!found)
         {
            ArrayResize(detected_eas, ea_count + 1);
            detected_eas[ea_count].symbol = symbol;
            detected_eas[ea_count].magic_number = magic;
            detected_eas[ea_count].ea_name = GetEANameFromMagic(magic);
            detected_eas[ea_count].trade_count = 1;
            detected_eas[ea_count].total_volume = volume;
            detected_eas[ea_count].total_profit = profit;
            detected_eas[ea_count].total_risk = CalculatePositionRisk(PositionGetTicket(i));
            ea_count++;
         }
         else
         {
            detected_eas[index].trade_count++;
            detected_eas[index].total_volume += volume;
            detected_eas[index].total_profit += profit;
            detected_eas[index].total_risk += CalculatePositionRisk(PositionGetTicket(i));
         }
      }
   }
   
   // Display results
   Print("\n╔════════════════════════════════════════════════════════╗");
   Print("║              DETECTED EXPERT ADVISORS                  ║");
   Print("╚════════════════════════════════════════════════════════╝");
   
   if(ea_count == 0)
   {
      Print("No active EA trades detected.");
   }
   else
   {
      // Sort by magic number
      for(int i = 0; i < ea_count - 1; i++)
      {
         for(int j = i + 1; j < ea_count; j++)
         {
            if(detected_eas[i].magic_number > detected_eas[j].magic_number)
            {
               EAInfo temp = detected_eas[i];
               detected_eas[i] = detected_eas[j];
               detected_eas[j] = temp;
            }
         }
      }
      
      // Display each EA
      for(int i = 0; i < ea_count; i++)
      {
         Print("\n┌─────────────────────────────────────────────────────────┐");
         Print("│ EA #", (i+1), ": ", detected_eas[i].ea_name, 
               " (Magic: ", detected_eas[i].magic_number, ")");
         Print("├─────────────────────────────────────────────────────────┤");
         Print("│ Symbol: ", detected_eas[i].symbol);
         Print("│ Active Trades: ", detected_eas[i].trade_count);
         Print("│ Total Volume: ", DoubleToString(detected_eas[i].total_volume, 2), " lots");
         Print("│ Total Risk: ", DoubleToString(detected_eas[i].total_risk, 2), "%");
         Print("│ Current P/L: $", DoubleToString(detected_eas[i].total_profit, 2));
         Print("└─────────────────────────────────────────────────────────┘");
      }
   }
   
   // Configuration suggestions
   Print("\n╔════════════════════════════════════════════════════════╗");
   Print("║           CONFIGURATION SUGGESTIONS                    ║");
   Print("╚════════════════════════════════════════════════════════╝");
   
   if(ea_count > 0)
   {
      Print("\nTo manage specific EAs, use these MagicNumberFilter values:");
      for(int i = 0; i < ea_count; i++)
      {
         if(detected_eas[i].magic_number != 0) // Skip manual trades
         {
            Print("- For ", detected_eas[i].ea_name, ": MagicNumberFilter = ", 
                  detected_eas[i].magic_number);
         }
      }
      Print("\nTo manage ALL external trades: MagicNumberFilter = 0");
   }
   
   // Risk warnings
   double total_risk = 0;
   for(int i = 0; i < ea_count; i++)
   {
      total_risk += detected_eas[i].total_risk;
   }
   
   if(total_risk > 5.0)
   {
      Print("\n⚠️ WARNING: Total risk across all EAs: ", 
            DoubleToString(total_risk, 2), "%");
      Print("Consider reducing position sizes or number of EAs.");
   }
}

//+------------------------------------------------------------------+
//| Get EA name from magic number                                    |
//+------------------------------------------------------------------+
string GetEANameFromMagic(long magic)
{
   // Add your known EA magic numbers here
   switch((int)magic)
   {
      case 0:      return "Manual Trading";
      case 12345:  return "Risk Manager EA";
      case 55555:  return "Commercial EA";
      case 77777:  return "Scalper EA";
      case 88888:  return "Grid EA";
      case 99999:  return "Martingale EA";
      
      // Magic number ranges
      default:
         {
            if(magic >= 10000 && magic < 20000)
               return StringFormat("External EA (%d)", magic);
            else if(magic >= 20000 && magic < 30000)
               return StringFormat("Signal Service (%d)", magic);
            else if(magic >= 30000 && magic < 40000)
               return StringFormat("Copy Trader (%d)", magic);
            else if(magic >= 80000 && magic < 90000)
               return StringFormat("PAMM/MAM (%d)", magic);
            else
               return StringFormat("Unknown EA (%d)", magic);
         }
   }
}

//+------------------------------------------------------------------+
//| Calculate position risk percentage                               |
//+------------------------------------------------------------------+
double CalculatePositionRisk(ulong ticket)
{
   if(!PositionSelectByTicket(ticket))
      return 0;
      
   string symbol = PositionGetString(POSITION_SYMBOL);
   double sl = PositionGetDouble(POSITION_SL);
   double open_price = PositionGetDouble(POSITION_PRICE_OPEN);
   double volume = PositionGetDouble(POSITION_VOLUME);
   ENUM_POSITION_TYPE type = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
   
   if(sl == 0) return 0; // No stop loss
   
   double stop_distance;
   if(type == POSITION_TYPE_BUY)
      stop_distance = open_price - sl;
   else
      stop_distance = sl - open_price;
      
   if(stop_distance <= 0) return 0;
   
   double tick_value = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_VALUE);
   double tick_size = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_SIZE);
   
   if(tick_size <= 0) return 0;
   
   double potential_loss = (stop_distance / tick_size) * tick_value * volume;
   
   double balance = AccountInfoDouble(ACCOUNT_BALANCE);
   return (balance > 0) ? (potential_loss / balance) * 100 : 0;
}

//+------------------------------------------------------------------+
//| Create EA summary dashboard label                                |
//+------------------------------------------------------------------+
void CreateEASummaryDashboard()
{
   string summary = "═══ EA SUMMARY ═══\n";
   
   int total_positions = PositionsTotal();
   long magic_numbers[];
   int magic_count = 0;
   
   // Collect unique magic numbers
   for(int i = 0; i < total_positions; i++)
   {
      if(PositionSelectByTicket(PositionGetTicket(i)))
      {
         long magic = PositionGetInteger(POSITION_MAGIC);
         
         bool found = false;
         for(int j = 0; j < magic_count; j++)
         {
            if(magic_numbers[j] == magic)
            {
               found = true;
               break;
            }
         }
         
         if(!found)
         {
            ArrayResize(magic_numbers, magic_count + 1);
            magic_numbers[magic_count] = magic;
            magic_count++;
         }
      }
   }
   
   // Build summary
   for(int i = 0; i < magic_count; i++)
   {
      int count = 0;
      double profit = 0;
      
      for(int j = 0; j < total_positions; j++)
      {
         if(PositionSelectByTicket(PositionGetTicket(j)))
         {
            if(PositionGetInteger(POSITION_MAGIC) == magic_numbers[i])
            {
               count++;
               profit += PositionGetDouble(POSITION_PROFIT);
            }
         }
      }
      
      summary += GetEANameFromMagic(magic_numbers[i]) + ": " + 
                IntegerToString(count) + " trades, P/L: $" + 
                DoubleToString(profit, 2) + "\n";
   }
   
   // Display on chart
   Comment(summary);
}

//+------------------------------------------------------------------+