`//+------------------------------------------------------------------+
//| Smart_Money_Concepts_Lux.mq5 |
//| Copyright 2023, MetaQuotes Software Corp. |
//| https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2023, MetaQuotes Software Corp."
#property link "https://www.mql5.com"
#property version "1.00"

#property indicator_chart_window
#property indicator_buffers 0
#property indicator_plots 0

//--- Define maximum number of objects to draw
#define MAX_LABELS 500
#define MAX_LINES 500
#define MAX_BOXES 500

//--- Input parameters
input group "Smart Money Concepts"
input string Mode = "Historical"; // Historical or Present
input string Style = "Colored"; // Colored or Monochrome
input bool ShowTrend = false; // Color Candles

input group "Real Time Internal Structure"
input bool ShowInternals = true; // Show Internal Structure
input string ShowIBull = "All"; // Bullish Structure: All, BOS, CHoCH
input color SwingIBullCss = clrDarkGreen;
input string ShowIBear = "All"; // Bearish Structure: All, BOS, CHoCH
input color SwingIBearCss = clrRed;
input bool FilterConfluence = false; // Confluence Filter

input group "Real Time Swing Structure"
input bool ShowStructure = true; // Show Swing Structure
input string ShowBull = "All"; // Bullish Structure: All, BOS, CHoCH
input color SwingBullCss = clrDarkGreen;
input string ShowBear = "All"; // Bearish Structure: All, BOS, CHoCH
input color SwingBearCss = clrRed;
input bool ShowSwings = false; // Show Swings Points
input int Length = 50; // Length for swing detection
input bool ShowHLSwings = true; // Show Strong/Weak High/Low

input group "Order Blocks"
input bool ShowIOB = true; // Internal Order Blocks
input int IOBShowLast = 5; // Number of internal order blocks to display
input bool ShowOB = false; // Swing Order Blocks
input int OBShowLast = 5; // Number of swing order blocks to display
input string OBFilter = "Atr"; // Order Block Filter: Atr, Cumulative Mean Range
input bool OBHighlightMit = true; // Highlight Mitigated Order blocks
input color IBullObCss = C'52,121,245,204'; // Internal Bullish OB with transparency
input color IBullmObCss = C'99,99,99,204'; // Internal Bullish Mitigated OB
input color IBearObCss = C'247,124,128,204'; // Internal Bearish OB with transparency
input color IBearmObCss = C'99,99,99,204'; // Internal Bearish Mitigated OB
input color BullObCss = C'24,72,204,204'; // Bullish OB with transparency
input color BullmObCss = C'99,99,99,204'; // Bullish Mitigated OB
input color BearObCss = C'178,40,51,204'; // Bearish OB with transparency
input color BearmObCss = C'99,99,99,204'; // Bearish Mitigated OB

input group "EQH/EQL"
input bool ShowEQ = true; // Equal High/Low
input int EQLen = 3; // Bars Confirmation
input float EQThreshold = 0.1; // Threshold

input group "Fair Value Gaps"
input bool ShowFVG = false; // Fair Value Gaps
input bool FVGAuto = true; // Auto Threshold
input string FVGTF = ""; // Timeframe
input color BullFvgCss = C'0,255,104,178'; // Bullish FVG with transparency
input color BearFvgCss = C'255,0,8,178'; // Bearish FVG with transparency
input int FVGExtend = 1; // Extend FVG

input group "Highs & Lows MTF"
input bool ShowPDHL = false; // Daily
input string PDHLStyle = "⎯⎯⎯"; // Style: ⎯⎯⎯, ----, ····
input color PDHLCss = clrDodgerBlue;
input bool ShowPWHL = false; // Weekly
input string PWHLStyle = "⎯⎯⎯"; // Style: ⎯⎯⎯, ----, ····
input color PWHLCss = clrDodgerBlue;
input bool ShowPMHL = false; // Monthly
input string PMHLStyle = "⎯⎯⎯"; // Style: ⎯⎯⎯, ----, ····
input color PMHLCss = clrDodgerBlue;

input group "Premium & Discount Zones"
input bool ShowSD = false; // Premium/Discount Zones
input color PremiumCss = clrRed;
input color EqCss = C'178,181,190'; // Equilibrium Zone
input color DiscountCss = clrDarkGreen;

//--- Global variables
int trend;
int itrend;

double top_y;
int top_x;
double btm_y;
int btm_x;

double itop_y;
int itop_x;
double ibtm_y;
int ibtm_x;

double trail_up;
double trail_dn;
int trail_up_x;
int trail_dn_x;

bool top_cross;
bool btm_cross;
bool itop_cross;
bool ibtm_cross;

string txt_top;
string txt_btm;

//--- Arrays for order blocks
double iob_top[];
double iob_btm[];
datetime iob_left[];
datetime iob_right[];
int iob_type[];
int iob_mit[];

double ob_top[];
double ob_btm[];
datetime ob_left[];
datetime ob_right[];
int ob_type[];
int ob_mit[];

//--- ATR handle and buffer
int atr_handle;
double atr_buffer[];

//--- Alert variables
bool bull_choch_alert;
bool bull_bos_alert;
bool bear_choch_alert;
bool bear_bos_alert;
bool bull_ichoch_alert;
bool bull_ibos_alert;
bool bear_ichoch_alert;
bool bear_ibos_alert;
bool bull_iob_mit;
bool bear_iob_mit;
bool bull_ob_mit;
bool bear_ob_mit;
bool bull_iob_break;
bool bear_iob_break;
bool bull_ob_break;
bool bear_ob_break;
bool eqh_alert;
bool eql_alert;
bool bullish_fvg_cnd;
bool bearish_fvg_cnd;

//--- FVG variables
double bullish_fvg_max[];
double bullish_fvg_min[];
datetime bullish_fvg_time[];
double bearish_fvg_max[];
double bearish_fvg_min[];
datetime bearish_fvg_time[];

//--- EQH/EQL variables
double eq_prev_top;
int eq_top_x;
double eq_prev_btm;
int eq_btm_x;

//+------------------------------------------------------------------+
//| Custom indicator initialization function |
//+------------------------------------------------------------------+
int OnInit()
{
//--- Set indicator to calculate on all ticks
IndicatorSetInteger(INDICATOR_CALCULATIONS, -1);

//--- Initialize arrays
ArrayResize(iob_top, MAX_BOXES);
ArrayResize(iob_btm, MAX_BOXES);
ArrayResize(iob_left, MAX_BOXES);
ArrayResize(iob_right, MAX_BOXES);
ArrayResize(iob_type, MAX_BOXES);
ArrayResize(iob_mit, MAX_BOXES);

ArrayResize(ob_top, MAX_BOXES);
ArrayResize(ob_btm, MAX_BOXES);
ArrayResize(ob_left, MAX_BOXES);
ArrayResize(ob_right, MAX_BOXES);
ArrayResize(ob_type, MAX_BOXES);
ArrayResize(ob_mit, MAX_BOXES);

//--- Initialize FVG arrays
ArrayResize(bullish_fvg_max, MAX_BOXES);
ArrayResize(bullish_fvg_min, MAX_BOXES);
ArrayResize(bullish_fvg_time, MAX_BOXES);
ArrayResize(bearish_fvg_max, MAX_BOXES);
ArrayResize(bearish_fvg_min, MAX_BOXES);
ArrayResize(bearish_fvg_time, MAX_BOXES);

//--- Initialize ATR
atr_handle = iATR(_Symbol, _Period, 200);
if(atr_handle == INVALID_HANDLE)
{
Print("Error creating ATR indicator handle: ", GetLastError());
return(INIT_FAILED);
}

//--- Set ATR buffer
ArraySetAsSeries(atr_buffer, true);

//--- Initialize variables
trend = 0;
itrend = 0;
top_cross = true;
btm_cross = true;
itop_cross = true;
ibtm_cross = true;
eq_prev_top = 0;
eq_top_x = 0;
eq_prev_btm = 0;
eq_btm_x = 0;

//--- Initialize alert variables
bull_choch_alert = false;
bull_bos_alert = false;
bear_choch_alert = false;
bear_bos_alert = false;
bull_ichoch_alert = false;
bull_ibos_alert = false;
bear_ichoch_alert = false;
bear_ibos_alert = false;
bull_iob_mit = false;
bear_iob_mit = false;
bull_ob_mit = false;
bear_ob_mit = false;
bull_iob_break = false;
bear_iob_break = false;
bull_ob_break = false;
bear_ob_break = false;
eqh_alert = false;
eql_alert = false;
bullish_fvg_cnd = false;
bearish_fvg_cnd = false;

return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Custom indicator deinitialization function |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
//--- Delete all objects created by the indicator
ObjectsDeleteAll(0, "StructureLine_");
ObjectsDeleteAll(0, "StructureLabel_");
ObjectsDeleteAll(0, "IOB_");
ObjectsDeleteAll(0, "OB_");
ObjectsDeleteAll(0, "EQH_");
ObjectsDeleteAll(0, "EQL_");
ObjectsDeleteAll(0, "FVG_");
ObjectsDeleteAll(0, "PDHL_");
ObjectsDeleteAll(0, "PWHL_");
ObjectsDeleteAll(0, "PMHL_");
ObjectsDeleteAll(0, "Premium_");
ObjectsDeleteAll(0, "Equilibrium_");
ObjectsDeleteAll(0, "Discount_");

//--- Release indicator handle
if(atr_handle != INVALID_HANDLE)
IndicatorRelease(atr_handle);
}

//+------------------------------------------------------------------+
//| Helper function to detect swings (pivot highs and lows) |
//+------------------------------------------------------------------+
void DetectSwings(int length, double &top, double &btm)
{
double high[], low[];
ArraySetAsSeries(high, true);
ArraySetAsSeries(low, true);

CopyHigh(_Symbol, _Period, 0, length2, high);
CopyLow(_Symbol, _Period, 0, length2, low);

double upper = high[ArrayMaximum(high, 0, length)];
double lower = low[ArrayMinimum(low, 0, length)];

static int os = 0;

if(high[length] > upper)
os = 0;
else if(low[length] < lower)
os = 1;

if(os == 0 && os != 1)
top = high[length];
else
top = 0;

if(os == 1 && os != 0)
btm = low[length];
else
btm = 0;
}

//+------------------------------------------------------------------+
//| Helper function to draw structure lines and labels |
//+------------------------------------------------------------------+
void DrawStructure(datetime x, double y, string txt, color clr, bool dashed, bool down, string size)
{
//--- Create line
string line_name = "StructureLine_" + IntegerToString(ChartID()) + "_" + TimeToString(TimeCurrent());
ObjectCreate(0, line_name, OBJ_TREND, 0, x, y, TimeCurrent(), y);
ObjectSetInteger(0, line_name, OBJPROP_COLOR, clr);
ObjectSetInteger(0, line_name, OBJPROP_STYLE, dashed ? STYLE_DASH : STYLE_SOLID);
ObjectSetInteger(0, line_name, OBJPROP_WIDTH, 1);
ObjectSetInteger(0, line_name, OBJPROP_RAY_RIGHT, false);

//--- Create label
string label_name = "StructureLabel_" + IntegerToString(ChartID()) + "_" + TimeToString(TimeCurrent());
ObjectCreate(0, label_name, OBJ_TEXT, 0, x, y);
ObjectSetString(0, label_name, OBJPROP_TEXT, txt);
ObjectSetInteger(0, label_name, OBJPROP_COLOR, clr);

//--- Set label size
int label_size;
if(size == "Tiny")
label_size = 7;
else if(size == "Small")
label_size = 9;
else // Normal
label_size = 11;

ObjectSetInteger(0, label_name, OBJPROP_FONTSIZE, label_size);

//--- Set label anchor
if(down)
ObjectSetInteger(0, label_name, OBJPROP_ANCHOR, ANCHOR_UPPER);
else
ObjectSetInteger(0, label_name, OBJPROP_ANCHOR, ANCHOR_LOWER);

//--- Delete objects in "Present" mode
if(Mode == "Present")
{
ObjectDelete(0, line_name);
ObjectDelete(0, label_name);
}
}

//+------------------------------------------------------------------+
//| Helper function to get order block coordinates |
//+------------------------------------------------------------------+
void OBCoord(bool useMax, int loc, double &targetTop[], double &targetBtm[],
datetime &targetLeft[], datetime &targetRight[], int &targetType[], int &targetMit[])
{
double high[], low[], atr[];
datetime time[];

ArraySetAsSeries(high, true);
ArraySetAsSeries(low, true);
ArraySetAsSeries(atr, true);
ArraySetAsSeries(time, true);

int bars = Bars(_Symbol, _Period);
CopyHigh(_Symbol, _Period, 0, bars, high);
CopyLow(_Symbol, _Period, 0, bars, low);
CopyBuffer(atr_handle, 0, 0, bars, atr);
CopyTime(_Symbol, _Period, 0, bars, time);

double min = 99999999.0;
double max = 0.0;
int idx = 1;

double obThreshold;
if(OBFilter == "Atr")
obThreshold = atr[0];
else
{
// Calculate cumulative mean range
double cumRange = 0;
for(int i = 0; i < bars; i++)
cumRange += high[i] - low[i];
obThreshold = cumRange / bars;
}

// Search for highest/lowest high within the structure interval and get range
if(useMax)
{
for(int i = 1; i < (bars - loc) - 1; i++)
{
if((high[i] - low[i]) < obThreshold * 2)
{
if(high[i] > max)
{
max = high[i];
min = low[i];
idx = i;
}
}
}
}
else
{
for(int i = 1; i < (bars - loc) - 1; i++)
{
if((high[i] - low[i]) < obThreshold * 2)
{
if(low[i] < min)
{
min = low[i];
max = high[i];
idx = i;
}
}
}
}

// Add to arrays
int size = ArraySize(targetTop);
ArrayResize(targetTop, size + 1);
ArrayResize(targetBtm, size + 1);
ArrayResize(targetLeft, size + 1);
ArrayResize(targetRight, size + 1);
ArrayResize(targetType, size + 1);
ArrayResize(targetMit, size + 1);

// Shift array elements
for(int i = size; i > 0; i--)
{
targetTop[i] = targetTop[i-1];
targetBtm[i] = targetBtm[i-1];
targetLeft[i] = targetLeft[i-1];
targetRight[i] = targetRight[i-1];
targetType[i] = targetType[i-1];
targetMit[i] = targetMit[i-1];
}

// Add new element at the beginning
targetTop[0] = max;
targetBtm[0] = min;
targetLeft[0] = time[idx];
targetRight[0] = time[idx];
targetType[0] = useMax ? -1 : 1;
targetMit[0] = 0;
}

//+------------------------------------------------------------------+
//| Helper function to draw order blocks |
//+------------------------------------------------------------------+
void DrawOrderBlocks(string prefix, double &targetTop[], double &targetBtm[],
datetime &targetLeft[], datetime &targetRight[], int &targetType[], int &targetMit[],
int showLast, bool isSwing, int size, color bullCss, color bullmCss, color bearCss, color bearmCss)
{
for(int i = 0; i < MathMin(showLast, size); i++)
{
if(targetLeft[i] == 0) continue;

  string box_name = prefix + "_" + IntegerToString(i) + "_" + IntegerToString(ChartID());
  
  //--- Create or update rectangle
  if(ObjectFind(0, box_name) < 0)
  {
     ObjectCreate(0, box_name, OBJ_RECTANGLE, 0, targetLeft[i], targetTop[i], targetRight[i], targetBtm[i]);
     ObjectSetInteger(0, box_name, OBJPROP_BACK, true);
  }
  else
  {
     ObjectSetInteger(0, box_name, OBJPROP_TIME1, targetLeft[i]);
     ObjectSetInteger(0, box_name, OBJPROP_PRICE1, targetTop[i]);
     ObjectSetInteger(0, box_name, OBJPROP_TIME2, targetRight[i]);
     ObjectSetInteger(0, box_name, OBJPROP_PRICE2, targetBtm[i]);
  }
  
  //--- Set color
  color clr;
  if(Style == "Monochrome")
     clr = (targetType[i] == 1) ? C'178,181,190,204' : C'93,96,107,204';
  else
  {
     if(targetMit[i] > 0)
        clr = (targetType[i] == 1) ? bullmCss : bearmCss;
     else
        clr = (targetType[i] == 1) ? bullCss : bearCss;
  }
  
  ObjectSetInteger(0, box_name, OBJPROP_COLOR, clr);
  ObjectSetInteger(0, box_name, OBJPROP_FILL, true);
  ObjectSetInteger(0, box_name, OBJPROP_BACK, true);
  
  //--- Set extension
  if(targetMit[i] > 0)
     ObjectSetInteger(0, box_name, OBJPROP_RAY_RIGHT, false);
  else
     ObjectSetInteger(0, box_name, OBJPROP_RAY_RIGHT, true);

}
}

//+------------------------------------------------------------------+
//| Helper function to draw previous high/low lines |
//+------------------------------------------------------------------+
void DrawPHL(double high, double low, string tf, color clr, string style)
{
datetime time[];
double high_arr[], low_arr[];

ArraySetAsSeries(time, true);
ArraySetAsSeries(high_arr, true);
ArraySetAsSeries(low_arr, true);

int copied = CopyTime(_Symbol, _Period, 0, Bars(_Symbol, _Period), time);
CopyHigh(_Symbol, _Period, 0, Bars(_Symbol, _Period), high_arr);
CopyLow(_Symbol, _Period, 0, Bars(_Symbol, _Period), low_arr);

// Find last high and low
datetime high_time = 0;
datetime low_time = 0;
double last_high = 0;
double last_low = 0;

for(int i = 0; i < copied; i++)
{
if(high_arr[i] == high)
{
last_high = high;
high_time = time[i];
}

  if(low_arr[i] == low)
  {
     last_low = low;
     low_time = time[i];
  }

}

if(high_time > 0)
{
string high_line_name = "PDHL_" + tf + "High" + IntegerToString(ChartID());
string high_lbl_name = "PDHL_" + tf + "HighLbl" + IntegerToString(ChartID());

  // Create or update high line
  if(ObjectFind(0, high_line_name) < 0)
  {
     ObjectCreate(0, high_line_name, OBJ_TREND, 0, high_time, last_high, TimeCurrent(), last_high);
     ObjectSetInteger(0, high_line_name, OBJPROP_COLOR, clr);
     
     int line_style = STYLE_SOLID;
     if(style == "----")
        line_style = STYLE_DASH;
     else if(style == "····")
        line_style = STYLE_DOT;
        
     ObjectSetInteger(0, high_line_name, OBJPROP_STYLE, line_style);
     ObjectSetInteger(0, high_line_name, OBJPROP_WIDTH, 1);
     ObjectSetInteger(0, high_line_name, OBJPROP_RAY_RIGHT, true);
  }
  else
  {
     ObjectSetInteger(0, high_line_name, OBJPROP_TIME1, high_time);
     ObjectSetInteger(0, high_line_name, OBJPROP_PRICE1, last_high);
     ObjectSetInteger(0, high_line_name, OBJPROP_TIME2, TimeCurrent());
     ObjectSetInteger(0, high_line_name, OBJPROP_PRICE2, last_high);
  }
  
  // Create or update high label
  if(ObjectFind(0, high_lbl_name) < 0)
  {
     ObjectCreate(0, high_lbl_name, OBJ_TEXT, 0, TimeCurrent(), last_high);
     ObjectSetString(0, high_lbl_name, OBJPROP_TEXT, "P" + tf + "H");
     ObjectSetInteger(0, high_lbl_name, OBJPROP_COLOR, clr);
     ObjectSetInteger(0, high_lbl_name, OBJPROP_ANCHOR, ANCHOR_LEFT);
     ObjectSetInteger(0, high_lbl_name, OBJPROP_FONTSIZE, 8);
  }
  else
  {
     ObjectSetInteger(0, high_lbl_name, OBJPROP_TIME, TimeCurrent());
     ObjectSetInteger(0, high_lbl_name, OBJPROP_PRICE, last_high);
  }

}

if(low_time > 0)
{
string low_line_name = "PDHL_" + tf + "Low" + IntegerToString(ChartID());
string low_lbl_name = "PDHL_" + tf + "LowLbl" + IntegerToString(ChartID());

  // Create or update low line
  if(ObjectFind(0, low_line_name) < 0)
  {
     ObjectCreate(0, low_line_name, OBJ_TREND, 0, low_time, last_low, TimeCurrent(), last_low);
     ObjectSetInteger(0, low_line_name, OBJPROP_COLOR, clr);
     
     int line_style = STYLE_SOLID;
     if(style == "----")
        line_style = STYLE_DASH;
     else if(style == "····")
        line_style = STYLE_DOT;
        
     ObjectSetInteger(0, low_line_name, OBJPROP_STYLE, line_style);
     ObjectSetInteger(0, low_line_name, OBJPROP_WIDTH, 1);
     ObjectSetInteger(0, low_line_name, OBJPROP_RAY_RIGHT, true);
  }
  else
  {
     ObjectSetInteger(0, low_line_name, OBJPROP_TIME1, low_time);
     ObjectSetInteger(0, low_line_name, OBJPROP_PRICE1, last_low);
     ObjectSetInteger(0, low_line_name, OBJPROP_TIME2, TimeCurrent());
     ObjectSetInteger(0, low_line_name, OBJPROP_PRICE2, last_low);
  }
  
  // Create or update low label
  if(ObjectFind(0, low_lbl_name) < 0)
  {
     ObjectCreate(0, low_lbl_name, OBJ_TEXT, 0, TimeCurrent(), last_low);
     ObjectSetString(0, low_lbl_name, OBJPROP_TEXT, "P" + tf + "L");
     ObjectSetInteger(0, low_lbl_name, OBJPROP_COLOR, clr);
     ObjectSetInteger(0, low_lbl_name, OBJPROP_ANCHOR, ANCHOR_LEFT);
     ObjectSetInteger(0, low_lbl_name, OBJPROP_FONTSIZE, 8);
  }
  else
  {
     ObjectSetInteger(0, low_lbl_name, OBJPROP_TIME, TimeCurrent());
     ObjectSetInteger(0, low_lbl_name, OBJPROP_PRICE, last_low);
  }

}
}

//+------------------------------------------------------------------+
//| Helper function to draw premium/discount zones |
//+------------------------------------------------------------------+
void DrawPremiumDiscountZones()
{
string premium_box = "Premium_" + IntegerToString(ChartID());
string premium_lbl = "PremiumLbl_" + IntegerToString(ChartID());
string eq_box = "Equilibrium_" + IntegerToString(ChartID());
string eq_lbl = "EquilibriumLbl_" + IntegerToString(ChartID());
string discount_box = "Discount_" + IntegerToString(ChartID());
string discount_lbl = "DiscountLbl_" + IntegerToString(ChartID());

datetime time[];
double high[], low[];

ArraySetAsSeries(time, true);
ArraySetAsSeries(high, true);
ArraySetAsSeries(low, true);

int copied = CopyTime(_Symbol, _Period, 0, Bars(_Symbol, _Period), time);
CopyHigh(_Symbol, _Period, 0, Bars(_Symbol, _Period), high);
CopyLow(_Symbol, _Period, 0, Bars(_Symbol, _Period), low);

// Find start time
datetime start_time = time[MathMax(top_x, btm_x)];

// Calculate average
double avg = (trail_up + trail_dn) / 2;

// Create or update premium zone
if(ObjectFind(0, premium_box) < 0)
{
ObjectCreate(0, premium_box, OBJ_RECTANGLE, 0, start_time, trail_up, TimeCurrent(), 0.95 * trail_up + 0.05 * trail_dn);
ObjectSetInteger(0, premium_box, OBJPROP_COLOR, PremiumCss);
ObjectSetInteger(0, premium_box, OBJPROP_STYLE, STYLE_SOLID);
ObjectSetInteger(0, premium_box, OBJPROP_WIDTH, 1);
ObjectSetInteger(0, premium_box, OBJPROP_BACK, true);
ObjectSetInteger(0, premium_box, OBJPROP_FILL, true);
}
else
{
ObjectSetInteger(0, premium_box, OBJPROP_TIME1, start_time);
ObjectSetInteger(0, premium_box, OBJPROP_PRICE1, trail_up);
ObjectSetInteger(0, premium_box, OBJPROP_TIME2, TimeCurrent());
ObjectSetInteger(0, premium_box, OBJPROP_PRICE2, 0.95 * trail_up + 0.05 * trail_dn);
}

// Create or update premium label
if(ObjectFind(0, premium_lbl) < 0)
{
ObjectCreate(0, premium_lbl, OBJ_TEXT, 0, TimeCurrent(), trail_up);
ObjectSetString(0, premium_lbl, OBJPROP_TEXT, "Premium");
ObjectSetInteger(0, premium_lbl, OBJPROP_COLOR, PremiumCss);
ObjectSetInteger(0, premium_lbl, OBJPROP_ANCHOR, ANCHOR_LOWER);
ObjectSetInteger(0, premium_lbl, OBJPROP_FONTSIZE, 8);
}
else
{
ObjectSetInteger(0, premium_lbl, OBJPROP_TIME, TimeCurrent());
ObjectSetInteger(0, premium_lbl, OBJPROP_PRICE, trail_up);
}

// Create or update equilibrium zone
if(ObjectFind(0, eq_box) < 0)
{
ObjectCreate(0, eq_box, OBJ_RECTANGLE, 0, start_time, 0.525 * trail_up + 0.475 * trail_dn, TimeCurrent(), 0.525 * trail_dn + 0.475 * trail_up);
ObjectSetInteger(0, eq_box, OBJPROP_COLOR, EqCss);
ObjectSetInteger(0, eq_box, OBJPROP_STYLE, STYLE_SOLID);
ObjectSetInteger(0, eq_box, OBJPROP_WIDTH, 1);
ObjectSetInteger(0, eq_box, OBJPROP_BACK, true);
ObjectSetInteger(0, eq_box, OBJPROP_FILL, true);
}
else
{
ObjectSetInteger(0, eq_box, OBJPROP_TIME1, start_time);
ObjectSetInteger(0, eq_box, OBJPROP_PRICE1, 0.525 * trail_up + 0.475 * trail_dn);
ObjectSetInteger(0, eq_box, OBJPROP_TIME2, TimeCurrent());
ObjectSetInteger(0, eq_box, OBJPROP_PRICE2, 0.525 * trail_dn + 0.475 * trail_up);
}

// Create or update equilibrium label
if(ObjectFind(0, eq_lbl) < 0)
{
ObjectCreate(0, eq_lbl, OBJ_TEXT, 0, TimeCurrent(), avg);
ObjectSetString(0, eq_lbl, OBJPROP_TEXT, "Equilibrium");
ObjectSetInteger(0, eq_lbl, OBJPROP_COLOR, EqCss);
ObjectSetInteger(0, eq_lbl, OBJPROP_ANCHOR, ANCHOR_LEFT);
ObjectSetInteger(0, eq_lbl, OBJPROP_FONTSIZE, 8);
}
else
{
ObjectSetInteger(0, eq_lbl, OBJPROP_TIME, TimeCurrent());
ObjectSetInteger(0, eq_lbl, OBJPROP_PRICE, avg);
}

// Create or update discount zone
if(ObjectFind(0, discount_box) < 0)
{
ObjectCreate(0, discount_box, OBJ_RECTANGLE, 0, start_time, 0.95 * trail_dn + 0.05 * trail_up, TimeCurrent(), trail_dn);
ObjectSetInteger(0, discount_box, OBJPROP_COLOR, DiscountCss);
ObjectSetInteger(0, discount_box, OBJPROP_STYLE, STYLE_SOLID);
ObjectSetInteger(0, discount_box, OBJPROP_WIDTH, 1);
ObjectSetInteger(0, discount_box, OBJPROP_BACK, true);
ObjectSetInteger(0, discount_box, OBJPROP_FILL, true);
}
else
{
ObjectSetInteger(0, discount_box, OBJPROP_TIME1, start_time);
ObjectSetInteger(0, discount_box, OBJPROP_PRICE1, 0.95 * trail_dn + 0.05 * trail_up);
ObjectSetInteger(0, discount_box, OBJPROP_TIME2, TimeCurrent());
ObjectSetInteger(0, discount_box, OBJPROP_PRICE2, trail_dn);
}

// Create or update discount label
if(ObjectFind(0, discount_lbl) < 0)
{
ObjectCreate(0, discount_lbl, OBJ_TEXT, 0, TimeCurrent(), trail_dn);
ObjectSetString(0, discount_lbl, OBJPROP_TEXT, "Discount");
ObjectSetInteger(0, discount_lbl, OBJPROP_COLOR, DiscountCss);
ObjectSetInteger(0, discount_lbl, OBJPROP_ANCHOR, ANCHOR_UPPER);
ObjectSetInteger(0, discount_lbl, OBJPROP_FONTSIZE, 8);
}
else
{
ObjectSetInteger(0, discount_lbl, OBJPROP_TIME, TimeCurrent());
ObjectSetInteger(0, discount_lbl, OBJPROP_PRICE, trail_dn);
}
}

//+------------------------------------------------------------------+
//| Helper function to draw FVG boxes |
//+------------------------------------------------------------------+
void DrawFVGBoxes()
{
for(int i = 0; i < ArraySize(bullish_fvg_max); i++)
{
if(bullish_fvg_time[i] == 0) continue;

  string box_name1 = "FVG_BullMax_" + IntegerToString(i) + "_" + IntegerToString(ChartID());
  string box_name2 = "FVG_BullMin_" + IntegerToString(i) + "_" + IntegerToString(ChartID());
  
  // Create or update max box
  if(ObjectFind(0, box_name1) < 0)
  {
     ObjectCreate(0, box_name1, OBJ_RECTANGLE, 0, bullish_fvg_time[i], bullish_fvg_max[i], TimeCurrent(), (bullish_fvg_max[i] + bullish_fvg_min[i])/2);
     ObjectSetInteger(0, box_name1, OBJPROP_COLOR, BullFvgCss);
     ObjectSetInteger(0, box_name1, OBJPROP_STYLE, STYLE_SOLID);
     ObjectSetInteger(0, box_name1, OBJPROP_WIDTH, 1);
     ObjectSetInteger(0, box_name1, OBJPROP_BACK, true);
     ObjectSetInteger(0, box_name1, OBJPROP_FILL, true);
  }
  else
  {
     ObjectSetInteger(0, box_name1, OBJPROP_TIME1, bullish_fvg_time[i]);
     ObjectSetInteger(0, box_name1, OBJPROP_PRICE1, bullish_fvg_max[i]);
     ObjectSetInteger(0, box_name1, OBJPROP_TIME2, TimeCurrent());
     ObjectSetInteger(0, box_name1, OBJPROP_PRICE2, (bullish_fvg_max[i] + bullish_fvg_min[i])/2);
  }
  
  // Create or update min box
  if(ObjectFind(0, box_name2) < 0)
  {
     ObjectCreate(0, box_name2, OBJ_RECTANGLE, 0, bullish_fvg_time[i], (bullish_fvg_max[i] + bullish_fvg_min[i])/2, TimeCurrent(), bullish_fvg_min[i]);
     ObjectSetInteger(0, box_name2, OBJPROP_COLOR, BullFvgCss);
     ObjectSetInteger(0, box_name2, OBJPROP_STYLE, STYLE_SOLID);
     ObjectSetInteger(0, box_name2, OBJPROP_WIDTH, 1);
     ObjectSetInteger(0, box_name2, OBJPROP_BACK, true);
     ObjectSetInteger(0, box_name2, OBJPROP_FILL, true);
  }
  else
  {
     ObjectSetInteger(0, box_name2, OBJPROP_TIME1, bullish_fvg_time[i]);
     ObjectSetInteger(0, box_name2, OBJPROP_PRICE1, (bullish_fvg_max[i] + bullish_fvg_min[i])/2);
     ObjectSetInteger(0, box_name2, OBJPROP_TIME2, TimeCurrent());
     ObjectSetInteger(0, box_name2, OBJPROP_PRICE2, bullish_fvg_min[i]);
  }

}

for(int i = 0; i < ArraySize(bearish_fvg_max); i++)
{
if(bearish_fvg_time[i] == 0) continue;

  string box_name1 = "FVG_BearMax_" + IntegerToString(i) + "_" + IntegerToString(ChartID());
  string box_name2 = "FVG_BearMin_" + IntegerToString(i) + "_" + IntegerToString(ChartID());
  
  // Create or update max box
  if(ObjectFind(0, box_name1) < 0)
  {
     ObjectCreate(0, box_name1, OBJ_RECTANGLE, 0, bearish_fvg_time[i], bearish_fvg_max[i], TimeCurrent(), (bearish_fvg_max[i] + bearish_fvg_min[i])/2);
     ObjectSetInteger(0, box_name1, OBJPROP_COLOR, BearFvgCss);
     ObjectSetInteger(0, box_name1, OBJPROP_STYLE, STYLE_SOLID);
     ObjectSetInteger(0, box_name1, OBJPROP_WIDTH, 1);
     ObjectSetInteger(0, box_name1, OBJPROP_BACK, true);
     ObjectSetInteger(0, box_name1, OBJPROP_FILL, true);
  }
  else
  {
     ObjectSetInteger(0, box_name1, OBJPROP_TIME1, bearish_fvg_time[i]);
     ObjectSetInteger(0, box_name1, OBJPROP_PRICE1, bearish_fvg_max[i]);
     ObjectSetInteger(0, box_name1, OBJPROP_TIME2, TimeCurrent());
     ObjectSetInteger(0, box_name1, OBJPROP_PRICE2, (bearish_fvg_max[i] + bearish_fvg_min[i])/2);
  }
  
  // Create or update min box
  if(ObjectFind(0, box_name2) < 0)
  {
     ObjectCreate(0, box_name2, OBJ_RECTANGLE, 0, bearish_fvg_time[i], (bearish_fvg_max[i] + bearish_fvg_min[i])/2, TimeCurrent(), bearish_fvg_min[i]);
     ObjectSetInteger(0, box_name2, OBJPROP_COLOR, BearFvgCss);
     ObjectSetInteger(0, box_name2, OBJPROP_STYLE, STYLE_SOLID);
     ObjectSetInteger(0, box_name2, OBJPROP_WIDTH, 1);
     ObjectSetInteger(0, box_name2, OBJPROP_BACK, true);
     ObjectSetInteger(0, box_name2, OBJPROP_FILL, true);
  }
  else
  {
     ObjectSetInteger(0, box_name2, OBJPROP_TIME1, bearish_fvg_time[i]);
     ObjectSetInteger(0, box_name2, OBJPROP_PRICE1, (bearish_fvg_max[i] + bearish_fvg_min[i])/2);
     ObjectSetInteger(0, box_name2, OBJPROP_TIME2, TimeCurrent());
     ObjectSetInteger(0, box_name2, OBJPROP_PRICE2, bearish_fvg_min[i]);
  }

}
}

//+------------------------------------------------------------------+
//| Custom indicator iteration function |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
const int prev_calculated,
const datetime &time[],
const double &open[],
const double &high[],
const double &low[],
const double &close[],
const long &tick_volume[],
const long &real_volume[],
const int &spread[])
{
//--- Check if we have enough data
if(rates_total < Length + 10)
return(0);

//--- Copy ATR values
if(CopyBuffer(atr_handle, 0, 0, rates_total, atr_buffer) <= 0)
{
Print("Error copying ATR buffer: ", GetLastError());
return(0);
}

//--- Set arrays as series
ArraySetAsSeries(time, true);
ArraySetAsSeries(open, true);
ArraySetAsSeries(high, true);
ArraySetAsSeries(low, true);
ArraySetAsSeries(close, true);

//--- Detect swings
double top, btm;
DetectSwings(Length, top, btm);

double itop, ibtm;
DetectSwings(5, itop, ibtm);

//--- Process pivot highs
if(top > 0)
{
top_cross = true;
txt_top = (top > top_y) ? "HH" : "LH";

  if(ShowSwings)
  {
     DrawStructure(time[Length], top, txt_top, 
                  (Style == "Monochrome") ? C'178,181,190' : SwingBearCss, 
                  false, true, "Small");
  }
  
  //--- Update variables
  top_y = top;
  top_x = Length;
  trail_up = top;
  trail_up_x = Length;

}

//--- Process pivot lows
if(btm > 0)
{
btm_cross = true;
txt_btm = (btm < btm_y) ? "LL" : "HL";

  if(ShowSwings)
  {
     DrawStructure(time[Length], btm, txt_btm, 
                  (Style == "Monochrome") ? C'178,181,190' : SwingBullCss, 
                  false, false, "Small");
  }
  
  //--- Update variables
  btm_y = btm;
  btm_x = Length;
  trail_dn = btm;
  trail_dn_x = Length;

}

//--- Detect internal structure breakouts
if(itop > 0)
{
itop_cross = true;
itop_y = itop;
itop_x = 5;
}

if(ibtm > 0)
{
ibtm_cross = true;
ibtm_y = ibtm;
ibtm_x = 5;
}

//--- Update trailing values
if(high[0] > trail_up)
{
trail_up = high[0];
trail_up_x = 0;
}

if(low[0] < trail_dn)
{
trail_dn = low[0];
trail_dn_x = 0;
}

//--- Detect bullish internal structure
if(close[0] > itop_y && itop_cross && top_y != itop_y)
{
bool choch = (itrend < 0);
string txt = choch ? "CHoCH" : "BOS";

  if(ShowInternals)
  {
     if(ShowIBull == "All" || 
        (ShowIBull == "BOS" && !choch) || 
        (ShowIBull == "CHoCH" && choch))
     {
        DrawStructure(time[itop_x], itop_y, txt, 
                     (Style == "Monochrome") ? C'178,181,190' : SwingIBullCss, 
                     true, true, "Tiny");
     }
  }
  
  itop_cross = false;
  itrend = 1;
  
  //--- Internal Order Block
  if(ShowIOB)
  {
     OBCoord(false, itop_x, iob_top, iob_btm, iob_left, iob_right, iob_type, iob_mit);
  }
  
  //--- Set alerts
  if(choch)
     bull_ichoch_alert = true;
  else
     bull_ibos_alert = true;

}

//--- Detect bullish structure
if(close[0] > top_y && top_cross)
{
bool choch = (trend < 0);
string txt = choch ? "CHoCH" : "BOS";

  if(ShowStructure)
  {
     if(ShowBull == "All" || 
        (ShowBull == "BOS" && !choch) || 
        (ShowBull == "CHoCH" && choch))
     {
        DrawStructure(time[top_x], top_y, txt, 
                     (Style == "Monochrome") ? C'178,181,190' : SwingBullCss, 
                     false, true, "Small");
     }
  }
  
  top_cross = false;
  trend = 1;
  
  //--- Order Block
  if(ShowOB)
  {
     OBCoord(false, top_x, ob_top, ob_btm, ob_left, ob_right, ob_type, ob_mit);
  }
  
  //--- Set alerts
  if(choch)
     bull_choch_alert = true;
  else
     bull_bos_alert = true;

}

//--- Detect bearish internal structure
if(close[0] < ibtm_y && ibtm_cross && btm_y != ibtm_y)
{
bool choch = (itrend > 0);
string txt = choch ? "CHoCH" : "BOS";

  if(ShowInternals)
  {
     if(ShowIBear == "All" || 
        (ShowIBear == "BOS" && !choch) || 
        (ShowIBear == "CHoCH" && choch))
     {
        DrawStructure(time[ibtm_x], ibtm_y, txt, 
                     (Style == "Monochrome") ? C'178,181,190' : SwingIBearCss, 
                     true, false, "Tiny");
     }
  }
  
  ibtm_cross = false;
  itrend = -1;
  
  //--- Internal Order Block
  if(ShowIOB)
  {
     OBCoord(true, ibtm_x, iob_top, iob_btm, iob_left, iob_right, iob_type, iob_mit);
  }
  
  //--- Set alerts
  if(choch)
     bear_ichoch_alert = true;
  else
     bear_ibos_alert = true;

}

//--- Detect bearish structure
if(close[0] < btm_y && btm_cross)
{
bool choch = (trend > 0);
string txt = choch ? "CHoCH" : "BOS";

  if(ShowStructure)
  {
     if(ShowBear == "All" || 
        (ShowBear == "BOS" && !choch) || 
        (ShowBear == "CHoCH" && choch))
     {
        DrawStructure(time[btm_x], btm_y, txt, 
                     (Style == "Monochrome") ? C'178,181,190' : SwingBearCss, 
                     false, false, "Small");
     }
  }
  
  btm_cross = false;
  trend = -1;
  
  //--- Order Block
  if(ShowOB)
  {
     OBCoord(true, btm_x, ob_top, ob_btm, ob_left, ob_right, ob_type, ob_mit);
  }
  
  //--- Set alerts
  if(choch)
     bear_choch_alert = true;
  else
     bear_bos_alert = true;

}

//--- Check order block mitigation and break
for(int i = 0; i < ArraySize(iob_type); i++)
{
if(iob_left[i] == 0) continue;

  // Mark internal orderbox as mitigated if price tapped inside the orderblock
  if(OBHighlightMit)
  {
     if(iob_type[i] == 1 && low[1] > iob_top[i] && low[0] <= iob_top[i])
     {
        iob_mit[i]++;
        iob_right[i] = time[0];
        bull_iob_mit = true;
     }
     else if(iob_type[i] == -1 && high[1] < iob_btm[i] && high[0] >= iob_btm[i])
     {
        iob_mit[i]++;
        iob_right[i] = time[0];
        bear_iob_mit = true;
     }
  }
  
  // Check if order block is broken
  if(close[0] < iob_btm[i] && iob_type[i] == 1)
  {
     // Remove order block
     for(int j = i; j < ArraySize(iob_type) - 1; j++)
     {
        iob_top[j] = iob_top[j+1];
        iob_btm[j] = iob_btm[j+1];
        iob_left[j] = iob_left[j+1];
        iob_right[j] = iob_right[j+1];
        iob_type[j] = iob_type[j+1];
        iob_mit[j] = iob_mit[j+1];
     }
     
     ArrayResize(iob_top, ArraySize(iob_top) - 1);
     ArrayResize(iob_btm, ArraySize(iob_btm) - 1);
     ArrayResize(iob_left, ArraySize(iob_left) - 1);
     ArrayResize(iob_right, ArraySize(iob_right) - 1);
     ArrayResize(iob_type, ArraySize(iob_type) - 1);
     ArrayResize(iob_mit, ArraySize(iob_mit) - 1);
     
     bull_iob_break = true;
     i--; // Adjust index after removal
  }
  else if(close[0] > iob_top[i] && iob_type[i] == -1)
  {
     // Remove order block
     for(int j = i; j < ArraySize(iob_type) - 1; j++)
     {
        iob_top[j] = iob_top[j+1];
        iob_btm[j] = iob_btm[j+1];
        iob_left[j] = iob_left[j+1];
        iob_right[j] = iob_right[j+1];
        iob_type[j] = iob_type[j+1];
        iob_mit[j] = iob_mit[j+1];
     }
     
     ArrayResize(iob_top, ArraySize(iob_top) - 1);
     ArrayResize(iob_btm, ArraySize(iob_btm) - 1);
     ArrayResize(iob_left, ArraySize(iob_left) - 1);
     ArrayResize(iob_right, ArraySize(iob_right) - 1);
     ArrayResize(iob_type, ArraySize(iob_type) - 1);
     ArrayResize(iob_mit, ArraySize(iob_mit) - 1);
     
     bear_iob_break = true;
     i--; // Adjust index after removal
  }

}

//--- Check swing order block mitigation and break
for(int i = 0; i < ArraySize(ob_type); i++)
{
if(ob_left[i] == 0) continue;

  // Mark orderbox as mitigated if price tapped inside the orderblock
  if(OBHighlightMit)
  {
     if(ob_type[i] == 1 && low[1] > ob_top[i] && low[0] <= ob_top[i])
     {
        ob_mit[i]++;
        ob_right[i] = time[0];
        bull_ob_mit = true;
     }
     else if(ob_type[i] == -1 && high[1] < ob_btm[i] && high[0] >= ob_btm[i])
     {
        ob_mit[i]++;
        ob_right[i] = time[0];
        bear_ob_mit = true;
     }
  }
  
  // Check if order block is broken
  if(close[0] < ob_btm[i] && ob_type[i] == 1)
  {
     // Remove order block
     for(int j = i; j < ArraySize(ob_type) - 1; j++)
     {
        ob_top[j] = ob_top[j+1];
        ob_btm[j] = ob_btm[j+1];
        ob_left[j] = ob_left[j+1];
        ob_right[j] = ob_right[j+1];
        ob_type[j] = ob_type[j+1];
        ob_mit[j] = ob_mit[j+1];
     }
     
     ArrayResize(ob_top, ArraySize(ob_top) - 1);
     ArrayResize(ob_btm, ArraySize(ob_btm) - 1);
     ArrayResize(ob_left, ArraySize(ob_left) - 1);
     ArrayResize(ob_right, ArraySize(ob_right) - 1);
     ArrayResize(ob_type, ArraySize(ob_type) - 1);
     ArrayResize(ob_mit, ArraySize(ob_mit) - 1);
     
     bull_ob_break = true;
     i--; // Adjust index after removal
  }
  else if(close[0] > ob_top[i] && ob_type[i] == -1)
  {
     // Remove order block
     for(int j = i; j < ArraySize(ob_type) - 1; j++)
     {
        ob_top[j] = ob_top[j+1];
        ob_btm[j] = ob_btm[j+1];
        ob_left[j] = ob_left[j+1];
        ob_right[j] = ob_right[j+1];
        ob_type[j] = ob_type[j+1];
        ob_mit[j] = ob_mit[j+1];
     }
     
     ArrayResize(ob_top, ArraySize(ob_top) - 1);
     ArrayResize(ob_btm, ArraySize(ob_btm) - 1);
     ArrayResize(ob_left, ArraySize(ob_left) - 1);
     ArrayResize(ob_right, ArraySize(ob_right) - 1);
     ArrayResize(ob_type, ArraySize(ob_type) - 1);
     ArrayResize(ob_mit, ArraySize(ob_mit) - 1);
     
     bear_ob_break = true;
     i--; // Adjust index after removal
  }

}

//--- Draw order blocks
if(ShowIOB)
{
DrawOrderBlocks("IOB", iob_top, iob_btm, iob_left, iob_right, iob_type, iob_mit,
IOBShowLast, false, ArraySize(iob_type),
IBullObCss, IBullmObCss, IBearObCss, IBearmObCss);
}

if(ShowOB)
{
DrawOrderBlocks("OB", ob_top, ob_btm, ob_left, ob_right, ob_type, ob_mit,
OBShowLast, true, ArraySize(ob_type),
BullObCss, BullmObCss, BearObCss, BearmObCss);
}

//--- Detect and draw EQH/EQL
if(ShowEQ)
{
// Find pivot high and low
double eq_top = 0, eq_btm = 0;
int eq_top_idx = 0, eq_btm_idx = 0;

  for(int i = EQLen; i < rates_total - EQLen; i++)
  {
     bool is_pivot_high = true;
     bool is_pivot_low = true;
     
     for(int j = 1; j <= EQLen; j++)
     {
        if(high[i] <= high[i+j] || high[i] <= high[i-j])
           is_pivot_high = false;
        
        if(low[i] >= low[i+j] || low[i] >= low[i-j])
           is_pivot_low = false;
     }
     
     if(is_pivot_high)
     {
        eq_top = high[i];
        eq_top_idx = i;
     }
     
     if(is_pivot_low)
     {
        eq_btm = low[i];
        eq_btm_idx = i;
     }
  }
  
  // Check for EQH
  if(eq_top > 0 && eq_prev_top > 0)
  {
     double max = MathMax(eq_top, eq_prev_top);
     double min = MathMin(eq_top, eq_prev_top);
     
     if(max < min + atr_buffer[0] * EQThreshold)
     {
        string line_name = "EQH_" + IntegerToString(ChartID());
        string label_name = "EQHLbl_" + IntegerToString(ChartID());
        
        // Create or update line
        if(ObjectFind(0, line_name) < 0)
        {
           ObjectCreate(0, line_name, OBJ_TREND, 0, time[eq_top_x], eq_prev_top, time[eq_top_idx], eq_top);
           ObjectSetInteger(0, line_name, OBJPROP_COLOR, (Style == "Monochrome") ? C'178,181,190' : SwingBearCss);
           ObjectSetInteger(0, line_name, OBJPROP_STYLE, STYLE_DOT);
           ObjectSetInteger(0, line_name, OBJPROP_WIDTH, 1);
           ObjectSetInteger(0, line_name, OBJPROP_RAY_RIGHT, false);
        }
        else
        {
           ObjectSetInteger(0, line_name, OBJPROP_TIME1, time[eq_top_x]);
           ObjectSetInteger(0, line_name, OBJPROP_PRICE1, eq_prev_top);
           ObjectSetInteger(0, line_name, OBJPROP_TIME2, time[eq_top_idx]);
           ObjectSetInteger(0, line_name, OBJPROP_PRICE2, eq_top);
        }
        
        // Create or update label
        if(ObjectFind(0, label_name) < 0)
        {
           ObjectCreate(0, label_name, OBJ_TEXT, 0, time[(eq_top_x + eq_top_idx)/2], eq_top);
           ObjectSetString(0, label_name, OBJPROP_TEXT, "EQH");
           ObjectSetInteger(0, label_name, OBJPROP_COLOR, (Style == "Monochrome") ? C'178,181,190' : SwingBearCss);
           ObjectSetInteger(0, label_name, OBJPROP_ANCHOR, ANCHOR_UPPER);
           ObjectSetInteger(0, label_name, OBJPROP_FONTSIZE, 7);
        }
        else
        {
           ObjectSetInteger(0, label_name, OBJPROP_TIME, time[(eq_top_x + eq_top_idx)/2]);
           ObjectSetInteger(0, label_name, OBJPROP_PRICE, eq_top);
        }
        
        eqh_alert = true;
     }
  }
  
  // Check for EQL
  if(eq_btm > 0 && eq_prev_btm > 0)
  {
     double max = MathMax(eq_btm, eq_prev_btm);
     double min = MathMin(eq_btm, eq_prev_btm);
     
     if(min > max - atr_buffer[0] * EQThreshold)
     {
        string line_name = "EQL_" + IntegerToString(ChartID());
        string label_name = "EQLLbl_" + IntegerToString(ChartID());
        
        // Create or update line
        if(ObjectFind(0, line_name) < 0)
        {
           ObjectCreate(0, line_name, OBJ_TREND, 0, time[eq_btm_x], eq_prev_btm, time[eq_btm_idx], eq_btm);
           ObjectSetInteger(0, line_name, OBJPROP_COLOR, (Style == "Monochrome") ? C'178,181,190' : SwingBullCss);
           ObjectSetInteger(0, line_name, OBJPROP_STYLE, STYLE_DOT);
           ObjectSetInteger(0, line_name, OBJPROP_WIDTH, 1);
           ObjectSetInteger(0, line_name, OBJPROP_RAY_RIGHT, false);
        }
        else
        {
           ObjectSetInteger(0, line_name, OBJPROP_TIME1, time[eq_btm_x]);
           ObjectSetInteger(0, line_name, OBJPROP_PRICE1, eq_prev_btm);
           ObjectSetInteger(0, line_name, OBJPROP_TIME2, time[eq_btm_idx]);
           ObjectSetInteger(0, line_name, OBJPROP_PRICE2, eq_btm);
        }
        
        // Create or update label
        if(ObjectFind(0, label_name) < 0)
        {
           ObjectCreate(0, label_name, OBJ_TEXT, 0, time[(eq_btm_x + eq_btm_idx)/2], eq_btm);
           ObjectSetString(0, label_name, OBJPROP_TEXT, "EQL");
           ObjectSetInteger(0, label_name, OBJPROP_COLOR, (Style == "Monochrome") ? C'178,181,190' : SwingBullCss);
           ObjectSetInteger(0, label_name, OBJPROP_ANCHOR, ANCHOR_LOWER);
           ObjectSetInteger(0, label_name, OBJPROP_FONTSIZE, 7);
        }
        else
        {
           ObjectSetInteger(0, label_name, OBJPROP_TIME, time[(eq_btm_x + eq_btm_idx)/2]);
           ObjectSetInteger(0, label_name, OBJPROP_PRICE, eq_btm);
        }
        
        eql_alert = true;
     }
  }
  
  // Update previous values
  if(eq_top > 0)
  {
     eq_prev_top = eq_top;
     eq_top_x = eq_top_idx;
  }
  
  if(eq_btm > 0)
  {
     eq_prev_btm = eq_btm;
     eq_btm_x = eq_btm_idx;
  }

}

//--- Detect and draw FVG
if(ShowFVG)
{
// Get data from specified timeframe
ENUM_TIMEFRAMES fvg_tf = PERIOD_CURRENT;
if(FVGTF == "M1") fvg_tf = PERIOD_M1;
else if(FVGTF == "M5") fvg_tf = PERIOD_M5;
else if(FVGTF == "M15") fvg_tf = PERIOD_M15;
else if(FVGTF == "M30") fvg_tf = PERIOD_M30;
else if(FVGTF == "H1") fvg_tf = PERIOD_H1;
else if(FVGTF == "H4") fvg_tf = PERIOD_H4;
else if(FVGTF == "D1") fvg_tf = PERIOD_D1;
else if(FVGTF == "W1") fvg_tf = PERIOD_W1;
else if(FVGTF == "MN1") fvg_tf = PERIOD_MN1;

  // Check if timeframe changed
  static datetime last_fvg_time = 0;
  datetime fvg_time[];
  double fvg_open[], fvg_close[], fvg_high[], fvg_low[];
  
  ArraySetAsSeries(fvg_time, true);
  ArraySetAsSeries(fvg_open, true);
  ArraySetAsSeries(fvg_close, true);
  ArraySetAsSeries(fvg_high, true);
  ArraySetAsSeries(fvg_low, true);
  
  CopyTime(_Symbol, fvg_tf, 0, 10, fvg_time);
  CopyOpen(_Symbol, fvg_tf, 0, 10, fvg_open);
  CopyClose(_Symbol, fvg_tf, 0, 10, fvg_close);
  CopyHigh(_Symbol, fvg_tf, 0, 10, fvg_high);
  CopyLow(_Symbol, fvg_tf, 0, 10, fvg_low);
  
  // Check if we have a new bar on FVG timeframe
  if(fvg_time[0] != last_fvg_time)
  {
     last_fvg_time = fvg_time[0];
     
     // Calculate percentage change
     double delta_per = (fvg_close[1] - fvg_open[1]) / fvg_open[1] * 100;
     
     // Calculate threshold
     double threshold;
     if(FVGAuto)
     {
        static double cum_delta = 0;
        static int bar_count = 0;
        
        cum_delta += MathAbs(delta_per);
        bar_count++;
        
        threshold = cum_delta / bar_count * 2;
     }
     else
     {
        threshold = 0;
     }
     
     // Check for bullish FVG
     if(fvg_low[1] > fvg_high[2] && 
        fvg_close[1] > fvg_high[2] && 
        delta_per > threshold)
     {
        // Add to arrays
        int size = ArraySize(bullish_fvg_max);
        ArrayResize(bullish_fvg_max, size + 1);
        ArrayResize(bullish_fvg_min, size + 1);
        ArrayResize(bullish_fvg_time, size + 1);
        
        // Shift array elements
        for(int i = size; i > 0; i--)
        {
           bullish_fvg_max[i] = bullish_fvg_max[i-1];
           bullish_fvg_min[i] = bullish_fvg_min[i-1];
           bullish_fvg_time[i] = bullish_fvg_time[i-1];
        }
        
        // Add new element at the beginning
        bullish_fvg_max[0] = fvg_low[1];
        bullish_fvg_min[0] = fvg_high[2];
        bullish_fvg_time[0] = fvg_time[1];
        
        bullish_fvg_cnd = true;
     }
     
     // Check for bearish FVG
     if(fvg_high[1] < fvg_low[2] && 
        fvg_close[1] < fvg_low[2] && 
        -delta_per > threshold)
     {
        // Add to arrays
        int size = ArraySize(bearish_fvg_max);
        ArrayResize(bearish_fvg_max, size + 1);
        ArrayResize(bearish_fvg_min, size + 1);
        ArrayResize(bearish_fvg_time, size + 1);
        
        // Shift array elements
        for(int i = size; i > 0; i--)
        {
           bearish_fvg_max[i] = bearish_fvg_max[i-1];
           bearish_fvg_min[i] = bearish_fvg_min[i-1];
           bearish_fvg_time[i] = bearish_fvg_time[i-1];
        }
        
        // Add new element at the beginning
        bearish_fvg_max[0] = fvg_high[1];
        bearish_fvg_min[0] = fvg_low[2];
        bearish_fvg_time[0] = fvg_time[1];
        
        bearish_fvg_cnd = true;
     }
  }
  
  // Check if FVG is mitigated
  for(int i = 0; i < ArraySize(bullish_fvg_max); i++)
  {
     if(bullish_fvg_time[i] == 0) continue;
     
     if(low[0] < bullish_fvg_min[i])
     {
        // Remove FVG
        for(int j = i; j < ArraySize(bullish_fvg_max) - 1; j++)
        {
           bullish_fvg_max[j] = bullish_fvg_max[j+1];
           bullish_fvg_min[j] = bullish_fvg_min[j+1];
           bullish_fvg_time[j] = bullish_fvg_time[j+1];
        }
        
        ArrayResize(bullish_fvg_max, ArraySize(bullish_fvg_max) - 1);
        ArrayResize(bullish_fvg_min, ArraySize(bullish_fvg_min) - 1);
        ArrayResize(bullish_fvg_time, ArraySize(bullish_fvg_time) - 1);
        
        i--; // Adjust index after removal
     }
  }
  
  for(int i = 0; i < ArraySize(bearish_fvg_max); i++)
  {
     if(bearish_fvg_time[i] == 0) continue;
     
     if(high[0] > bearish_fvg_max[i])
     {
        // Remove FVG
        for(int j = i; j < ArraySize(bearish_fvg_max) - 1; j++)
        {
           bearish_fvg_max[j] = bearish_fvg_max[j+1];
           bearish_fvg_min[j] = bearish_fvg_min[j+1];
           bearish_fvg_time[j] = bearish_fvg_time[j+1];
        }
        
        ArrayResize(bearish_fvg_max, ArraySize(bearish_fvg_max) - 1);
        ArrayResize(bearish_fvg_min, ArraySize(bearish_fvg_min) - 1);
        ArrayResize(bearish_fvg_time, ArraySize(bearish_fvg_time) - 1);
        
        i--; // Adjust index after removal
     }
  }
  
  // Draw FVG boxes
  DrawFVGBoxes();

}

//--- Draw previous high/low lines
if(ShowPDHL)
{
double pdh, pdl;
datetime pdh_time, pdl_time;

  // Get daily high/low
  double daily_high[], daily_low[];
  datetime daily_time[];
  
  ArraySetAsSeries(daily_high, true);
  ArraySetAsSeries(daily_low, true);
  ArraySetAsSeries(daily_time, true);
  
  CopyHigh(_Symbol, PERIOD_D1, 0, 2, daily_high);
  CopyLow(_Symbol, PERIOD_D1, 0, 2, daily_low);
  CopyTime(_Symbol, PERIOD_D1, 0, 2, daily_time);
  
  pdh = daily_high[1];
  pdl = daily_low[1];
  
  DrawPHL(pdh, pdl, "D", PDHLCss, PDHLStyle);

}

if(ShowPWHL)
{
double pwh, pwl;
datetime pwh_time, pwl_time;

  // Get weekly high/low
  double weekly_high[], weekly_low[];
  datetime weekly_time[];
  
  ArraySetAsSeries(weekly_high, true);
  ArraySetAsSeries(weekly_low, true);
  ArraySetAsSeries(weekly_time, true);
  
  CopyHigh(_Symbol, PERIOD_W1, 0, 2, weekly_high);
  CopyLow(_Symbol, PERIOD_W1, 0, 2, weekly_low);
  CopyTime(_Symbol, PERIOD_W1, 0, 2, weekly_time);
  
  pwh = weekly_high[1];
  pwl = weekly_low[1];
  
  DrawPHL(pwh, pwl, "W", PWHLCss, PWHLStyle);

}

if(ShowPMHL)
{
double pmh, pml;
datetime pmh_time, pml_time;

  // Get monthly high/low
  double monthly_high[], monthly_low[];
  datetime monthly_time[];
  
  ArraySetAsSeries(monthly_high, true);
  ArraySetAsSeries(monthly_low, true);
  ArraySetAsSeries(monthly_time, true);
  
  CopyHigh(_Symbol, PERIOD_MN1, 0, 2, monthly_high);
  CopyLow(_Symbol, PERIOD_MN1, 0, 2, monthly_low);
  CopyTime(_Symbol, PERIOD_MN1, 0, 2, monthly_time);
  
  pmh = monthly_high[1];
  pml = monthly_low[1];
  
  DrawPHL(pmh, pml, "M", PMHLCss, PMHLStyle);

}

//--- Draw premium/discount zones
if(ShowSD)
{
DrawPremiumDiscountZones();
}

//--- Color candles based on trend
if(ShowTrend)
{
color trend_color;
if(Style == "Colored")
trend_color = (itrend == 1) ? SwingBullCss : SwingBearCss;
else // Monochrome
trend_color = (itrend == 1) ? C'178,181,190' : C'93,96,107';

  // This would require using chart objects to color candles
  // In MQL5, we can't directly color candles without using a custom candlestick plot
  // This is a limitation compared to Pine Script

}

//--- Return value
return(rates_total);
}
//+------------------------------------------------------------------+`

can you please drop it in a coded document