//+------------------------------------------------------------------+
//|                                OI_MeanReversion_Pro_XAUUSD_V2.mq5 |
//|                       Professional OI Mean Reversion System      |
//|                                              Version 2.0         |
//+------------------------------------------------------------------+
#property copyright "Professional OI Mean Reversion System"
#property link      ""
#property version   "2.00"
#property description "Advanced Mean Reversion with OI Levels & Multi-Timeframe Filtering"
#property strict

//--- Includes
#include <Trade\Trade.mqh>
#include <Trade\AccountInfo.mqh>
#include <Trade\SymbolInfo.mqh>
#include <Trade\PositionInfo.mqh>
#include <Trade\OrderInfo.mqh>
#include <Trade\HistoryOrderInfo.mqh>
#include <Arrays\ArrayObj.mqh>
#include <Arrays\ArrayDouble.mqh>

//--- Market Phase Enum (Moved to global scope)
enum ENUM_MARKET_PHASE
{
   PHASE_BULLISH,
   PHASE_BEARISH,
   PHASE_SIDEWAYS,
   PHASE_NEUTRAL
};

//--- Input Parameters (จัดกลุ่มตามสเปก)
// Group A: OI & Delta Configuration
input group "=== OI & DELTA SETTINGS ==="
enum ENUM_OI_SOURCE {
   OI_SOURCE_MANUAL,     // Manual Input
   OI_SOURCE_CSV_FILE,   // CSV File
   OI_SOURCE_AUTO_SYNC   // Auto Sync (Future)
};
input ENUM_OI_SOURCE InpOISource = OI_SOURCE_CSV_FILE;
input string InpOICsvPath = "oi_data.csv"; // Path to CSV file
input int InpCSVReloadInterval = 60; // CSV reload interval (minutes, 0=disabled)
input double InpManualFuturePrice = 0.0; // Manual future price input

// OI Levels (Manual Input - สามารถใส่ได้ถึง 3 ระดับ)
input double InpCallStrike1 = 0.0;
input double InpCallStrike2 = 0.0;
input double InpCallStrike3 = 0.0;
input double InpPutStrike1 = 0.0;
input double InpPutStrike2 = 0.0;
input double InpPutStrike3 = 0.0;

// Delta Calculation
input int InpDeltaEmaPeriod = 20; // EMA period for Delta average
input double InpDeviationThreshold = 20.0; // Deviation threshold in points
input double InpDeviationMultiplier = 1.5; // Deviation multiplier for entry

// Group B: Trading Configuration
input group "=== TRADING SETTINGS ==="
input double InpLotSize = 0.1; // Fixed lot size
input bool InpUseMoneyManagement = true; // Use money management
input double InpRiskPercent = 1.0; // Risk per trade (%)
input bool InpUseStopLoss = true; // Use stop loss
input bool InpUseTakeProfit = true; // Use take profit
input int InpStopLossPoints = 300; // SL in points
input int InpTakeProfitPoints = 500; // TP in points
input int InpMaxSpread = 200; // Max spread in points
input int InpMaxSlippage = 10; // Max slippage in points
input int InpMagicNumber = 202412; // Magic number
input bool InpCloseOnZeroDeviation = true; // Close when deviation crosses zero

// Group C: Market Filters
input group "=== MARKET FILTERS ==="
input bool InpUseMarketPhaseFilter = true; // Filter by market phase
input ENUM_TIMEFRAMES InpTrendTF = PERIOD_H4; // Trend timeframe
input int InpTrendMAPeriod1 = 50; // Fast MA period
input int InpTrendMAPeriod2 = 200; // Slow MA period
input bool InpUseATRFilter = true; // Use ATR volatility filter
input double InpMaxATRPercent = 2.0; // Max ATR% for trading
input bool InpUseSessionFilter = true; // Filter by trading session
input int InpSessionStartHour = 8; // Session start (GMT)
input int InpSessionEndHour = 22; // Session end (GMT)
input bool InpAvoidHighImpactNews = true; // Avoid high impact news

// Group D: Risk Management
input group "=== RISK MANAGEMENT ==="
input double InpMaxDailyLossPercent = 3.0; // Max daily loss %
input double InpMaxDailyProfitPercent = 5.0; // Max daily profit %
input int InpMaxConsecutiveLosses = 3; // Max consecutive losses
input bool InpDisableAfterMaxLoss = true; // Disable after max loss
input double InpEquityProtectionPercent = 10.0; // Equity protection %
input bool InpCloseAllOnReverse = false; // Close all on market reversal
input int InpMaxDailyTrades = 10; // Maximum trades per day

// Group E: Advanced Features
input group "=== ADVANCED FEATURES ==="
input bool InpUseTrailingStop = false; // Use trailing stop
input int InpTrailingStartPoints = 150; // Trailing start in points
input int InpTrailingStepPoints = 50; // Trailing step in points
input bool InpUseSoftStopLoss = true; // Use soft stop loss (close manually)
input bool InpUseAutoRecovery = true; // Auto recover after restart
input bool InpEnableDashboard = true; // Enable dashboard display

//--- Global Objects
CTrade Trade;
CSymbolInfo SymbolInfo;
CAccountInfo AccountInfo;
CPositionInfo PositionInfo;
COrderInfo OrderInfo;
CHistoryOrderInfo HistoryOrderInfo;

//--- Global Variables
double DeltaPrice = 0.0;
double DeltaEMA = 0.0;
double DeltaDeviation = 0.0;
double FuturePrice = 0.0;
double SpotPrice = 0.0;

// OI Levels Arrays
double CallLevels[3];
double PutLevels[3];
int CallOI[3];
int PutOI[3];

// Dynamic OI Data Variables (modifiable)
double DynamicFuturePrice = 0.0;
double DynamicCallStrike1 = 0.0;
double DynamicCallStrike2 = 0.0;
double DynamicCallStrike3 = 0.0;
double DynamicPutStrike1 = 0.0;
double DynamicPutStrike2 = 0.0;
double DynamicPutStrike3 = 0.0;

// Key Levels from Dashboard
double LevelUpper1 = 0.0;
double LevelUpper2 = 0.0;
double LevelMid = 0.0;
double LevelLower1 = 0.0;
double LevelLower2 = 0.0;

// Trading Statistics
int DailyTradeCount = 0;
double DailyPnL = 0.0;
double DailyProfit = 0.0;
double DailyLoss = 0.0;
int ConsecutiveLosses = 0;
datetime LastTradeTime = 0;
datetime LastResetDate = 0;

// Risk Management
bool TradingEnabled = true;
double EquityHigh = 0.0;
double EquityLow = 0.0;

// Indicator Handles
int ATRHandle = INVALID_HANDLE;
int MAFastHandle = INVALID_HANDLE;
int MASlowHandle = INVALID_HANDLE;
int RSIMainHandle = INVALID_HANDLE;

// Dashboard
long chart_id = 0; // Chart window ID
int DashboardSubWindow = -1;
color PanelColor = C'30,30,30';
color TextColor = clrWhite;
color ProfitColor = clrLime;
color LossColor = clrRed;
color WarningColor = clrOrange;

// News Filter
bool NewsBlockActive = false;
datetime NewsBlockStart = 0;
datetime NewsBlockEnd = 0;

// CSV Cache Variables
double CachedFuturePrice = -1;
string LoadedCSVPath = "";
bool CSVLoadLogged = false;
datetime LastCSVReloadTime = 0;

//=== NEW: Control Panel Variables ===
// Control Panel Position - Moved below dashboard
int ControlPanelX = 10;
int ControlPanelY = 210;

// Input Values for Control Panel
double PendingPriceValue = 0.0;
double ManualLotSize = 0.5;
int ManualSLPoints = 0;
int ManualTPPoints = 300;

// OI Data Input Values
double ManualFuturePriceValue = 0.0;
double CallStrike1Value = 0.0;
double CallStrike2Value = 0.0;
double CallStrike3Value = 0.0;
double PutStrike1Value = 0.0;
double PutStrike2Value = 0.0;
double PutStrike3Value = 0.0;

// Control Panel Object Names
string ControlPanelObjects[] = {
   // Top Panel Objects
   "CP_TopPanel",
   "CP_CloseAll",
   
   // OI Data Panel Objects
   "CP_OIDataPanel",
   "CP_FuturePrice",
   "CP_CallStrike1",
   "CP_CallStrike2",
   "CP_CallStrike3",
   "CP_PutStrike1",
   "CP_PutStrike2",
   "CP_PutStrike3",
   "CP_UpdateOI",
   
   // Trading Panel Objects
   "CP_TradingPanel",
   "CP_PendingPrice",
   "CP_LotSize",
   "CP_SLPoints",
   "CP_TPPoints",
   "CP_Sell",
   "CP_Buy",
   "CP_PendingSell",
   "CP_PendingBuy",
   "CP_CloseAllPending",
   "CP_CloseSell",
   "CP_CloseBuy"
};

//--- Global Variables for Line Management
string DrawnLines[]; // Array to store drawn line names
int MaxLines = 10;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
   //--- Initialize trading objects
   Trade.SetExpertMagicNumber(InpMagicNumber);
   Trade.SetDeviationInPoints(InpMaxSlippage);
   Trade.SetTypeFilling(ORDER_FILLING_IOC);
   
   //--- Initialize symbol info
   SymbolInfo.Name(_Symbol);
   SymbolInfo.RefreshRates();
   
   //--- Initialize Dynamic OI Variables with input parameters
   DynamicFuturePrice = InpManualFuturePrice;
   DynamicCallStrike1 = InpCallStrike1;
   DynamicCallStrike2 = InpCallStrike2;
   DynamicCallStrike3 = InpCallStrike3;
   DynamicPutStrike1 = InpPutStrike1;
   DynamicPutStrike2 = InpPutStrike2;
   DynamicPutStrike3 = InpPutStrike3;
   
   //--- Initialize OI Levels
   InitializeOILevels();
   
   //--- Initialize Key Levels
   InitializeKeyLevels();
   
   //--- Initialize indicators
   if(!InitializeIndicators())
   {
      Print("Error initializing indicators");
      return INIT_FAILED;
   }
   
   //--- Initialize risk management
   EquityHigh = AccountInfo.Equity();
   EquityLow = AccountInfo.Equity();
   
   //--- Initialize dashboard
   if(InpEnableDashboard)
   {
      chart_id = ChartID(); // Get current chart ID
      CreateDashboard();
      CreateControlPanel(); // Create new control panel
   }
   
   //--- Auto-recovery: Check for existing positions
   if(InpUseAutoRecovery)
   {
      CheckExistingPositions();
   }
   
   //--- Set timer for updates (every 1 second)
   EventSetTimer(1);
   
   //--- Initialize lines array
   ArrayResize(DrawnLines, MaxLines);
   for(int i = 0; i < MaxLines; i++)
   {
      DrawnLines[i] = "";
   }
   
   Print("EA Initialized Successfully");
   Print("Symbol: ", _Symbol);
   Print("Account Balance: ", AccountInfo.Balance());
   Print("Trading Enabled: ", TradingEnabled);
   
   return INIT_SUCCEEDED;
}

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   //--- Clean up dashboard and control panel
   if(InpEnableDashboard)
   {
      ObjectsDeleteAll(chart_id, 0, -1);
   }
   
   //--- Release indicator handles
   if(ATRHandle != INVALID_HANDLE) IndicatorRelease(ATRHandle);
   if(MAFastHandle != INVALID_HANDLE) IndicatorRelease(MAFastHandle);
   if(MASlowHandle != INVALID_HANDLE) IndicatorRelease(MASlowHandle);
   if(RSIMainHandle != INVALID_HANDLE) IndicatorRelease(RSIMainHandle);
   
   //--- Kill timer
   EventKillTimer();
   
   Print("EA Deinitialized");
}

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
   //--- Skip if not enough bars
   if(Bars(_Symbol, _Period) < 100)
      return;
   
   //--- Update market data
   if(!UpdateMarketData())
      return;
   
   //--- Check global conditions
   if(!CheckGlobalConditions())
      return;
   
   //--- Check for trade signals
   CheckTradingSignals();
   
   //--- Manage existing positions
   ManagePositions();
   
   //--- Update dashboard and control panel
   if(InpEnableDashboard)
   {
      UpdateDashboard();
      UpdateControlPanel();
   }
}

//+------------------------------------------------------------------+
//| Timer function                                                   |
//+------------------------------------------------------------------+
void OnTimer()
{
    //--- Update dashboard periodically
    if(InpEnableDashboard)
    {
       UpdateDashboard();
       UpdateControlPanel();
    }
    
    //--- Check news events
    if(InpAvoidHighImpactNews)
    {
       CheckNewsEvents();
    }
    
    //--- Reset daily statistics if new day
    CheckDailyReset();
    
    //--- CSV reload check
    if(InpOISource == OI_SOURCE_CSV_FILE && InpCSVReloadInterval > 0) {
       if(TimeCurrent() - LastCSVReloadTime >= InpCSVReloadInterval * 60) {
          Print("CSV Reload: Scheduled reload triggered");
          LastCSVReloadTime = TimeCurrent();
          CachedFuturePrice = -1;
          LoadOIFromCSV();
       }
    }
}

//+------------------------------------------------------------------+
//| Chart Event Handler                                              |
//+------------------------------------------------------------------+
void OnChartEvent(const int id, const long &lparam, const double &dparam, const string &sparam)
{
   //--- Handle control panel button clicks
   if(id == CHARTEVENT_OBJECT_CLICK)
   {
      HandleControlPanelClick(sparam);
   }
   
   //--- Handle edit field changes (สำหรับรับค่าจาก Input Fields)
   if(id == CHARTEVENT_OBJECT_ENDEDIT)
   {
      // อัพเดทค่าทันทีเมื่อมีการแก้ไขข้อมูลใน Edit Fields
      UpdateInputValues();
      Print("Edit field updated: ", sparam, " Value: ", ObjectGetString(chart_id, sparam, OBJPROP_TEXT));
   }
}

//+------------------------------------------------------------------+
//| Create Control Panel                                             |
//+------------------------------------------------------------------+
void CreateControlPanel()
{
   //--- Create top control panel
   CreateControlPanelUI();
   
   //--- Set initial values
   UpdateControlPanelValues();
}

//+------------------------------------------------------------------+
//| Create Control Panel UI                                          |
//+------------------------------------------------------------------+
void CreateControlPanelUI()
{
   int panelWidth = 850;  // Match dashboard width
   int topPanelHeight = 50;
   int oiPanelHeight = 120;
   int tradingPanelHeight = 180;
   
   //--- Top Panel (Quick Tools)
   CreatePanel("CP_TopPanel", ControlPanelX, ControlPanelY, panelWidth, topPanelHeight, C'45,45,45', BORDER_FLAT);
   
   //--- Close All Button
   CreateButton("CP_CloseAll", ControlPanelX + 10, ControlPanelY + 10, 830, 30, "Close All Positions", clrRed, clrWhite);
   
   //--- OI Data Panel (New Section)
   CreatePanel("CP_OIDataPanel", ControlPanelX, ControlPanelY + topPanelHeight + 10, panelWidth, oiPanelHeight, C'45,45,45', BORDER_FLAT);
   
   //--- OI Data Labels Row 1 - ปรับจัดเรียงให้เป็น Grid Layout
   CreateLabel("CP_FuturePriceLabel", ControlPanelX + 10, ControlPanelY + topPanelHeight + 20, "Future Price:", clrYellow, 8);
   CreateLabel("CP_CallStrikesLabel", ControlPanelX + 200, ControlPanelY + topPanelHeight + 20, "Call Strikes:", clrYellow, 8);
   CreateLabel("CP_PutStrikesLabel", ControlPanelX + 200, ControlPanelY + topPanelHeight + 50, "Put Strikes:", clrYellow, 8);
   
   //--- OI Data Fields Row 1 - จัดเรียงแบบ Grid
   CreateEditField("CP_FuturePrice", ControlPanelX + 90, ControlPanelY + topPanelHeight + 15, 80, 20, "0", clrWhite, clrBlack);
   CreateEditField("CP_CallStrike1", ControlPanelX + 280, ControlPanelY + topPanelHeight + 15, 80, 20, "0", clrWhite, clrBlack);
   CreateEditField("CP_CallStrike2", ControlPanelX + 370, ControlPanelY + topPanelHeight + 15, 80, 20, "0", clrWhite, clrBlack);
   CreateEditField("CP_CallStrike3", ControlPanelX + 460, ControlPanelY + topPanelHeight + 15, 80, 20, "0", clrWhite, clrBlack);
   
   //--- OI Data Fields Row 2 - จัดเรียงให้เสมอกันกับ Call Strikes
   CreateEditField("CP_PutStrike1", ControlPanelX + 280, ControlPanelY + topPanelHeight + 45, 80, 20, "0", clrWhite, clrBlack);
   CreateEditField("CP_PutStrike2", ControlPanelX + 370, ControlPanelY + topPanelHeight + 45, 80, 20, "0", clrWhite, clrBlack);
   CreateEditField("CP_PutStrike3", ControlPanelX + 460, ControlPanelY + topPanelHeight + 45, 80, 20, "0", clrWhite, clrBlack);
   
   //--- Update OI Button
   CreateButton("CP_UpdateOI", ControlPanelX + 750, ControlPanelY + topPanelHeight + 25, 90, 35, "Update OI Data", clrCyan, clrBlack);
   
   //--- Trading Panel (Main Trading Controls)
   CreatePanel("CP_TradingPanel", ControlPanelX, ControlPanelY + topPanelHeight + oiPanelHeight + 20, panelWidth, tradingPanelHeight, C'45,45,45', BORDER_FLAT);
   
   //--- Trading Input Fields Labels
   CreateLabel("CP_PendingPriceLabel", ControlPanelX + 10, ControlPanelY + topPanelHeight + oiPanelHeight + 35, "Price:", clrYellow, 8);
   CreateLabel("CP_LotSizeLabel", ControlPanelX + 10, ControlPanelY + topPanelHeight + oiPanelHeight + 60, "Lot Size:", clrYellow, 8);
   CreateLabel("CP_SLPointsLabel", ControlPanelX + 10, ControlPanelY + topPanelHeight + oiPanelHeight + 85, "SL (Point):", clrYellow, 8);
   CreateLabel("CP_TPPointsLabel", ControlPanelX + 10, ControlPanelY + topPanelHeight + oiPanelHeight + 110, "TP (Point):", clrYellow, 8);
   
   //--- Trading Input Fields
   CreateEditField("CP_PendingPrice", ControlPanelX + 80, ControlPanelY + topPanelHeight + oiPanelHeight + 30, 80, 20, "0", clrWhite, clrBlack);
   CreateEditField("CP_LotSize", ControlPanelX + 80, ControlPanelY + topPanelHeight + oiPanelHeight + 55, 80, 20, "0.5", clrWhite, clrBlack);
   CreateEditField("CP_SLPoints", ControlPanelX + 80, ControlPanelY + topPanelHeight + oiPanelHeight + 80, 80, 20, "0", clrWhite, clrBlack);
   CreateEditField("CP_TPPoints", ControlPanelX + 80, ControlPanelY + topPanelHeight + oiPanelHeight + 105, 80, 20, "300", clrWhite, clrBlack);
   
   //--- Immediate Action Buttons Row 1
   CreateButton("CP_Sell", ControlPanelX + 180, ControlPanelY + topPanelHeight + oiPanelHeight + 30, 100, 25, "Sell Now", clrRed, clrWhite);
   CreateButton("CP_Buy", ControlPanelX + 290, ControlPanelY + topPanelHeight + oiPanelHeight + 30, 100, 25, "Buy Now", clrGreen, clrWhite);
   
   //--- Pending Action Buttons Row 2
   CreateButton("CP_PendingSell", ControlPanelX + 180, ControlPanelY + topPanelHeight + oiPanelHeight + 65, 100, 25, "Pending Sell", clrOrange, clrBlack);
   CreateButton("CP_PendingBuy", ControlPanelX + 290, ControlPanelY + topPanelHeight + oiPanelHeight + 65, 100, 25, "Pending Buy", clrDarkGreen, clrWhite);
   
   //--- Management Buttons Row 3
   CreateButton("CP_CloseAllPending", ControlPanelX + 180, ControlPanelY + topPanelHeight + oiPanelHeight + 100, 210, 25, "Close All Pending Orders", clrPurple, clrWhite);
   
   //--- Management Buttons Row 4
   CreateButton("CP_CloseSell", ControlPanelX + 180, ControlPanelY + topPanelHeight + oiPanelHeight + 135, 100, 25, "Close All Sell", clrPurple, clrWhite);
   CreateButton("CP_CloseBuy", ControlPanelX + 290, ControlPanelY + topPanelHeight + oiPanelHeight + 135, 100, 25, "Close All Buy", clrPurple, clrWhite);
}

//+------------------------------------------------------------------+
//| Create Panel                                                     |
//+------------------------------------------------------------------+
void CreatePanel(string name, int x, int y, int width, int height, color bgColor, ENUM_BORDER_TYPE border)
{
   if(ObjectFind(chart_id, name) < 0)
   {
      ObjectCreate(chart_id, name, OBJ_RECTANGLE_LABEL, 0, 0, 0);
      ObjectSetInteger(chart_id, name, OBJPROP_XDISTANCE, x);
      ObjectSetInteger(chart_id, name, OBJPROP_YDISTANCE, y);
      ObjectSetInteger(chart_id, name, OBJPROP_XSIZE, width);
      ObjectSetInteger(chart_id, name, OBJPROP_YSIZE, height);
      ObjectSetInteger(chart_id, name, OBJPROP_BGCOLOR, bgColor);
      ObjectSetInteger(chart_id, name, OBJPROP_BORDER_TYPE, border);
      ObjectSetInteger(chart_id, name, OBJPROP_BORDER_COLOR, clrGray);
      ObjectSetInteger(chart_id, name, OBJPROP_BACK, false); // ปรับจาก true เป็น false เพื่อให้อยู่หน้ากราฟ
      ObjectSetInteger(chart_id, name, OBJPROP_SELECTABLE, false);
      ObjectSetInteger(chart_id, name, OBJPROP_HIDDEN, true);
      // ตั้งค่า Z-Order ให้สูงเพื่อให้อยู่เหนือเส้นกราฟ
      ObjectSetInteger(chart_id, name, OBJPROP_ZORDER, 1000);
   }
}

//+------------------------------------------------------------------+
//| Create Button                                                    |
//+------------------------------------------------------------------+
void CreateButton(string name, int x, int y, int width, int height, string text, color bgColor, color textColor)
{
   if(ObjectFind(chart_id, name) < 0)
   {
      ObjectCreate(chart_id, name, OBJ_BUTTON, 0, 0, 0);
      ObjectSetInteger(chart_id, name, OBJPROP_XDISTANCE, x);
      ObjectSetInteger(chart_id, name, OBJPROP_YDISTANCE, y);
      ObjectSetInteger(chart_id, name, OBJPROP_XSIZE, width);
      ObjectSetInteger(chart_id, name, OBJPROP_YSIZE, height);
      ObjectSetString(chart_id, name, OBJPROP_TEXT, text);
      ObjectSetInteger(chart_id, name, OBJPROP_BGCOLOR, bgColor);
      ObjectSetInteger(chart_id, name, OBJPROP_COLOR, textColor);
      ObjectSetInteger(chart_id, name, OBJPROP_FONTSIZE, 8);
      ObjectSetString(chart_id, name, OBJPROP_FONT, "Arial");
      ObjectSetInteger(chart_id, name, OBJPROP_CORNER, CORNER_LEFT_UPPER);
      ObjectSetInteger(chart_id, name, OBJPROP_ANCHOR, ANCHOR_LEFT_UPPER);
      ObjectSetInteger(chart_id, name, OBJPROP_SELECTABLE, false);
      ObjectSetInteger(chart_id, name, OBJPROP_HIDDEN, true);
      ObjectSetInteger(chart_id, name, OBJPROP_ZORDER, 1001);
   }
}

//+------------------------------------------------------------------+
//| Create Edit Field                                                |
//+------------------------------------------------------------------+
void CreateEditField(string name, int x, int y, int width, int height, string defaultText, color textColor, color bgColor)
{
   if(ObjectFind(chart_id, name) < 0)
   {
      ObjectCreate(chart_id, name, OBJ_EDIT, 0, 0, 0);
      ObjectSetInteger(chart_id, name, OBJPROP_XDISTANCE, x);
      ObjectSetInteger(chart_id, name, OBJPROP_YDISTANCE, y);
      ObjectSetInteger(chart_id, name, OBJPROP_XSIZE, width);
      ObjectSetInteger(chart_id, name, OBJPROP_YSIZE, height);
      ObjectSetString(chart_id, name, OBJPROP_TEXT, defaultText);
      ObjectSetInteger(chart_id, name, OBJPROP_BGCOLOR, bgColor);
      ObjectSetInteger(chart_id, name, OBJPROP_COLOR, textColor);
      ObjectSetInteger(chart_id, name, OBJPROP_FONTSIZE, 8);
      ObjectSetString(chart_id, name, OBJPROP_FONT, "Arial");
      ObjectSetInteger(chart_id, name, OBJPROP_CORNER, CORNER_LEFT_UPPER);
      ObjectSetInteger(chart_id, name, OBJPROP_ANCHOR, ANCHOR_LEFT_UPPER);
      ObjectSetInteger(chart_id, name, OBJPROP_SELECTABLE, false);
      ObjectSetInteger(chart_id, name, OBJPROP_HIDDEN, true);
      ObjectSetInteger(chart_id, name, OBJPROP_ZORDER, 1001);
   }
}

//+------------------------------------------------------------------+
//| Create Label                                                     |
//+------------------------------------------------------------------+
void CreateLabel(string name, int x, int y, string text, color clr, int fontSize = 8)
{
   if(ObjectFind(chart_id, name) < 0)
   {
      ObjectCreate(chart_id, name, OBJ_LABEL, 0, 0, 0);
      ObjectSetInteger(chart_id, name, OBJPROP_XDISTANCE, x);
      ObjectSetInteger(chart_id, name, OBJPROP_YDISTANCE, y);
      ObjectSetString(chart_id, name, OBJPROP_TEXT, text);
      ObjectSetInteger(chart_id, name, OBJPROP_COLOR, clr);
      ObjectSetInteger(chart_id, name, OBJPROP_FONTSIZE, fontSize);
      ObjectSetString(chart_id, name, OBJPROP_FONT, "Arial");
      ObjectSetInteger(chart_id, name, OBJPROP_CORNER, CORNER_LEFT_UPPER);
      ObjectSetInteger(chart_id, name, OBJPROP_ANCHOR, ANCHOR_LEFT_UPPER);
      ObjectSetInteger(chart_id, name, OBJPROP_SELECTABLE, false);
      ObjectSetInteger(chart_id, name, OBJPROP_HIDDEN, true);
      ObjectSetInteger(chart_id, name, OBJPROP_ZORDER, 1002);
   }
}

//+------------------------------------------------------------------+
//| Handle Control Panel Click                                       |
//+------------------------------------------------------------------+
void HandleControlPanelClick(string objectName)
{
   //--- Get current values from input fields
   UpdateInputValues();
   
   if(objectName == "CP_CloseAll")
   {
      CloseAllPositions();
   }
   else if(objectName == "CP_UpdateOI")  // New OI Data Update Handler
   {
      UpdateOIData();
   }
   else if(objectName == "CP_Sell")
   {
      ExecuteManualSell();
   }
   else if(objectName == "CP_Buy")
   {
      ExecuteManualBuy();
   }
   else if(objectName == "CP_PendingSell")
   {
      ExecutePendingSell();
   }
   else if(objectName == "CP_PendingBuy")
   {
      ExecutePendingBuy();
   }
   else if(objectName == "CP_CloseAllPending")
   {
      CancelAllPendingOrders();
   }
   else if(objectName == "CP_CloseSell")
   {
      CloseAllSellPositions();
   }
   else if(objectName == "CP_CloseBuy")
   {
      CloseAllBuyPositions();
   }
}

//+------------------------------------------------------------------+
//| Update Input Values from Control Panel                           |
//+------------------------------------------------------------------+
void UpdateInputValues()
{
   // Update trading input values
   PendingPriceValue = StringToDouble(ObjectGetString(chart_id, "CP_PendingPrice", OBJPROP_TEXT));
   ManualLotSize = StringToDouble(ObjectGetString(chart_id, "CP_LotSize", OBJPROP_TEXT));
   ManualSLPoints = (int)StringToInteger(ObjectGetString(chart_id, "CP_SLPoints", OBJPROP_TEXT));
   ManualTPPoints = (int)StringToInteger(ObjectGetString(chart_id, "CP_TPPoints", OBJPROP_TEXT));
   
   // Update OI data input values
   ManualFuturePriceValue = StringToDouble(ObjectGetString(chart_id, "CP_FuturePrice", OBJPROP_TEXT));
   CallStrike1Value = StringToDouble(ObjectGetString(chart_id, "CP_CallStrike1", OBJPROP_TEXT));
   CallStrike2Value = StringToDouble(ObjectGetString(chart_id, "CP_CallStrike2", OBJPROP_TEXT));
   CallStrike3Value = StringToDouble(ObjectGetString(chart_id, "CP_CallStrike3", OBJPROP_TEXT));
   PutStrike1Value = StringToDouble(ObjectGetString(chart_id, "CP_PutStrike1", OBJPROP_TEXT));
   PutStrike2Value = StringToDouble(ObjectGetString(chart_id, "CP_PutStrike2", OBJPROP_TEXT));
   PutStrike3Value = StringToDouble(ObjectGetString(chart_id, "CP_PutStrike3", OBJPROP_TEXT));
   
   Print("Pending Price: ", PendingPriceValue);
   Print("Lot Size: ", ManualLotSize);
   Print("SL Points: ", ManualSLPoints);
   Print("TP Points: ", ManualTPPoints);
   Print("Manual Future Price: ", ManualFuturePriceValue);
   Print("Call Strikes: ", CallStrike1Value, ", ", CallStrike2Value, ", ", CallStrike3Value);
   Print("Put Strikes: ", PutStrike1Value, ", ", PutStrike2Value, ", ", PutStrike3Value);
}

//+------------------------------------------------------------------+
//| Update Control Panel Values                                      |
//+------------------------------------------------------------------+
void UpdateControlPanelValues()
{
   // Update price display
   double currentBid = SymbolInfo.Bid();
   ObjectSetString(chart_id, "CP_PendingPrice", OBJPROP_TEXT, DoubleToString(currentBid, _Digits));
   
   // Initialize OI data fields with current input values (dynamic first, then input)
   ObjectSetString(chart_id, "CP_FuturePrice", OBJPROP_TEXT, 
                   DoubleToString((DynamicFuturePrice > 0) ? DynamicFuturePrice : InpManualFuturePrice, _Digits));
   ObjectSetString(chart_id, "CP_CallStrike1", OBJPROP_TEXT, 
                   DoubleToString((DynamicCallStrike1 > 0) ? DynamicCallStrike1 : InpCallStrike1, _Digits));
   ObjectSetString(chart_id, "CP_CallStrike2", OBJPROP_TEXT, 
                   DoubleToString((DynamicCallStrike2 > 0) ? DynamicCallStrike2 : InpCallStrike2, _Digits));
   ObjectSetString(chart_id, "CP_CallStrike3", OBJPROP_TEXT, 
                   DoubleToString((DynamicCallStrike3 > 0) ? DynamicCallStrike3 : InpCallStrike3, _Digits));
   ObjectSetString(chart_id, "CP_PutStrike1", OBJPROP_TEXT, 
                   DoubleToString((DynamicPutStrike1 > 0) ? DynamicPutStrike1 : InpPutStrike1, _Digits));
   ObjectSetString(chart_id, "CP_PutStrike2", OBJPROP_TEXT, 
                   DoubleToString((DynamicPutStrike2 > 0) ? DynamicPutStrike2 : InpPutStrike2, _Digits));
   ObjectSetString(chart_id, "CP_PutStrike3", OBJPROP_TEXT, 
                   DoubleToString((DynamicPutStrike3 > 0) ? DynamicPutStrike3 : InpPutStrike3, _Digits));
}

//+------------------------------------------------------------------+
//| Update Control Panel                                             |
//+------------------------------------------------------------------+
void UpdateControlPanel()
{
   // Update pending price with current market price periodically
   static datetime lastUpdate = 0;
   if(TimeCurrent() - lastUpdate > 5) // Update every 5 seconds
   {
      UpdateControlPanelValues();
      lastUpdate = TimeCurrent();
   }
}

//+------------------------------------------------------------------+
//| Execute Manual SELL                                              |
//+------------------------------------------------------------------+
void ExecuteManualSell()
{
   double lotSize = NormalizeLot(ManualLotSize);
   if(lotSize <= 0) return;
   
   double sl = (ManualSLPoints > 0) ? SymbolInfo.Bid() + ManualSLPoints * _Point : 0.0;
   double tp = (ManualTPPoints > 0) ? SymbolInfo.Bid() - ManualTPPoints * _Point : 0.0;
   
   if(Trade.Sell(lotSize, _Symbol, SymbolInfo.Bid(), sl, tp, "Manual SELL"))
   {
      Print("Manual SELL executed. Lot: ", lotSize, " Price: ", SymbolInfo.Bid());
      DailyTradeCount++;
   }
   else
   {
      Print("Manual SELL failed. Error: ", Trade.ResultRetcodeDescription());
   }
}

//+------------------------------------------------------------------+
//| Execute Manual BUY                                               |
//+------------------------------------------------------------------+
void ExecuteManualBuy()
{
   double lotSize = NormalizeLot(ManualLotSize);
   if(lotSize <= 0) return;
   
   double sl = (ManualSLPoints > 0) ? SymbolInfo.Ask() - ManualSLPoints * _Point : 0.0;
   double tp = (ManualTPPoints > 0) ? SymbolInfo.Ask() + ManualTPPoints * _Point : 0.0;
   
   if(Trade.Buy(lotSize, _Symbol, SymbolInfo.Ask(), sl, tp, "Manual BUY"))
   {
      Print("Manual BUY executed. Lot: ", lotSize, " Price: ", SymbolInfo.Ask());
      DailyTradeCount++;
   }
   else
   {
      Print("Manual BUY failed. Error: ", Trade.ResultRetcodeDescription());
   }
}

//+------------------------------------------------------------------+
//| Execute Pending SELL                                             |
//+------------------------------------------------------------------+
void ExecutePendingSell()
{
   // 1. อัพเดทค่าจาก Control Panel
   UpdateInputValues();
   
   // 2. Refresh rates ก่อนใช้งาน
   SymbolInfo.RefreshRates();
   
   // 3. ตรวจสอบค่าที่ได้
   if(PendingPriceValue <= 0) 
   {
      Print("Invalid pending price for SELL: ", PendingPriceValue);
      Alert("กรุณากรอกราคาที่ต้องการสำหรับ Pending SELL");
      return;
   }
   
   double lotSize = NormalizeLot(ManualLotSize);
   if(lotSize <= 0) 
   {
      Print("Invalid lot size for Pending SELL: ", ManualLotSize);
      Alert("กรุณากรอกขนาด Lot ที่ถูกต้อง");
      return;
   }
   
   // 4. คำนวณ SL และ TP สำหรับ SELL orders
   // SL ต้องต่ำกว่าราคา entry สำหรับ SELL orders
   double sl = (ManualSLPoints > 0) ? PendingPriceValue - ManualSLPoints * _Point : 0.0;
   double tp = (ManualTPPoints > 0) ? PendingPriceValue - ManualTPPoints * _Point : 0.0;
   
   Print("SELL Order - Entry: ", PendingPriceValue, " | SL: ", sl, " | TP: ", tp);
   
   // 5. กำหนดประเภท Order - SELL logic ต้องถูกต้อง
   ENUM_ORDER_TYPE orderType;
   double currentBid = SymbolInfo.Bid(); // ใช้ Bid สำหรับ SELL orders
   
   Print("Current Bid: ", currentBid, " | Pending Price: ", PendingPriceValue);
   
   // SELL_LIMIT: ขายที่ราคาสูงกว่าตลาดปัจจุบัน (รอราคาขึ้นมาแล้วขาย)
   // SELL_STOP: ขายเมื่อราคาลดลงถึงระดับที่กำหนด (Stop loss)
   if(PendingPriceValue > currentBid)
   {
      orderType = ORDER_TYPE_SELL_LIMIT; // Sell limit if price is above current Bid
      Print("Using SELL_LIMIT order type (sell at higher price)");
   }
   else
   {
      orderType = ORDER_TYPE_SELL_STOP; // Sell stop if price is below current Bid
      Print("Using SELL_STOP order type (sell when price drops)");
   }
   
   // 6. ใช้ OrderSend() ตรงๆ แทน Trade.OrderSend()
   MqlTradeRequest request = {};
   MqlTradeResult result = {};
   
   request.action = TRADE_ACTION_PENDING;
   request.symbol = _Symbol;
   request.type = orderType;
   request.volume = lotSize;
   request.price = NormalizeDouble(PendingPriceValue, _Digits);
   request.sl = (sl > 0) ? NormalizeDouble(sl, _Digits) : 0;
   request.tp = (tp > 0) ? NormalizeDouble(tp, _Digits) : 0;
   request.comment = "Pending SELL";
   request.type_filling = ORDER_FILLING_IOC;
   request.magic = InpMagicNumber;
   
   // 7. ใช้ Trade.OrderSend() สำหรับการจัดการที่ดีกว่า
   if(Trade.OrderSend(request, result))
   {
      Print("Pending SELL order placed successfully!");
      Print("Ticket: ", result.order, " | Price: ", result.price);
      Alert("Pending SELL order placed successfully!\nTicket: " + IntegerToString(result.order) + "\nPrice: " + DoubleToString(result.price, _Digits));
   }
   else
   {
      Print("Pending SELL failed! Error: ", Trade.ResultRetcodeDescription());
      Alert("Pending SELL failed! Error: " + Trade.ResultRetcodeDescription());
   }
}
//+------------------------------------------------------------------+
//| Execute Pending BUY                                              |
//+------------------------------------------------------------------+
void ExecutePendingBuy()
{
   // 1. อัพเดทค่าจาก Control Panel
   UpdateInputValues();
   
   // 2. Refresh rates ก่อนใช้งาน
   SymbolInfo.RefreshRates();
   
   // 3. ตรวจสอบค่าที่ได้
   if(PendingPriceValue <= 0) 
   {
      Print("Invalid pending price for BUY: ", PendingPriceValue);
      Alert("กรุณากรอกราคาที่ต้องการสำหรับ Pending BUY");
      return;
   }
   
   double lotSize = NormalizeLot(ManualLotSize);
   if(lotSize <= 0) 
   {
      Print("Invalid lot size for Pending BUY: ", ManualLotSize);
      Alert("กรุณากรอกขนาด Lot ที่ถูกต้อง");
      return;
   }
   
   // 4. คำนวณ SL และ TP สำหรับ BUY orders
   // SL ต้องต่ำกว่าราคา entry สำหรับ BUY orders
   double sl = (ManualSLPoints > 0) ? PendingPriceValue - ManualSLPoints * _Point : 0.0;
   double tp = (ManualTPPoints > 0) ? PendingPriceValue + ManualTPPoints * _Point : 0.0;
   
   Print("BUY Order - Entry: ", PendingPriceValue, " | SL: ", sl, " | TP: ", tp);
   
   // 5. กำหนดประเภท Order - BUY logic
   ENUM_ORDER_TYPE orderType;
   double currentAsk = SymbolInfo.Ask(); // ใช้ Ask สำหรับ BUY orders
   
   Print("Current Ask: ", currentAsk, " | Pending Price: ", PendingPriceValue);
   
   // BUY_LIMIT: ซื้อที่ราคาต่ำกว่าตลาดปัจจุบัน (รอราคาลงมาแล้วซื้อ)
   // BUY_STOP: ซื้อเมื่อราคาขึ้นไปถึงระดับที่กำหนด (Breakout)
   if(PendingPriceValue < currentAsk)
   {
      orderType = ORDER_TYPE_BUY_LIMIT; // Buy limit if price is below current Ask
      Print("Using BUY_LIMIT order type (buy at lower price)");
   }
   else
   {
      orderType = ORDER_TYPE_BUY_STOP; // Buy stop if price is above current Ask
      Print("Using BUY_STOP order type (buy when price breaks higher)");
   }
   
   // 6. เตรียม Trade Request
   MqlTradeRequest request = {};
   MqlTradeResult result = {};
   
   request.action = TRADE_ACTION_PENDING;
   request.symbol = _Symbol;
   request.type = orderType;
   request.volume = lotSize;
   request.price = NormalizeDouble(PendingPriceValue, _Digits);
   request.sl = (sl > 0) ? NormalizeDouble(sl, _Digits) : 0;
   request.tp = (tp > 0) ? NormalizeDouble(tp, _Digits) : 0;
   request.comment = "Pending BUY";
   request.type_filling = ORDER_FILLING_IOC;
   request.magic = InpMagicNumber;
   
   // 7. ส่ง Order
   if(Trade.OrderSend(request, result))
   {
      Print("Pending BUY order placed successfully!");
      Print("Ticket: ", result.order, " | Price: ", result.price);
      Alert("Pending BUY order placed successfully!\nTicket: " + IntegerToString(result.order) + "\nPrice: " + DoubleToString(result.price, _Digits));
   }
   else
   {
      Print("Pending BUY failed! Error: ", Trade.ResultRetcodeDescription());
      Alert("Pending BUY failed! Error: " + Trade.ResultRetcodeDescription());
   }
}

//+------------------------------------------------------------------+
//| Cancel All Pending Orders                                        |
//+------------------------------------------------------------------+
void CancelAllPendingOrders()
{
   int totalOrders = OrdersTotal();
   int canceledCount = 0;
   
   for(int i = totalOrders - 1; i >= 0; i--)
   {
      if(OrderInfo.SelectByIndex(i))
      {
         if(OrderInfo.Symbol() == _Symbol && OrderInfo.Magic() == InpMagicNumber)
         {
            ENUM_ORDER_TYPE orderType = OrderInfo.OrderType();
            
            // Check if it's a pending order
            if(orderType == ORDER_TYPE_BUY_LIMIT || orderType == ORDER_TYPE_BUY_STOP ||
               orderType == ORDER_TYPE_SELL_LIMIT || orderType == ORDER_TYPE_SELL_STOP)
            {
               if(Trade.OrderDelete(OrderInfo.Ticket()))
               {
                  Print("Pending order deleted: ", OrderInfo.Ticket());
                  canceledCount++;
               }
            }
         }
      }
   }
   
   if(canceledCount > 0)
   {
      Print("Total pending orders canceled: ", canceledCount);
   }
   else
   {
      Print("No pending orders found to cancel");
   }
}

//+------------------------------------------------------------------+
//| Close All Sell Positions                                         |
//+------------------------------------------------------------------+
void CloseAllSellPositions()
{
   for(int i = PositionsTotal() - 1; i >= 0; i--)
   {
      if(PositionInfo.SelectByIndex(i))
      {
         if(PositionInfo.Symbol() == _Symbol && 
            PositionInfo.Magic() == InpMagicNumber && 
            PositionInfo.PositionType() == POSITION_TYPE_SELL)
         {
            Trade.PositionClose(PositionInfo.Ticket());
            Print("SELL position closed: ", PositionInfo.Ticket());
         }
      }
   }
}

//+------------------------------------------------------------------+
//| Close All Buy Positions                                          |
//+------------------------------------------------------------------+
void CloseAllBuyPositions()
{
   for(int i = PositionsTotal() - 1; i >= 0; i--)
   {
      if(PositionInfo.SelectByIndex(i))
      {
         if(PositionInfo.Symbol() == _Symbol && 
            PositionInfo.Magic() == InpMagicNumber && 
            PositionInfo.PositionType() == POSITION_TYPE_BUY)
         {
            Trade.PositionClose(PositionInfo.Ticket());
            Print("BUY position closed: ", PositionInfo.Ticket());
         }
      }
   }
}

//+------------------------------------------------------------------+
//| Normalize Lot Size                                               |
//+------------------------------------------------------------------+
double NormalizeLot(double lot)
{
   double minLot = SymbolInfo.LotsMin();
   double maxLot = SymbolInfo.LotsMax();
   double lotStep = SymbolInfo.LotsStep();
   
   lot = MathMax(lot, minLot);
   lot = MathMin(lot, maxLot);
   
   if(lotStep > 0)
      lot = MathRound(lot / lotStep) * lotStep;
   
   return NormalizeDouble(lot, 2);
}

//+------------------------------------------------------------------+
//| Update OI Data from Control Panel                                |
//+------------------------------------------------------------------+
void UpdateOIData()
{
   // Get current values from control panel
   UpdateInputValues();
   
   // แสดงข้อมูลที่ได้รับจาก Control Panel
   Print("=== OI Data Update Process ===");
   Print("Manual Future Price Value: ", ManualFuturePriceValue);
   Print("Call Strike Values: ", CallStrike1Value, ", ", CallStrike2Value, ", ", CallStrike3Value);
   Print("Put Strike Values: ", PutStrike1Value, ", ", PutStrike2Value, ", ", PutStrike3Value);
   
   // Validate and update dynamic variables
   if(ManualFuturePriceValue > 0)
   {
      DynamicFuturePrice = ManualFuturePriceValue;
      Print("Updated Dynamic Future Price: ", DynamicFuturePrice);
   }
   else
   {
      Print("Warning: Manual Future Price is 0 or invalid, using previous value: ", DynamicFuturePrice);
   }
   
   // Update OI Strike levels (dynamic variables)
   if(CallStrike1Value >= 0) DynamicCallStrike1 = CallStrike1Value;
   if(CallStrike2Value >= 0) DynamicCallStrike2 = CallStrike2Value;
   if(CallStrike3Value >= 0) DynamicCallStrike3 = CallStrike3Value;
   if(PutStrike1Value >= 0) DynamicPutStrike1 = PutStrike1Value;
   if(PutStrike2Value >= 0) DynamicPutStrike2 = PutStrike2Value;
   if(PutStrike3Value >= 0) DynamicPutStrike3 = PutStrike3Value;
   
   Print("Dynamic Call Strikes: ", DynamicCallStrike1, ", ", DynamicCallStrike2, ", ", DynamicCallStrike3);
   Print("Dynamic Put Strikes: ", DynamicPutStrike1, ", ", DynamicPutStrike2, ", ", DynamicPutStrike3);
   
   // Reinitialize OI levels with new values
   InitializeOILevels();
   InitializeKeyLevels();
   
   Print("OI Data Updated Successfully!");
   
   // Show confirmation
   string message = "OI Data Updated Successfully!\n" +
                   "Future Price: " + DoubleToString(DynamicFuturePrice, _Digits) + "\n" +
                   "Call Strikes: " + DoubleToString(DynamicCallStrike1, _Digits) + ", " + 
                   DoubleToString(DynamicCallStrike2, _Digits) + ", " + DoubleToString(DynamicCallStrike3, _Digits) + "\n" +
                   "Put Strikes: " + DoubleToString(DynamicPutStrike1, _Digits) + ", " + 
                   DoubleToString(DynamicPutStrike2, _Digits) + ", " + DoubleToString(DynamicPutStrike3, _Digits);
   
   Alert(message);
}

//+------------------------------------------------------------------+
//| Initialize OI Levels                                             |
//+------------------------------------------------------------------+
void InitializeOILevels()
{
   //--- Load OI data based on source
   switch(InpOISource)
   {
      case OI_SOURCE_MANUAL:
         // Use dynamic variables first, fall back to input parameters
         CallLevels[0] = (DynamicCallStrike1 > 0) ? DynamicCallStrike1 : InpCallStrike1;
         CallLevels[1] = (DynamicCallStrike2 > 0) ? DynamicCallStrike2 : InpCallStrike2;
         CallLevels[2] = (DynamicCallStrike3 > 0) ? DynamicCallStrike3 : InpCallStrike3;
         
         PutLevels[0] = (DynamicPutStrike1 > 0) ? DynamicPutStrike1 : InpPutStrike1;
         PutLevels[1] = (DynamicPutStrike2 > 0) ? DynamicPutStrike2 : InpPutStrike2;
         PutLevels[2] = (DynamicPutStrike3 > 0) ? DynamicPutStrike3 : InpPutStrike3;
         
         // Default OI values
         CallOI[0] = 1000;
         CallOI[1] = 800;
         CallOI[2] = 600;
         
         PutOI[0] = 1000;
         PutOI[1] = 800;
         PutOI[2] = 600;
         break;
         
      case OI_SOURCE_CSV_FILE:
         LoadOIFromCSV();
         break;
         
      case OI_SOURCE_AUTO_SYNC:
         // Future implementation for auto-sync
         break;
   }
   
   //--- Sort levels in ascending order
   ArraySort(CallLevels);
   ArraySort(PutLevels);
   
   Print("OI Levels Initialized:");
   Print("Call Levels: ", CallLevels[0], ", ", CallLevels[1], ", ", CallLevels[2]);
   Print("Put Levels: ", PutLevels[0], ", ", PutLevels[1], ", ", PutLevels[2]);
}

//+------------------------------------------------------------------+
//| Load OI data from CSV file                                       |
//+------------------------------------------------------------------+
void LoadOIFromCSV()
{
    Print("=== CSV Loading Debug ===");
    Print("Terminal Files dir: ", TerminalInfoString(TERMINAL_DATA_PATH) + "\\MQL5\\Files\\");
    Print("Attempting to open: ", InpOICsvPath);
    
    if(!FileIsExist(InpOICsvPath)) {
       Print("CSV FILE NOT FOUND - check path or if scraper output exists");
       return;
    }
    
    string filename = InpOICsvPath;
    int filehandle = FileOpen(filename, FILE_READ | FILE_ANSI);
    
    if(filehandle == INVALID_HANDLE)
    {
       int err = GetLastError();
       Print("CSV OPEN FAILED [Error ", err, "]: ", err);
       Print("File exists: ", FileIsExist(InpOICsvPath) ? "YES" : "NO");
       InitializeOILevels();
       return;
    }
    
    long fileSize = FileSize(filehandle);
    Print("CSV opened successfully. Size: ", fileSize, " bytes");
    
    int callIndex = 0;
    int putIndex = 0;
    double futurePrice = 0.0;
    bool isFirstLine = true;
    
    while(!FileIsEnding(filehandle))
    {
       string row = FileReadString(filehandle);
       
       Print("DEBUG ROW: [", row, "]");
       
       if(isFirstLine) {
          isFirstLine = false;
          if(StringFind(row, "Type") >= 0 || StringFind(row, "Strike") >= 0 || StringFind(row, "OI") >= 0) {
             continue;
          }
       }
       
       string data[];
       int count = StringSplit(row, ',', data);
       
       if(count >= 3)
       {
          string type = data[0];
          double strike = StringToDouble(data[1]);
          int oi = (int)StringToInteger(data[2]);
          
          if(StringFind(type, "Future") >= 0)
          {
             futurePrice = strike;
             if(!CSVLoadLogged) {
                Print("DEBUG: Parsed Future price: ", futurePrice);
             }
          }
          else if(type == "CALL" && callIndex < 3)
          {
             CallLevels[callIndex] = strike;
             CallOI[callIndex] = oi;
             callIndex++;
             if(!CSVLoadLogged) {
                Print("DEBUG: Found CALL row, strike=", strike, " oi=", oi);
             }
          }
          else if(type == "PUT" && putIndex < 3)
          {
             PutLevels[putIndex] = strike;
             PutOI[putIndex] = oi;
             putIndex++;
             if(!CSVLoadLogged) {
                Print("DEBUG: Found PUT row, strike=", strike, " oi=", oi);
             }
          }
       }
    }
    
    FileClose(filehandle);
    
    for(int i = callIndex; i < 3; i++)
    {
       CallLevels[i] = 0;
       CallOI[i] = 0;
    }
    
    for(int i = putIndex; i < 3; i++)
    {
       PutLevels[i] = 0;
       PutOI[i] = 0;
    }
    
    if(futurePrice > 0) {
       CachedFuturePrice = futurePrice;
       DynamicFuturePrice = futurePrice;
       FuturePrice = futurePrice;
       LoadedCSVPath = filename;
       CSVLoadLogged = true;
       Print("CSV SUCCESS: FuturePrice=", futurePrice, ", CALL=[", CallLevels[0], ",", CallLevels[1], ",", CallLevels[2], "], PUT=[", PutLevels[0], ",", PutLevels[1], ",", PutLevels[2], "] loaded from ", filename);
    } else {
       if(!CSVLoadLogged) {
          Print("CSV ERROR: No valid price found in ", filename);
          CSVLoadLogged = true;
       }
       CachedFuturePrice = 0;
    }
}

//+------------------------------------------------------------------+
//| Initialize Key Levels                                            |
//+------------------------------------------------------------------+
void InitializeKeyLevels()
{
   // Calculate key levels based on OI levels
   if(PutLevels[2] > 0 && CallLevels[2] > 0)
   {
      LevelLower2 = PutLevels[2];  // Lowest put strike
      LevelLower1 = PutLevels[1];  // Middle put strike
      LevelMid = (PutLevels[0] + CallLevels[0]) / 2;  // Mid point
      LevelUpper1 = CallLevels[1];  // Middle call strike
      LevelUpper2 = CallLevels[2];  // Highest call strike
   }
   else
   {
      // Use current price as reference
      double currentPrice = SymbolInfo.Bid();
      LevelLower2 = currentPrice - 500 * _Point;
      LevelLower1 = currentPrice - 250 * _Point;
      LevelMid = currentPrice;
      LevelUpper1 = currentPrice + 250 * _Point;
      LevelUpper2 = currentPrice + 500 * _Point;
   }
}

//+------------------------------------------------------------------+
//| Initialize Indicators                                            |
//+------------------------------------------------------------------+
bool InitializeIndicators()
{
   // ATR for volatility
   ATRHandle = iATR(_Symbol, PERIOD_H1, 14);
   if(ATRHandle == INVALID_HANDLE)
   {
      Print("Error creating ATR indicator");
      return false;
   }
   
   // Moving Averages for trend
   MAFastHandle = iMA(_Symbol, InpTrendTF, InpTrendMAPeriod1, 0, MODE_EMA, PRICE_CLOSE);
   MASlowHandle = iMA(_Symbol, InpTrendTF, InpTrendMAPeriod2, 0, MODE_SMA, PRICE_CLOSE);
   
   if(MAFastHandle == INVALID_HANDLE || MASlowHandle == INVALID_HANDLE)
   {
      Print("Error creating MA indicators");
      return false;
   }
   
   // RSI for momentum (optional)
   RSIMainHandle = iRSI(_Symbol, PERIOD_H1, 14, PRICE_CLOSE);
   
   return true;
}

//+------------------------------------------------------------------+
//| Update Market Data                                               |
//+------------------------------------------------------------------+
bool UpdateMarketData()
{
    // Get current prices
    SpotPrice = SymbolInfo.Bid();
    SymbolInfo.RefreshRates();
    
    // Get future price (CSV cache, manual or from symbol)
    if(CachedFuturePrice > 0)
    {
       FuturePrice = CachedFuturePrice;
    }
    else if(DynamicFuturePrice > 0)
    {
       FuturePrice = DynamicFuturePrice;
    }
    else if(InpManualFuturePrice > 0)
    {
       FuturePrice = InpManualFuturePrice;
    }
    else
    {
       // In real implementation, you might get this from a different symbol
       // For now, use spot price with a small offset
       FuturePrice = SpotPrice;
    }
    
    // Calculate Delta
    double previousDelta = DeltaPrice;
    DeltaPrice = FuturePrice - SpotPrice;
    
    // Update Delta EMA
    UpdateDeltaEMA();
   
   // Calculate Deviation
   DeltaDeviation = DeltaPrice - DeltaEMA;
   
   // Check for zero cross
   if(InpCloseOnZeroDeviation && previousDelta * DeltaPrice < 0)
   {
      CloseAllPositions();
   }
   
   return true;
}

//+------------------------------------------------------------------+
//| Update Delta EMA                                                 |
//+------------------------------------------------------------------+
void UpdateDeltaEMA()
{
   static double ema = 0;
   static bool firstRun = true;
   
   if(firstRun)
   {
      ema = DeltaPrice;
      firstRun = false;
   }
   else
   {
      double alpha = 2.0 / (InpDeltaEmaPeriod + 1.0);
      ema = alpha * DeltaPrice + (1 - alpha) * ema;
   }
   
   DeltaEMA = ema;
}

//+------------------------------------------------------------------+
//| Check Global Trading Conditions                                  |
//+------------------------------------------------------------------+
bool CheckGlobalConditions()
{
   //--- Check if trading is enabled
   if(!TradingEnabled)
   {
      return false;
   }
   
   //--- Check terminal connection
   if(!TerminalInfoInteger(TERMINAL_CONNECTED))
   {
      Print("Terminal not connected");
      return false;
   }
   
   //--- Check trading permission
   if(!TerminalInfoInteger(TERMINAL_TRADE_ALLOWED) || !MQLInfoInteger(MQL_TRADE_ALLOWED))
   {
      Print("Trading not allowed");
      return false;
   }
   
   //--- Check spread limit
   long spread = SymbolInfo.Spread();
   if(spread > InpMaxSpread)
   {
      return false;
   }
   
   //--- Check session time
   if(InpUseSessionFilter && !IsTradingSession())
   {
      return false;
   }
   
   //--- Check news block
   if(NewsBlockActive)
   {
      return false;
   }
   
   //--- Check volatility filter
   if(InpUseATRFilter && !CheckVolatilityFilter())
   {
      return false;
   }
   
   //--- Check daily limits
   if(!CheckDailyLimits())
   {
      TradingEnabled = false;
      Print("Daily limit reached. Trading disabled.");
      return false;
   }
   
   //--- Check equity protection
   if(CheckEquityProtection())
   {
      TradingEnabled = false;
      Print("Equity protection triggered. Trading disabled.");
      return false;
   }
   
   return true;
}

//+------------------------------------------------------------------+
//| Check Trading Session                                            |
//+------------------------------------------------------------------+
bool IsTradingSession()
{
   MqlDateTime timeNow;
   TimeCurrent(timeNow);
   
   int hour = timeNow.hour;
   
   // Check if current hour is within trading session
   if(hour >= InpSessionStartHour && hour < InpSessionEndHour)
   {
      return true;
   }
   
   return false;
}

//+------------------------------------------------------------------+
//| Check Volatility Filter                                          |
//+------------------------------------------------------------------+
bool CheckVolatilityFilter()
{
   double atrValues[];
   ArraySetAsSeries(atrValues, true);
   if(CopyBuffer(ATRHandle, 0, 0, 1, atrValues) < 1)
      return false;
   
   double atr = atrValues[0];
   double atrPercent = (atr / SpotPrice) * 100;
   
   return (atrPercent <= InpMaxATRPercent);
}

//+------------------------------------------------------------------+
//| Check Daily Limits                                               |
//+------------------------------------------------------------------+
bool CheckDailyLimits()
{
   double balance = AccountInfo.Balance();
   double equity = AccountInfo.Equity();
   
   // Check daily loss limit
   if(DailyLoss > 0)
   {
      double lossPercent = (DailyLoss / balance) * 100;
      if(lossPercent >= InpMaxDailyLossPercent)
      {
         Print("Daily loss limit reached: ", lossPercent, "%");
         return false;
      }
   }
   
   // Check daily profit limit
   if(DailyProfit > 0)
   {
      double profitPercent = (DailyProfit / balance) * 100;
      if(profitPercent >= InpMaxDailyProfitPercent)
      {
         Print("Daily profit limit reached: ", profitPercent, "%");
         return false;
      }
   }
   
   // Check consecutive losses
   if(ConsecutiveLosses >= InpMaxConsecutiveLosses && InpDisableAfterMaxLoss)
   {
      Print("Max consecutive losses reached: ", ConsecutiveLosses);
      return false;
   }
   
   // Check daily trade count
   if(DailyTradeCount >= InpMaxDailyTrades)
   {
      Print("Max daily trades reached: ", DailyTradeCount);
      return false;
   }
   
   return true;
}

//+------------------------------------------------------------------+
//| Check Equity Protection                                          |
//+------------------------------------------------------------------+
bool CheckEquityProtection()
{
   double balance = AccountInfo.Balance();
   double equity = AccountInfo.Equity();
   
   if(balance <= 0) return false;
   
   double drawdownPercent = ((balance - equity) / balance) * 100;
   
   if(drawdownPercent >= InpEquityProtectionPercent)
   {
      Print("Equity protection triggered: ", drawdownPercent, "% drawdown");
      CloseAllPositions();
      return true;
   }
   
   return false;
}

//+------------------------------------------------------------------+
//| Check News Events                                                |
//+------------------------------------------------------------------+
void CheckNewsEvents()
{
   // Simplified news check - in real implementation, you would use a news API
   // or economic calendar data
   datetime timeNow = TimeCurrent();
   
   // For now, this is a placeholder function
   // In production, you would implement actual news checking logic here
}

//+------------------------------------------------------------------+
//| Check Trading Signals                                            |
//+------------------------------------------------------------------+
void CheckTradingSignals()
{
   // Don't open new trades if already have position
   if(PositionsTotal() > 0)
   {
      // Check if we should add to position or close
      return;
   }
   
   // Get market phase
   ENUM_MARKET_PHASE marketPhase = GetMarketPhase();
   
   // Check SELL conditions
   if(CheckSellConditions(marketPhase))
   {
      ExecuteSellTrade();
   }
   // Check BUY conditions
   else if(CheckBuyConditions(marketPhase))
   {
      ExecuteBuyTrade();
   }
}

//+------------------------------------------------------------------+
//| Get Market Phase                                                 |
//+------------------------------------------------------------------+
ENUM_MARKET_PHASE GetMarketPhase()
{
   if(!InpUseMarketPhaseFilter)
      return PHASE_NEUTRAL;
   
   double maFast[], maSlow[];
   ArraySetAsSeries(maFast, true);
   ArraySetAsSeries(maSlow, true);
   
   if(CopyBuffer(MAFastHandle, 0, 0, 2, maFast) < 2) return PHASE_NEUTRAL;
   if(CopyBuffer(MASlowHandle, 0, 0, 1, maSlow) < 1) return PHASE_NEUTRAL;
   
   double maFastCurrent = maFast[0];
   double maFastPrevious = maFast[1];
   double maSlowCurrent = maSlow[0];
   
   // Calculate slope
   double slope = maFastCurrent - maFastPrevious;
   
   if(maFastCurrent > maSlowCurrent && slope > 0)
      return PHASE_BULLISH;
   else if(maFastCurrent < maSlowCurrent && slope < 0)
      return PHASE_BEARISH;
   else if(MathAbs(slope) < 0.0001)
      return PHASE_SIDEWAYS;
   else
      return PHASE_NEUTRAL;
}

//+------------------------------------------------------------------+
//| Check SELL Conditions                                            |
//+------------------------------------------------------------------+
bool CheckSellConditions(ENUM_MARKET_PHASE marketPhase)
{
   // 1. Check Delta Deviation
   if(DeltaDeviation <= InpDeviationThreshold * _Point)
      return false;
   
   // 2. Check price near upper OI level
   if(!IsPriceNearLevel(SpotPrice, CallLevels, true))
      return false;
   
   // 3. Check market phase filter
   if(marketPhase == PHASE_BULLISH && InpUseMarketPhaseFilter)
   {
      // Need stronger signal in bullish phase
      if(DeltaDeviation < InpDeviationThreshold * _Point * InpDeviationMultiplier)
         return false;
   }
   
   // 4. Check overbought condition (optional)
   if(!CheckOverbought())
      return false;
   
   // 5. Check if price is at key resistance
   if(!IsAtResistance())
      return false;
   
   return true;
}

//+------------------------------------------------------------------+
//| Check BUY Conditions                                             |
//+------------------------------------------------------------------+
bool CheckBuyConditions(ENUM_MARKET_PHASE marketPhase)
{
   // 1. Check Delta Deviation
   if(DeltaDeviation >= -InpDeviationThreshold * _Point)
      return false;
   
   // 2. Check price near lower OI level
   if(!IsPriceNearLevel(SpotPrice, PutLevels, false))
      return false;
   
   // 3. Check market phase filter
   if(marketPhase == PHASE_BEARISH && InpUseMarketPhaseFilter)
   {
      // Need stronger signal in bearish phase
      if(DeltaDeviation > -InpDeviationThreshold * _Point * InpDeviationMultiplier)
         return false;
   }
   
   // 4. Check oversold condition (optional)
   if(!CheckOversold())
      return false;
   
   // 5. Check if price is at key support
   if(!IsAtSupport())
      return false;
   
   return true;
}

//+------------------------------------------------------------------+
//| Check if price is near OI level                                  |
//+------------------------------------------------------------------+
bool IsPriceNearLevel(double price, double &levels[], bool isUpper)
{
   double tolerance = 50 * _Point; // 50 points tolerance
   
   for(int i = 0; i < ArraySize(levels); i++)
   {
      if(levels[i] <= 0) continue;
      
      if(isUpper)
      {
         // For upper levels, price should be at or above the level
         if(price >= levels[i] - tolerance && price <= levels[i] + tolerance)
            return true;
      }
      else
      {
         // For lower levels, price should be at or below the level
         if(price >= levels[i] - tolerance && price <= levels[i] + tolerance)
            return true;
      }
   }
   
   return false;
}

//+------------------------------------------------------------------+
//| Check overbought condition                                       |
//+------------------------------------------------------------------+
bool CheckOverbought()
{
   // Simple RSI check
   if(RSIMainHandle != INVALID_HANDLE)
   {
      double rsiValues[];
      ArraySetAsSeries(rsiValues, true);
      if(CopyBuffer(RSIMainHandle, 0, 0, 1, rsiValues) >= 1)
      {
         if(rsiValues[0] < 70) // Not overbought
            return false;
      }
   }
   
   return true;
}

//+------------------------------------------------------------------+
//| Check oversold condition                                         |
//+------------------------------------------------------------------+
bool CheckOversold()
{
   // Simple RSI check
   if(RSIMainHandle != INVALID_HANDLE)
   {
      double rsiValues[];
      ArraySetAsSeries(rsiValues, true);
      if(CopyBuffer(RSIMainHandle, 0, 0, 1, rsiValues) >= 1)
      {
         if(rsiValues[0] > 30) // Not oversold
            return false;
      }
   }
   
   return true;
}

//+------------------------------------------------------------------+
//| Check if price is at resistance                                  |
//+------------------------------------------------------------------+
bool IsAtResistance()
{
   // Check if price is near upper key levels
   double tolerance = 100 * _Point;
   
   if(MathAbs(SpotPrice - LevelUpper1) <= tolerance ||
      MathAbs(SpotPrice - LevelUpper2) <= tolerance)
   {
      return true;
   }
   
   return false;
}

//+------------------------------------------------------------------+
//| Check if price is at support                                     |
//+------------------------------------------------------------------+
bool IsAtSupport()
{
   // Check if price is near lower key levels
   double tolerance = 100 * _Point;
   
   if(MathAbs(SpotPrice - LevelLower1) <= tolerance ||
      MathAbs(SpotPrice - LevelLower2) <= tolerance)
   {
      return true;
   }
   
   return false;
}

//+------------------------------------------------------------------+
//| Execute SELL Trade                                               |
//+------------------------------------------------------------------+
void ExecuteSellTrade()
{
   double lotSize = CalculateLotSize(POSITION_TYPE_SELL);
   if(lotSize <= 0)
      return;
   
   double sl = CalculateStopLoss(POSITION_TYPE_SELL, SpotPrice);
   double tp = CalculateTakeProfit(POSITION_TYPE_SELL, SpotPrice);
   
   // Send sell order
   if(Trade.Sell(lotSize, _Symbol, SpotPrice, sl, tp, "OI Mean Reversion SELL"))
   {
      DailyTradeCount++;
      LastTradeTime = TimeCurrent();
      Print("SELL order executed. Lot: ", lotSize, " Price: ", SpotPrice);
   }
   else
   {
      Print("SELL order failed. Error: ", Trade.ResultRetcodeDescription());
   }
}

//+------------------------------------------------------------------+
//| Execute BUY Trade                                                |
//+------------------------------------------------------------------+
void ExecuteBuyTrade()
{
   double lotSize = CalculateLotSize(POSITION_TYPE_BUY);
   if(lotSize <= 0)
      return;
   
   double sl = CalculateStopLoss(POSITION_TYPE_BUY, SpotPrice);
   double tp = CalculateTakeProfit(POSITION_TYPE_BUY, SpotPrice);
   
   // Send buy order
   if(Trade.Buy(lotSize, _Symbol, SpotPrice, sl, tp, "OI Mean Reversion BUY"))
   {
      DailyTradeCount++;
      LastTradeTime = TimeCurrent();
      Print("BUY order executed. Lot: ", lotSize, " Price: ", SpotPrice);
   }
   else
   {
      Print("BUY order failed. Error: ", Trade.ResultRetcodeDescription());
   }
}

//+------------------------------------------------------------------+
//| Calculate Lot Size                                               |
//+------------------------------------------------------------------+
double CalculateLotSize(ENUM_POSITION_TYPE tradeType)
{
   if(!InpUseMoneyManagement)
      return NormalizeLot(InpLotSize);
   
   double balance = AccountInfo.Balance();
   double riskAmount = balance * (InpRiskPercent / 100.0);
   
   double stopLossPrice = CalculateStopLoss(tradeType, SpotPrice);
   double stopLossPoints = MathAbs(SpotPrice - stopLossPrice) / _Point;
   
   double tickValue = SymbolInfo.TickValue();
   double lotSize = riskAmount / (stopLossPoints * tickValue);
   
   return NormalizeLot(lotSize);
}

//+------------------------------------------------------------------+
//| Calculate Stop Loss                                              |
//+------------------------------------------------------------------+
double CalculateStopLoss(ENUM_POSITION_TYPE tradeType, double entryPrice)
{
   if(!InpUseStopLoss)
      return 0.0;
   
   double slPoints = InpStopLossPoints * _Point;
   
   if(tradeType == POSITION_TYPE_BUY)
      return entryPrice - slPoints;
   else
      return entryPrice + slPoints;
}

//+------------------------------------------------------------------+
//| Calculate Take Profit                                            |
//+------------------------------------------------------------------+
double CalculateTakeProfit(ENUM_POSITION_TYPE tradeType, double entryPrice)
{
   if(!InpUseTakeProfit)
      return 0.0;
   
   double tpPoints = InpTakeProfitPoints * _Point;
   
   if(tradeType == POSITION_TYPE_BUY)
      return entryPrice + tpPoints;
   else
      return entryPrice - tpPoints;
}

//+------------------------------------------------------------------+
//| Manage Positions                                                 |
//+------------------------------------------------------------------+
void ManagePositions()
{
   for(int i = PositionsTotal() - 1; i >= 0; i--)
   {
      if(PositionInfo.SelectByIndex(i))
      {
         if(PositionInfo.Symbol() == _Symbol && PositionInfo.Magic() == InpMagicNumber)
         {
            // Check for trailing stop
            if(InpUseTrailingStop)
            {
               ApplyTrailingStop(i);
            }
            
            // Check for soft stop loss
            if(InpUseSoftStopLoss)
            {
               CheckSoftStopLoss(i);
            }
            
            // Check for take profit at mid level
            CheckMidLevelExit(i);
         }
      }
   }
}

//+------------------------------------------------------------------+
//| Apply Trailing Stop                                              |
//+------------------------------------------------------------------+
void ApplyTrailingStop(int positionIndex)
{
   if(!PositionInfo.SelectByIndex(positionIndex))
      return;
   
   double currentPrice = PositionInfo.PositionType() == POSITION_TYPE_BUY ? 
                         SymbolInfo.Bid() : SymbolInfo.Ask();
   
   double openPrice = PositionInfo.PriceOpen();
   double currentSL = PositionInfo.StopLoss();
   double pointsProfit = MathAbs(currentPrice - openPrice) / _Point;
   
   if(pointsProfit > InpTrailingStartPoints)
   {
      double newSL = 0;
      double trailPoints = InpTrailingStepPoints * _Point;
      
      if(PositionInfo.PositionType() == POSITION_TYPE_BUY)
      {
         newSL = currentPrice - trailPoints;
         if(newSL > currentSL && newSL > openPrice)
         {
            Trade.PositionModify(_Symbol, newSL, PositionInfo.TakeProfit());
         }
      }
      else
      {
         newSL = currentPrice + trailPoints;
         if(newSL < currentSL && newSL < openPrice)
         {
            Trade.PositionModify(_Symbol, newSL, PositionInfo.TakeProfit());
         }
      }
   }
}

//+------------------------------------------------------------------+
//| Check Soft Stop Loss                                             |
//+------------------------------------------------------------------+
void CheckSoftStopLoss(int positionIndex)
{
   if(!PositionInfo.SelectByIndex(positionIndex))
      return;
   
   double currentPrice = PositionInfo.PositionType() == POSITION_TYPE_BUY ? 
                         SymbolInfo.Bid() : SymbolInfo.Ask();
   
   double stopLossPrice = CalculateStopLoss(PositionInfo.PositionType(), 
                                           PositionInfo.PriceOpen());
   
   if((PositionInfo.PositionType() == POSITION_TYPE_BUY && currentPrice <= stopLossPrice) ||
      (PositionInfo.PositionType() == POSITION_TYPE_SELL && currentPrice >= stopLossPrice))
   {
      Trade.PositionClose(_Symbol);
      ConsecutiveLosses++;
      DailyLoss += PositionInfo.Profit();
   }
}

//+------------------------------------------------------------------+
//| Check Mid Level Exit                                             |
//+------------------------------------------------------------------+
void CheckMidLevelExit(int positionIndex)
{
   if(!PositionInfo.SelectByIndex(positionIndex))
      return;
   
   double currentPrice = PositionInfo.PositionType() == POSITION_TYPE_BUY ? 
                         SymbolInfo.Bid() : SymbolInfo.Ask();
   
   // Close if price reaches mid level
   if(MathAbs(currentPrice - LevelMid) <= 10 * _Point)
   {
      Trade.PositionClosePartial(_Symbol, PositionInfo.Volume() * 0.5); // Close half
   }
}

//+------------------------------------------------------------------+
//| Close All Positions                                              |
//+------------------------------------------------------------------+
void CloseAllPositions()
{
   for(int i = PositionsTotal() - 1; i >= 0; i--)
   {
      if(PositionInfo.SelectByIndex(i))
      {
         if(PositionInfo.Symbol() == _Symbol && PositionInfo.Magic() == InpMagicNumber)
         {
            Trade.PositionClose(_Symbol);
         }
      }
   }
}

//+------------------------------------------------------------------+
//| Check Existing Positions (Auto Recovery)                         |
//+------------------------------------------------------------------+
void CheckExistingPositions()
{
   int count = 0;
   for(int i = 0; i < PositionsTotal(); i++)
   {
      if(PositionInfo.SelectByIndex(i))
      {
         if(PositionInfo.Symbol() == _Symbol && PositionInfo.Magic() == InpMagicNumber)
         {
            count++;
            Print("Found existing position #", i+1, 
                  " Type: ", EnumToString(PositionInfo.PositionType()),
                  " Volume: ", PositionInfo.Volume(),
                  " Profit: ", PositionInfo.Profit());
         }
      }
   }
   
   if(count > 0)
   {
      Print("Auto-recovery: ", count, " positions restored");
   }
}

//+------------------------------------------------------------------+
//| Check Daily Reset                                                |
//+------------------------------------------------------------------+
void CheckDailyReset()
{
   MqlDateTime timeNow, lastReset;
   TimeCurrent(timeNow);
   TimeToStruct(LastResetDate, lastReset);
   
   if(timeNow.day != lastReset.day || 
      timeNow.mon != lastReset.mon || 
      timeNow.year != lastReset.year)
   {
      // New day, reset statistics
      DailyTradeCount = 0;
      DailyPnL = 0.0;
      DailyProfit = 0.0;
      DailyLoss = 0.0;
      ConsecutiveLosses = 0;
      LastResetDate = TimeCurrent();
      TradingEnabled = true;
      
      Print("Daily statistics reset");
   }
}

//+------------------------------------------------------------------+
//| Create Dashboard                                                 |
//+------------------------------------------------------------------+
void CreateDashboard()
{
   // Create main panel - ตั้งค่า Z-Order ให้สูงขึ้น
   CreatePanel("MainPanel", 10, 20, 850, 180, PanelColor, BORDER_SUNKEN);
   
   // Create section panels - ตั้งค่า Z-Order ให้สูงขึ้น และ BACK = false
   CreatePanel("PricePanel", 20, 30, 260, 70, C'40,40,40', BORDER_FLAT);
   CreatePanel("DeltaPanel", 290, 30, 260, 70, C'40,40,40', BORDER_FLAT);
   CreatePanel("LevelsPanel", 560, 30, 290, 70, C'40,40,40', BORDER_FLAT);
   
   CreatePanel("StatsPanel", 20, 110, 410, 80, C'40,40,40', BORDER_FLAT);
   CreatePanel("TradingPanel", 440, 110, 410, 80, C'40,40,40', BORDER_FLAT);
   
   // Initial labels
   UpdateDashboard();
}

//+------------------------------------------------------------------+
//| Update Dashboard                                                 |
//+------------------------------------------------------------------+
void UpdateDashboard()
{
   // Calculate metrics
   double balance = AccountInfo.Balance();
   double equity = AccountInfo.Equity();
   double dailyGainPercent = balance > 0 ? ((equity - balance) / balance) * 100 : 0;
   double maxDD = balance > 0 ? ((balance - equity) / balance) * 100 : 0;
   
   // Get ATR
   double atrValues[];
   ArraySetAsSeries(atrValues, true);
   double atr = 0;
   double atrPercent = 0;
   if(CopyBuffer(ATRHandle, 0, 0, 1, atrValues) >= 1)
   {
      atr = atrValues[0];
      atrPercent = (atr / SpotPrice) * 100;
   }
   
   // Get market phase
   string marketPhase = GetMarketPhaseString();
   color phaseColor = GetMarketPhaseColor();
   
   // Calculate distances to key levels
   double distToUpper = LevelUpper2 > 0 ? ((LevelUpper2 - SpotPrice) / SpotPrice) * 100 : 0;
   double distToLower = LevelLower2 > 0 ? ((SpotPrice - LevelLower2) / SpotPrice) * 100 : 0;
   
   // Find nearest OI levels
   double nearestCall = FindNearestLevel(SpotPrice, CallLevels, true);
   double nearestPut = FindNearestLevel(SpotPrice, PutLevels, false);
   
   // Price Section
   UpdateLabel("PriceTitle", 30, 35, "PRICE INFORMATION", clrYellow, 10);
   UpdateLabel("SpotPrice", 30, 55, "Spot: " + DoubleToString(SpotPrice, _Digits), TextColor, 9);
   UpdateLabel("FuturePrice", 30, 70, "Future: " + DoubleToString(FuturePrice, _Digits), TextColor, 9);
   UpdateLabel("Spread", 150, 55, "Spread: " + IntegerToString((int)SymbolInfo.Spread()), TextColor, 9);
   
   // Delta Section
   UpdateLabel("DeltaTitle", 300, 35, "DELTA & DEVIATION", clrYellow, 10);
   UpdateLabel("DeltaValue", 300, 55, "ΔPrice: " + DoubleToString(DeltaPrice, 4), 
               DeltaPrice > 0 ? clrLime : clrRed, 9);
   UpdateLabel("DeltaEMA", 300, 70, "ΔEMA: " + DoubleToString(DeltaEMA, 4), TextColor, 9);
   UpdateLabel("Deviation", 420, 55, "Deviation: " + DoubleToString(DeltaDeviation/_Point, 1) + " pts", 
               MathAbs(DeltaDeviation) > InpDeviationThreshold * _Point ? WarningColor : TextColor, 9);
   
   // Levels Section
   UpdateLabel("LevelsTitle", 570, 35, "OI & KEY LEVELS", clrYellow, 10);
   UpdateLabel("NearestCALL", 570, 55, "Nearest CALL: " + (nearestCall>0?DoubleToString(nearestCall, _Digits):"N/A"), clrCyan, 9);
   UpdateLabel("NearestPUT", 570, 70, "Nearest PUT: " + (nearestPut>0?DoubleToString(nearestPut, _Digits):"N/A"), clrCyan, 9);
   UpdateLabel("DistUpper", 725, 55, "%Far Upper: " + DoubleToString(distToUpper, 2), TextColor, 9);
   UpdateLabel("DistLower", 725, 70, "%Far Lower: " + DoubleToString(distToLower, 2), TextColor, 9);
   
   // Statistics Section
   UpdateLabel("StatsTitle", 30, 115, "STATISTICS", clrYellow, 10);
   UpdateLabel("DailyTrades", 30, 135, "Trades Today: " + IntegerToString(DailyTradeCount), TextColor, 9);
   UpdateLabel("DailyGain", 30, 150, "%Gain: " + DoubleToString(dailyGainPercent, 2), 
               dailyGainPercent >= 0 ? ProfitColor : LossColor, 9);
   UpdateLabel("MaxDD", 30, 165, "%Max DD: " + DoubleToString(maxDD, 2), 
               maxDD > 5 ? WarningColor : TextColor, 9);
   UpdateLabel("ConsecLosses", 180, 135, "Consec. Losses: " + IntegerToString(ConsecutiveLosses), 
               ConsecutiveLosses > 0 ? WarningColor : TextColor, 9);
   UpdateLabel("DailyProfit", 180, 150, "Daily P/L: " + DoubleToString(DailyProfit + DailyLoss, 2), 
               (DailyProfit + DailyLoss) >= 0 ? ProfitColor : LossColor, 9);
   
   // Trading Section
   UpdateLabel("TradingTitle", 450, 115, "TRADING STATUS", clrYellow, 10);
   UpdateLabel("MarketPhase", 450, 135, "Market: " + marketPhase, phaseColor, 9);
   UpdateLabel("TradingStatus", 450, 150, "Status: " + (TradingEnabled ? "ACTIVE" : "DISABLED"), 
               TradingEnabled ? clrLime : clrRed, 9);
   UpdateLabel("ATRPercent", 450, 165, "ATR%: " + DoubleToString(atrPercent, 2), 
               atrPercent > InpMaxATRPercent ? WarningColor : TextColor, 9);
   
   // Active Position
   string posInfo = "No Active Position";
   color posColor = clrGray;
   double posProfit = 0;
   
   if(PositionsTotal() > 0)
   {
      for(int i = 0; i < PositionsTotal(); i++)
      {
         if(PositionInfo.SelectByIndex(i))
         {
            if(PositionInfo.Symbol() == _Symbol && PositionInfo.Magic() == InpMagicNumber)
            {
               posInfo = PositionInfo.PositionType() == POSITION_TYPE_BUY ? 
                         "LONG (" + DoubleToString(PositionInfo.Volume(), 2) + ")" : 
                         "SHORT (" + DoubleToString(PositionInfo.Volume(), 2) + ")";
               posColor = PositionInfo.PositionType() == POSITION_TYPE_BUY ? clrLime : clrRed;
               posProfit = PositionInfo.Profit();
               break;
            }
         }
      }
   }
   
   UpdateLabel("PositionInfo", 600, 135, "Position: " + posInfo, posColor, 9);
   UpdateLabel("PositionProfit", 600, 150, "P/L: " + DoubleToString(posProfit, 2), 
               posProfit >= 0 ? ProfitColor : LossColor, 9);
   
   // News Block Warning
   if(NewsBlockActive)
   {
      UpdateLabel("NewsWarning", 600, 165, "NEWS BLOCK ACTIVE", clrRed, 9);
   }
   else
   {
      ObjectDelete(chart_id, "NewsWarning");
   }
}

//+------------------------------------------------------------------+
//| Update Label                                                     |
//+------------------------------------------------------------------+
void UpdateLabel(string name, int x, int y, string text, color clr, int fontSize = 9)
{
   if(ObjectFind(chart_id, name) < 0)
   {
      ObjectCreate(chart_id, name, OBJ_LABEL, 0, 0, 0);
      ObjectSetInteger(chart_id, name, OBJPROP_XDISTANCE, x);
      ObjectSetInteger(chart_id, name, OBJPROP_YDISTANCE, y);
      ObjectSetInteger(chart_id, name, OBJPROP_COLOR, clr);
      ObjectSetInteger(chart_id, name, OBJPROP_FONTSIZE, fontSize);
      ObjectSetString(chart_id, name, OBJPROP_FONT, "Consolas");
      ObjectSetInteger(chart_id, name, OBJPROP_BACK, false);
      ObjectSetInteger(chart_id, name, OBJPROP_SELECTABLE, false);
      ObjectSetInteger(chart_id, name, OBJPROP_HIDDEN, true);
      // ตั้งค่า Z-Order ให้สูง
      ObjectSetInteger(chart_id, name, OBJPROP_ZORDER, 1002);
   }
   
   ObjectSetString(chart_id, name, OBJPROP_TEXT, text);
   ObjectSetInteger(chart_id, name, OBJPROP_COLOR, clr);
}

//+------------------------------------------------------------------+
//| Find Nearest Level                                               |
//+------------------------------------------------------------------+
double FindNearestLevel(double price, double &levels[], bool findAbove)
{
   double nearest = 0;
   double minDist = DBL_MAX;
   
   for(int i = 0; i < ArraySize(levels); i++)
   {
      if(levels[i] <= 0) continue;
      
      double dist = MathAbs(price - levels[i]);
      
      if(findAbove)
      {
         if(levels[i] >= price && dist < minDist)
         {
            minDist = dist;
            nearest = levels[i];
         }
      }
      else
      {
         if(levels[i] <= price && dist < minDist)
         {
            minDist = dist;
            nearest = levels[i];
         }
      }
   }
   
   return nearest;
}

//+------------------------------------------------------------------+
//| Get Market Phase String                                          |
//+------------------------------------------------------------------+
string GetMarketPhaseString()
{
   ENUM_MARKET_PHASE phase = GetMarketPhase();
   
   switch(phase)
   {
      case PHASE_BULLISH: return "Bullish";
      case PHASE_BEARISH: return "Bearish";
      case PHASE_SIDEWAYS: return "Sideways";
      default: return "Neutral";
   }
}

//+------------------------------------------------------------------+
//| Get Market Phase Color                                           |
//+------------------------------------------------------------------+
color GetMarketPhaseColor()
{
   ENUM_MARKET_PHASE phase = GetMarketPhase();
   
   switch(phase)
   {
      case PHASE_BULLISH: return clrLime;
      case PHASE_BEARISH: return clrRed;
      case PHASE_SIDEWAYS: return clrYellow;
      default: return clrGray;
   }
}

//+------------------------------------------------------------------+
//| String Split Function                                            |
//+------------------------------------------------------------------+
int StringSplit(string text, string delimiter, string &result[])
{
   int count = 0;
   int pos = 0;
   int len = StringLen(delimiter);
   
   while(pos < StringLen(text))
   {
      int nextPos = StringFind(text, delimiter, pos);
      if(nextPos == -1) nextPos = StringLen(text);
      
      string substr = StringSubstr(text, pos, nextPos - pos);
      ArrayResize(result, count + 1);
      result[count] = substr;
      count++;
      
      pos = nextPos + len;
   }
   
   return count;
}
//+------------------------------------------------------------------+