//+------------------------------------------------------------------+
//|                    CompleteStructure_MinorZones_EA.mq5           |
//|   Major Zones (4H) + Minor Zones (15m) with Full Validation      |
//+------------------------------------------------------------------+
#property copyright "Professional Trader & AI Assistant"
#property version "4.00"
#property strict

//--- Input Parameters - Major Structure (4H)
input int MajorPivotLookback = 3;
input int MaxBarsToScan = 500;
input color BullishZoneColor = clrLime;
input color BearishZoneColor = clrRed;
input color InvalidZoneColor = clrGray;

//--- Input Parameters - Minor Structure (15m)
input int MinorWickLookback = 2;
input double WickToBodyRatio = 2.0;
input color MinorHighZoneColor = clrOrange;
input color MinorLowZoneColor = clrDodgerBlue;
input color MinorInvalidColor = clrSilver;
input color EquilibriumColor = clrYellow;

//--- ساختار داده برای ماژور
struct MajorZone
{
    double zoneHigh;
    double zoneLow;
    datetime zoneTime;
    int barIndex;
    bool isValid;
};

//--- ساختار داده برای مینور
struct MinorZone
{
    double zoneHigh;
    double zoneLow;
    datetime zoneTime;
    int barIndex;
    bool isValid;
    bool isLongSignal; // true = سیگنال لانگ (کف مینور), false = سیگنال شورت (سقف مینور)
};

//--- آرایه‌های ماژور
MajorZone majorLows[];
MajorZone majorHighs[];
int currentLowIndex = -1;
int currentHighIndex = -1;

//--- آرایه‌های مینور
MinorZone minorLows[];
MinorZone minorHighs[];
int currentMinorLowIndex = -1;
int currentMinorHighIndex = -1;

//--- متغیرهای بایاس و نواحی
string biasDirection = "NEUTRAL";
double equilibriumPrice = 0;
double premiumZone = 0;
double discountZone = 0;
bool structureValid = false;

//--- پیشوند آبجکت‌ها
string mzPrefix = "MZ_";
string qzPrefix = "QZ_";
string mnPrefix = "MN_";

//+------------------------------------------------------------------+
int OnInit()
{
    ArrayResize(majorLows, 0);
    ArrayResize(majorHighs, 0);
    ArrayResize(minorLows, 0);
    ArrayResize(minorHighs, 0);
    Print("EA v4.0 Initialized. Major + Minor Zones with Full Validation.");
    return (INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
    ObjectsDeleteAll(0, mzPrefix);
    ObjectsDeleteAll(0, qzPrefix);
    ObjectsDeleteAll(0, mnPrefix);
    Comment("");
}

//+------------------------------------------------------------------+
void OnTick()
{
    // 1. دریافت داده‌های 4H
    double high4H[], low4H[], open4H[], close4H[];
    datetime time4H[];

    ArraySetAsSeries(high4H, true);
    ArraySetAsSeries(low4H, true);
    ArraySetAsSeries(open4H, true);
    ArraySetAsSeries(close4H, true);
    ArraySetAsSeries(time4H, true);

    int copied4H = CopyHigh(_Symbol, PERIOD_H4, 0, MaxBarsToScan, high4H);
    CopyLow(_Symbol, PERIOD_H4, 0, MaxBarsToScan, low4H);
    CopyOpen(_Symbol, PERIOD_H4, 0, MaxBarsToScan, open4H);
    CopyClose(_Symbol, PERIOD_H4, 0, MaxBarsToScan, close4H);
    CopyTime(_Symbol, PERIOD_H4, 0, MaxBarsToScan, time4H);

    if (copied4H <= 0)
        return;

    // 2. بررسی بی‌اعتباری ماژورهای جاری
    CheckCurrentZonesInvalidation(close4H);

    // 3. به‌روزرسانی ماژورها (فقط در کندل جدید 4H)
    static datetime lastBarTime4H = 0;
    datetime currentBarTime4H = time4H[0];

    if (lastBarTime4H != currentBarTime4H)
    {
        lastBarTime4H = currentBarTime4H;
        UpdateCurrentZones(high4H, low4H, open4H, close4H, time4H, copied4H);
    }

    // 4. اعتبارسنجی ساختاری و بایاس
    ValidateStructure();
    DetermineBias();

    // 5. رسم ماژورها
    DrawAllMajorZones();

    // 6. اگر ساختار معتبر است، مینورها را پردازش کن
    if (structureValid)
    {
        CalculateQuartileZones();
        DrawQuartileZones();
        ProcessMinorZones();
    }

    // 7. داشبورد
    DisplayDashboard();
}

//+------------------------------------------------------------------+
//| بررسی بی‌اعتباری ماژورهای جاری                                   |
//+------------------------------------------------------------------+
void CheckCurrentZonesInvalidation(double &close4H[])
{
    if (currentLowIndex >= 0 && currentLowIndex < ArraySize(majorLows))
    {
        if (majorLows[currentLowIndex].isValid)
        {
            for (int i = 0; i <= majorLows[currentLowIndex].barIndex; i++)
            {
                if (close4H[i] < majorLows[currentLowIndex].zoneLow)
                {
                    majorLows[currentLowIndex].isValid = false;
                    Print("Major Low INVALIDATED at index ", currentLowIndex);
                    break;
                }
            }
        }
    }

    if (currentHighIndex >= 0 && currentHighIndex < ArraySize(majorHighs))
    {
        if (majorHighs[currentHighIndex].isValid)
        {
            for (int i = 0; i <= majorHighs[currentHighIndex].barIndex; i++)
            {
                if (close4H[i] > majorHighs[currentHighIndex].zoneHigh)
                {
                    majorHighs[currentHighIndex].isValid = false;
                    Print("Major High INVALIDATED at index ", currentHighIndex);
                    break;
                }
            }
        }
    }
}

//+------------------------------------------------------------------+
//| به‌روزرسانی ماژورها                                              |
//+------------------------------------------------------------------+
void UpdateCurrentZones(double &high4H[], double &low4H[], double &open4H[], double &close4H[], datetime &time4H[], int total)
{
    // مدیریت کف‌ها
    bool needNewLow = (currentLowIndex == -1 || !majorLows[currentLowIndex].isValid);
    if (needNewLow)
    {
        bool foundPrevious = false;
        for (int i = ArraySize(majorLows) - 1; i >= 0; i--)
        {
            if (majorLows[i].isValid)
            {
                currentLowIndex = i;
                foundPrevious = true;
                break;
            }
        }

        if (!foundPrevious)
        {
            MajorZone newLow;
            if (FindNewMajorLow(high4H, low4H, open4H, close4H, time4H, total, newLow))
            {
                int newSize = ArraySize(majorLows);
                ArrayResize(majorLows, newSize + 1);
                majorLows[newSize] = newLow;
                currentLowIndex = newSize;
            }
            else
            {
                currentLowIndex = -1;
            }
        }
    }

    // مدیریت سقف‌ها
    bool needNewHigh = (currentHighIndex == -1 || !majorHighs[currentHighIndex].isValid);
    if (needNewHigh)
    {
        bool foundPrevious = false;
        for (int i = ArraySize(majorHighs) - 1; i >= 0; i--)
        {
            if (majorHighs[i].isValid)
            {
                currentHighIndex = i;
                foundPrevious = true;
                break;
            }
        }

        if (!foundPrevious)
        {
            MajorZone newHigh;
            if (FindNewMajorHigh(high4H, low4H, open4H, close4H, time4H, total, newHigh))
            {
                int newSize = ArraySize(majorHighs);
                ArrayResize(majorHighs, newSize + 1);
                majorHighs[newSize] = newHigh;
                currentHighIndex = newSize;
            }
            else
            {
                currentHighIndex = -1;
            }
        }
    }
}

//+------------------------------------------------------------------+
bool FindNewMajorLow(double &high[], double &low[], double &open[], double &close[], datetime &time[], int total, MajorZone &outZone)
{
    int lastMinorHighIdx = -1;
    int lastMinorLowIdx = -1;

    for (int i = total - MajorPivotLookback - 1; i >= MajorPivotLookback; i--)
    {
        if (IsPivot(high, i, true, total, MajorPivotLookback))
            lastMinorHighIdx = i;
        if (IsPivot(low, i, false, total, MajorPivotLookback))
            lastMinorLowIdx = i;

        if (lastMinorHighIdx != -1 && i < lastMinorHighIdx && close[i] > high[lastMinorHighIdx])
        {
            if (lastMinorLowIdx != -1 && lastMinorLowIdx > lastMinorHighIdx)
            {
                bool stillValid = true;
                for (int j = 0; j <= i; j++)
                {
                    if (close[j] < low[lastMinorLowIdx])
                    {
                        stillValid = false;
                        break;
                    }
                }

                if (stillValid)
                {
                    outZone.zoneLow = low[lastMinorLowIdx];
                    outZone.zoneHigh = open[lastMinorLowIdx];
                    outZone.zoneTime = time[lastMinorLowIdx];
                    outZone.barIndex = lastMinorLowIdx;
                    outZone.isValid = true;
                    return true;
                }
            }
        }
    }
    return false;
}

//+------------------------------------------------------------------+
bool FindNewMajorHigh(double &high[], double &low[], double &open[], double &close[], datetime &time[], int total, MajorZone &outZone)
{
    int lastMinorHighIdx = -1;
    int lastMinorLowIdx = -1;

    for (int i = total - MajorPivotLookback - 1; i >= MajorPivotLookback; i--)
    {
        if (IsPivot(high, i, true, total, MajorPivotLookback))
            lastMinorHighIdx = i;
        if (IsPivot(low, i, false, total, MajorPivotLookback))
            lastMinorLowIdx = i;

        if (lastMinorLowIdx != -1 && i < lastMinorLowIdx && close[i] < low[lastMinorLowIdx])
        {
            if (lastMinorHighIdx != -1 && lastMinorHighIdx > lastMinorLowIdx)
            {
                bool stillValid = true;
                for (int j = 0; j <= i; j++)
                {
                    if (close[j] > high[lastMinorHighIdx])
                    {
                        stillValid = false;
                        break;
                    }
                }

                if (stillValid)
                {
                    outZone.zoneHigh = high[lastMinorHighIdx];
                    outZone.zoneLow = open[lastMinorHighIdx];
                    outZone.zoneTime = time[lastMinorHighIdx];
                    outZone.barIndex = lastMinorHighIdx;
                    outZone.isValid = true;
                    return true;
                }
            }
        }
    }
    return false;
}

//+------------------------------------------------------------------+
bool IsPivot(double &data[], int idx, bool isHigh, int total, int lookback)
{
    for (int j = 1; j <= lookback; j++)
    {
        if (idx - j < 0 || idx + j >= total)
            continue;
        if (isHigh)
        {
            if (data[idx] <= data[idx - j] || data[idx] <= data[idx + j])
                return false;
        }
        else
        {
            if (data[idx] >= data[idx - j] || data[idx] >= data[idx + j])
                return false;
        }
    }
    return true;
}

//+------------------------------------------------------------------+
void ValidateStructure()
{
    structureValid = false;

    if (currentLowIndex >= 0 && currentHighIndex >= 0)
    {
        if (majorLows[currentLowIndex].isValid && majorHighs[currentHighIndex].isValid)
        {
            if (majorHighs[currentHighIndex].zoneHigh > majorLows[currentLowIndex].zoneHigh)
            {
                structureValid = true;
            }
            else
            {
                majorLows[currentLowIndex].isValid = false;
                majorHighs[currentHighIndex].isValid = false;
            }
        }
    }
}

//+------------------------------------------------------------------+
void DetermineBias()
{
    if (!structureValid)
    {
        biasDirection = "NEUTRAL";
        return;
    }

    if (majorHighs[currentHighIndex].barIndex < majorLows[currentLowIndex].barIndex)
    {
        biasDirection = "BEARISH";
    }
    else if (majorLows[currentLowIndex].barIndex < majorHighs[currentHighIndex].barIndex)
    {
        biasDirection = "BULLISH";
    }
    else
    {
        biasDirection = "NEUTRAL";
    }
}

//+------------------------------------------------------------------+
void DrawAllMajorZones()
{
    for (int i = 0; i < ArraySize(majorLows); i++)
    {
        string objName = mzPrefix + "Low_" + IntegerToString(i);

        if (ObjectFind(0, objName) < 0)
        {
            ObjectCreate(0, objName, OBJ_RECTANGLE, 0, 0, 0, 0, 0);
            ObjectSetInteger(0, objName, OBJPROP_FILL, true);
            ObjectSetInteger(0, objName, OBJPROP_BACK, true);
            ObjectSetInteger(0, objName, OBJPROP_SELECTABLE, false);
        }

        color zoneColor = majorLows[i].isValid ? BullishZoneColor : InvalidZoneColor;
        ObjectSetInteger(0, objName, OBJPROP_COLOR, zoneColor);
        ObjectSetDouble(0, objName, OBJPROP_PRICE, 0, majorLows[i].zoneHigh);
        ObjectSetDouble(0, objName, OBJPROP_PRICE, 1, majorLows[i].zoneLow);
        ObjectSetInteger(0, objName, OBJPROP_TIME, 0, majorLows[i].zoneTime);
        ObjectSetInteger(0, objName, OBJPROP_TIME, 1, TimeCurrent());
    }

    for (int i = 0; i < ArraySize(majorHighs); i++)
    {
        string objName = mzPrefix + "High_" + IntegerToString(i);

        if (ObjectFind(0, objName) < 0)
        {
            ObjectCreate(0, objName, OBJ_RECTANGLE, 0, 0, 0, 0, 0);
            ObjectSetInteger(0, objName, OBJPROP_FILL, true);
            ObjectSetInteger(0, objName, OBJPROP_BACK, true);
            ObjectSetInteger(0, objName, OBJPROP_SELECTABLE, false);
        }

        color zoneColor = majorHighs[i].isValid ? BearishZoneColor : InvalidZoneColor;
        ObjectSetInteger(0, objName, OBJPROP_COLOR, zoneColor);
        ObjectSetDouble(0, objName, OBJPROP_PRICE, 0, majorHighs[i].zoneHigh);
        ObjectSetDouble(0, objName, OBJPROP_PRICE, 1, majorHighs[i].zoneLow);
        ObjectSetInteger(0, objName, OBJPROP_TIME, 0, majorHighs[i].zoneTime);
        ObjectSetInteger(0, objName, OBJPROP_TIME, 1, TimeCurrent());
    }

    ChartRedraw();
}

//+------------------------------------------------------------------+
void CalculateQuartileZones()
{
    double majorHigh = majorHighs[currentHighIndex].zoneHigh;
    double majorLow = majorLows[currentLowIndex].zoneLow;
    double range = majorHigh - majorLow;

    equilibriumPrice = majorLow + (range * 0.50);
    premiumZone = majorLow + (range * 0.75);
    discountZone = majorLow + (range * 0.25);
}

//+------------------------------------------------------------------+
void DrawQuartileZones()
{
    string eqName = qzPrefix + "Equilibrium";
    if (ObjectFind(0, eqName) < 0)
    {
        ObjectCreate(0, eqName, OBJ_HLINE, 0, 0, equilibriumPrice);
        ObjectSetInteger(0, eqName, OBJPROP_COLOR, EquilibriumColor);
        ObjectSetInteger(0, eqName, OBJPROP_STYLE, STYLE_DASHDOT);
        ObjectSetInteger(0, eqName, OBJPROP_WIDTH, 2);
    }
    else
    {
        ObjectSetDouble(0, eqName, OBJPROP_PRICE, 0, equilibriumPrice);
    }

    string topName = qzPrefix + "Top25";
    if (ObjectFind(0, topName) < 0)
    {
        ObjectCreate(0, topName, OBJ_HLINE, 0, 0, premiumZone);
        ObjectSetInteger(0, topName, OBJPROP_COLOR, clrDarkRed);
        ObjectSetInteger(0, topName, OBJPROP_STYLE, STYLE_DOT);
    }
    else
    {
        ObjectSetDouble(0, topName, OBJPROP_PRICE, 0, premiumZone);
    }

    string botName = qzPrefix + "Bottom25";
    if (ObjectFind(0, botName) < 0)
    {
        ObjectCreate(0, botName, OBJ_HLINE, 0, 0, discountZone);
        ObjectSetInteger(0, botName, OBJPROP_COLOR, clrDarkGreen);
        ObjectSetInteger(0, botName, OBJPROP_STYLE, STYLE_DOT);
    }
    else
    {
        ObjectSetDouble(0, botName, OBJPROP_PRICE, 0, discountZone);
    }

    ChartRedraw();
}

//+------------------------------------------------------------------+
//| پردازش مینورها: بررسی اعتبار + جستجوی جدید                      |
//+------------------------------------------------------------------+
void ProcessMinorZones()
{
    // 1. دریافت داده‌های 15 دقیقه
    double high15m[], low15m[], open15m[], close15m[];
    datetime time15m[];

    ArraySetAsSeries(high15m, true);
    ArraySetAsSeries(low15m, true);
    ArraySetAsSeries(open15m, true);
    ArraySetAsSeries(close15m, true);
    ArraySetAsSeries(time15m, true);

    int copied15m = CopyHigh(_Symbol, PERIOD_M15, 0, 500, high15m);
    CopyLow(_Symbol, PERIOD_M15, 0, 500, low15m);
    CopyOpen(_Symbol, PERIOD_M15, 0, 500, open15m);
    CopyClose(_Symbol, PERIOD_M15, 0, 500, close15m);
    CopyTime(_Symbol, PERIOD_M15, 0, 500, time15m);

    if (copied15m <= 0)
        return;

    // 2. بررسی بی‌اعتباری مینورهای جاری
    CheckMinorZonesInvalidation(close15m);

    // 3. به‌روزرسانی مینورها (در هر تیک، چون 15 دقیقه سریع‌تر است)
    UpdateCurrentMinorZones(high15m, low15m, open15m, close15m, time15m, copied15m);

    // 4. رسم تمام مینورها
    DrawAllMinorZones();
}

//+------------------------------------------------------------------+
//| بررسی بی‌اعتباری مینورهای جاری با Close کندل 15 دقیقه            |
//+------------------------------------------------------------------+
void CheckMinorZonesInvalidation(double &close15m[])
{
    // بررسی کف مینور جاری
    if (currentMinorLowIndex >= 0 && currentMinorLowIndex < ArraySize(minorLows))
    {
        if (minorLows[currentMinorLowIndex].isValid)
        {
            for (int i = 0; i <= minorLows[currentMinorLowIndex].barIndex; i++)
            {
                if (close15m[i] < minorLows[currentMinorLowIndex].zoneLow)
                {
                    minorLows[currentMinorLowIndex].isValid = false;
                    Print("Minor Low INVALIDATED at index ", currentMinorLowIndex);
                    break;
                }
            }
        }
    }

    // بررسی سقف مینور جاری
    if (currentMinorHighIndex >= 0 && currentMinorHighIndex < ArraySize(minorHighs))
    {
        if (minorHighs[currentMinorHighIndex].isValid)
        {
            for (int i = 0; i <= minorHighs[currentMinorHighIndex].barIndex; i++)
            {
                if (close15m[i] > minorHighs[currentMinorHighIndex].zoneHigh)
                {
                    minorHighs[currentMinorHighIndex].isValid = false;
                    Print("Minor High INVALIDATED at index ", currentMinorHighIndex);
                    break;
                }
            }
        }
    }
}

//+------------------------------------------------------------------+
//| به‌روزرسانی مینورها                                              |
//+------------------------------------------------------------------+
void UpdateCurrentMinorZones(double &high15m[], double &low15m[], double &open15m[], double &close15m[], datetime &time15m[], int total)
{
    // مدیریت کف‌های مینور (فقط در بایاس صعودی)
    if (biasDirection == "BULLISH")
    {
        bool needNewMinorLow = (currentMinorLowIndex == -1 || !minorLows[currentMinorLowIndex].isValid);
        if (needNewMinorLow)
        {
            bool foundPrevious = false;
            for (int i = ArraySize(minorLows) - 1; i >= 0; i--)
            {
                if (minorLows[i].isValid)
                {
                    currentMinorLowIndex = i;
                    foundPrevious = true;
                    break;
                }
            }

            if (!foundPrevious)
            {
                MinorZone newMinorLow;
                if (FindNewMinorLow(high15m, low15m, open15m, close15m, time15m, total, newMinorLow))
                {
                    int newSize = ArraySize(minorLows);
                    ArrayResize(minorLows, newSize + 1);
                    minorLows[newSize] = newMinorLow;
                    currentMinorLowIndex = newSize;
                    Print("New Minor Low Zone found at index: ", newSize);
                }
                else
                {
                    currentMinorLowIndex = -1;
                }
            }
        }
    }

    // مدیریت سقف‌های مینور (فقط در بایاس نزولی)
    if (biasDirection == "BEARISH")
    {
        bool needNewMinorHigh = (currentMinorHighIndex == -1 || !minorHighs[currentMinorHighIndex].isValid);
        if (needNewMinorHigh)
        {
            bool foundPrevious = false;
            for (int i = ArraySize(minorHighs) - 1; i >= 0; i--)
            {
                if (minorHighs[i].isValid)
                {
                    currentMinorHighIndex = i;
                    foundPrevious = true;
                    break;
                }
            }

            if (!foundPrevious)
            {
                MinorZone newMinorHigh;
                if (FindNewMinorHigh(high15m, low15m, open15m, close15m, time15m, total, newMinorHigh))
                {
                    int newSize = ArraySize(minorHighs);
                    ArrayResize(minorHighs, newSize + 1);
                    minorHighs[newSize] = newMinorHigh;
                    currentMinorHighIndex = newSize;
                    Print("New Minor High Zone found at index: ", newSize);
                }
                else
                {
                    currentMinorHighIndex = -1;
                }
            }
        }
    }
}

//+------------------------------------------------------------------+
//| پیدا کردن کف مینور جدید (ناحیه Wick-to-Body در Discount)         |
//+------------------------------------------------------------------+
bool FindNewMinorLow(double &high[], double &low[], double &open[], double &close[], datetime &time[], int total, MinorZone &outZone)
{
    for (int i = 1; i < total - MinorWickLookback; i++)
    {
        double bodyTop = MathMax(open[i], close[i]);
        double bodyBot = MathMin(open[i], close[i]);
        double bodySize = bodyTop - bodyBot;

        double lowerWick = bodyBot - low[i];

        // شرط 1: شدوی پایینی بلند (حداقل 2 برابر بدنه)
        // شرط 2: نوک شدو در ناحیه Discount (زیر 50%)
        // شرط 3: بدنه بالای 50% بسته شده
        if (lowerWick > 0 && bodySize > 0 && (lowerWick / bodySize) >= WickToBodyRatio)
        {
            if (low[i] < equilibriumPrice && bodyBot > equilibriumPrice)
            {
                // بررسی اعتبار: آیا از زمان تشکیل تا الان شکسته شده؟
                bool stillValid = true;
                for (int j = 0; j <= i; j++)
                {
                    if (close[j] < low[i])
                    {
                        stillValid = false;
                        break;
                    }
                }

                if (stillValid)
                {
                    outZone.zoneLow = low[i];   // نوک شدو
                    outZone.zoneHigh = open[i]; // ابتدای بدنه (Wick-to-Body)
                    outZone.zoneTime = time[i];
                    outZone.barIndex = i;
                    outZone.isValid = true;
                    outZone.isLongSignal = true;
                    return true;
                }
            }
        }
    }
    return false;
}

//+------------------------------------------------------------------+
//| پیدا کردن سقف مینور جدید (ناحیه Wick-to-Body در Premium)        |
//+------------------------------------------------------------------+
bool FindNewMinorHigh(double &high[], double &low[], double &open[], double &close[], datetime &time[], int total, MinorZone &outZone)
{
    for (int i = 1; i < total - MinorWickLookback; i++)
    {
        double bodyTop = MathMax(open[i], close[i]);
        double bodyBot = MathMin(open[i], close[i]);
        double bodySize = bodyTop - bodyBot;

        double upperWick = high[i] - bodyTop;

        // شرط 1: شدوی بالایی بلند
        // شرط 2: نوک شدو در ناحیه Premium (بالای 50%)
        // شرط 3: بدنه زیر 50% بسته شده
        if (upperWick > 0 && bodySize > 0 && (upperWick / bodySize) >= WickToBodyRatio)
        {
            if (high[i] > equilibriumPrice && bodyTop < equilibriumPrice)
            {
                bool stillValid = true;
                for (int j = 0; j <= i; j++)
                {
                    if (close[j] > high[i])
                    {
                        stillValid = false;
                        break;
                    }
                }

                if (stillValid)
                {
                    outZone.zoneHigh = high[i]; // نوک شدو
                    outZone.zoneLow = open[i];  // ابتدای بدنه (Wick-to-Body)
                    outZone.zoneTime = time[i];
                    outZone.barIndex = i;
                    outZone.isValid = true;
                    outZone.isLongSignal = false;
                    return true;
                }
            }
        }
    }
    return false;
}

//+------------------------------------------------------------------+
//| رسم تمام مینورها (معتبر و نامعتبر)                               |
//+------------------------------------------------------------------+
void DrawAllMinorZones()
{
    // رسم کف‌های مینور
    for (int i = 0; i < ArraySize(minorLows); i++)
    {
        string objName = mnPrefix + "Low_" + IntegerToString(i);

        if (ObjectFind(0, objName) < 0)
        {
            ObjectCreate(0, objName, OBJ_RECTANGLE, 0, 0, 0, 0, 0);
            ObjectSetInteger(0, objName, OBJPROP_FILL, true);
            ObjectSetInteger(0, objName, OBJPROP_BACK, true);
            ObjectSetInteger(0, objName, OBJPROP_SELECTABLE, false);
        }

        color zoneColor = minorLows[i].isValid ? MinorLowZoneColor : MinorInvalidColor;
        ObjectSetInteger(0, objName, OBJPROP_COLOR, zoneColor);
        ObjectSetDouble(0, objName, OBJPROP_PRICE, 0, minorLows[i].zoneHigh);
        ObjectSetDouble(0, objName, OBJPROP_PRICE, 1, minorLows[i].zoneLow);
        ObjectSetInteger(0, objName, OBJPROP_TIME, 0, minorLows[i].zoneTime);
        ObjectSetInteger(0, objName, OBJPROP_TIME, 1, TimeCurrent());
    }

    // رسم سقف‌های مینور
    for (int i = 0; i < ArraySize(minorHighs); i++)
    {
        string objName = mnPrefix + "High_" + IntegerToString(i);

        if (ObjectFind(0, objName) < 0)
        {
            ObjectCreate(0, objName, OBJ_RECTANGLE, 0, 0, 0, 0, 0);
            ObjectSetInteger(0, objName, OBJPROP_FILL, true);
            ObjectSetInteger(0, objName, OBJPROP_BACK, true);
            ObjectSetInteger(0, objName, OBJPROP_SELECTABLE, false);
        }

        color zoneColor = minorHighs[i].isValid ? MinorHighZoneColor : MinorInvalidColor;
        ObjectSetInteger(0, objName, OBJPROP_COLOR, zoneColor);
        ObjectSetDouble(0, objName, OBJPROP_PRICE, 0, minorHighs[i].zoneHigh);
        ObjectSetDouble(0, objName, OBJPROP_PRICE, 1, minorHighs[i].zoneLow);
        ObjectSetInteger(0, objName, OBJPROP_TIME, 0, minorHighs[i].zoneTime);
        ObjectSetInteger(0, objName, OBJPROP_TIME, 1, TimeCurrent());
    }

    ChartRedraw();
}

//+------------------------------------------------------------------+
void DisplayDashboard()
{
    string dash = "\n========== COMPLETE STRUCTURE (v4.0) ==========\n";
    dash += "Symbol: " + _Symbol + "\n";
    dash += "------------------------------------------------------\n";

    if (structureValid)
    {
        dash += "MAJOR HIGH: " + DoubleToString(majorHighs[currentHighIndex].zoneHigh, _Digits) + "\n";
        dash += "MAJOR LOW:  " + DoubleToString(majorLows[currentLowIndex].zoneLow, _Digits) + "\n";
        dash += "------------------------------------------------------\n";
        dash += "Equilibrium (50%): " + DoubleToString(equilibriumPrice, _Digits) + "\n";
        dash += "Premium (75%): " + DoubleToString(premiumZone, _Digits) + "\n";
        dash += "Discount (25%): " + DoubleToString(discountZone, _Digits) + "\n";
        dash += "------------------------------------------------------\n";
        dash += "BIAS: " + biasDirection + "\n";
        dash += "------------------------------------------------------\n";

        if (currentMinorLowIndex >= 0)
        {
            dash += "Current Minor Low: " + (minorLows[currentMinorLowIndex].isValid ? "✓ VALID" : " INVALID") + "\n";
            dash += "  Zone: " + DoubleToString(minorLows[currentMinorLowIndex].zoneLow, _Digits) +
                    " - " + DoubleToString(minorLows[currentMinorLowIndex].zoneHigh, _Digits) + "\n";
        }

        if (currentMinorHighIndex >= 0)
        {
            dash += "Current Minor High: " + (minorHighs[currentMinorHighIndex].isValid ? "✓ VALID" : "✗ INVALID") + "\n";
            dash += "  Zone: " + DoubleToString(minorHighs[currentMinorHighIndex].zoneLow, _Digits) +
                    " - " + DoubleToString(minorHighs[currentMinorHighIndex].zoneHigh, _Digits) + "\n";
        }
    }
    else
    {
        dash += "Structure: INVALID - Waiting for valid Major Zones\n";
    }

    dash += "======================================================\n";

    Comment(dash);
}
//+------------------------------------------------------------------+