//
// Peaks ...
int peaksCount = ArraySize(conditions.peaks);
if (IsValidSize(peaksCount))
{
    //
    for (int i = 0; i < peaksCount; i++)
    {
        //
        XPVPivot iPivot = conditions.peaks[i];

        //
        XCXPVPivotObject *iObj;
        iObj = new XCXPVPivotObject();

        //
        bool isCreated = iObj.Create(
            mPOIDrawer.ChartIdentification(),
            mPOIDrawer.SubWindowIdentification(),
            iPivot //
        );
        if (isCreated)
        {
            //
            iObj.PivotWidth(1);
            iObj.PivotFill(false);
            iObj.PivotColor(clrAqua);
            iObj.PivotStyle(STYLE_SOLID);

            //
            AddObjectIfNotExists(iObj);
        }
    }
}

//
// Vales ...
int valesCount = ArraySize(conditions.vales);
if (IsValidSize(valesCount))
{
    //
    for (int i = 0; i < valesCount; i++)
    {
        //
        XPVPivot iPivot = conditions.vales[i];

        //
        XCXPVPivotObject *iObj;
        iObj = new XCXPVPivotObject();

        //
        bool isCreated = iObj.Create(
            mPOIDrawer.ChartIdentification(),
            mPOIDrawer.SubWindowIdentification(),
            iPivot //
        );
        if (isCreated)
        {
            //
            iObj.PivotWidth(1);
            iObj.PivotFill(false);
            iObj.PivotStyle(STYLE_SOLID);
            iObj.PivotColor(clrMagenta);

            //
            AddObjectIfNotExists(iObj);
        }
    }
}

///////////////////////////////////////////////////////////////////
// Conditions Parsing ...
///////////////////////////////////////////////////////////////////

//
// Conditions Props ...

//
// D1 ...

//
XPOIState d1State;
ENUM_X_DIRECTION d1MarketDirection;
XCSupportZone *d1SupportZones[];
XCResistanceZone *d1ResistanceZones[];

//
XCSwing *d1SwingHigh;
XCSwing *d1SwingLow;

//
// H4 ...

//
XPOIState h4State;
ENUM_X_DIRECTION h4MarketDirection;
XCSupportZone *h4SupportZones[];
XCResistanceZone *h4ResistanceZones[];

//
XCSwing *h4SwingHigh;
XCSwing *h4SwingLow;

//
// H2 ...

//
XPOIState h2State;
ENUM_X_DIRECTION h2MarketDirection;
XCSupportZone *h2SupportZones[];
XCResistanceZone *h2ResistanceZones[];

//
XCSwing *h2SwingHigh;
XCSwing *h2SwingLow;

//
// H1 ...

//
XPOIState h1State;
ENUM_X_DIRECTION h1MarketDirection;
XCSupportZone *h1SupportZones[];
XCResistanceZone *h1ResistanceZones[];

//
XCSwing *h1SwingHigh;
XCSwing *h1SwingLow;

//
// M15 ...

//
XPOIState m15State;
ENUM_X_DIRECTION m15MarketDirection;
XCSupportZone *m15SupportZones[];
XCResistanceZone *m15ResistanceZones[];

//
XCSwing *m15SwingHigh;
XCSwing *m15SwingLow;

//
// M5 ...

//
XPOIState m5State;
ENUM_X_DIRECTION m5MarketDirection;
XCSupportZone *m5SupportZones[];
XCResistanceZone *m5ResistanceZones[];

//
XCSwing *m5SwingHigh;
XCSwing *m5SwingLow;

//
// M1 ...

//
XPOIState m1State;
ENUM_X_DIRECTION m1MarketDirection;
XCSupportZone *m1SupportZones[];
XCResistanceZone *m1ResistanceZones[];

//
XCSwing *m1SwingHigh;
XCSwing *m1SwingLow;

//
// Clean Method ...

//
// D1 ...

//
d1State.Clean();
d1MarketDirection = X_DIRECTION_NONE;
Clean(d1SupportZones);
Clean(d1ResistanceZones);

//
d1SwingHigh = NULL;
d1SwingLow = NULL;

//
// H4 ...

//
h4State.Clean();
h4MarketDirection = X_DIRECTION_NONE;
Clean(h4SupportZones);
Clean(h4ResistanceZones);

//
h4SwingHigh = NULL;
h4SwingLow = NULL;

//
// H2 ...

//
h2State.Clean();
h2MarketDirection = X_DIRECTION_NONE;
Clean(h2SupportZones);
Clean(h2ResistanceZones);

//
h2SwingHigh = NULL;
h2SwingLow = NULL;

//
// H1 ...

//
h1State.Clean();
h1MarketDirection = X_DIRECTION_NONE;
Clean(h1SupportZones);
Clean(h1ResistanceZones);

//
h1SwingHigh = NULL;
h1SwingLow = NULL;

//
// M15 ...

//
m15State.Clean();
m15MarketDirection = X_DIRECTION_NONE;
Clean(m15SupportZones);
Clean(m15ResistanceZones);

//
m15SwingHigh = NULL;
m15SwingLow = NULL;

//
// M5 ...

//
m5State.Clean();
m5MarketDirection = X_DIRECTION_NONE;
Clean(m5SupportZones);
Clean(m5ResistanceZones);

//
m5SwingHigh = NULL;
m5SwingLow = NULL;

//
// M1 ...

//
m1State.Clean();
m1MarketDirection = X_DIRECTION_NONE;
Clean(m1SupportZones);
Clean(m1ResistanceZones);

//
m1SwingHigh = NULL;
m1SwingLow = NULL;

//
// Tools Functions ...
//

//
// Custom Tools ...

/**
 * Check Conditions for Detect Market Structure ...
 *
 * @param  structure: ENUM_X_DIRECTION member, Market Structure Direction reference ...
 *
 * @return ( bool )
 */
bool HasMarketStructure(
    ENUM_X_DIRECTION &structure //
)
{
    //
    bool result = false;

    //
    structure = X_DIRECTION_NONE;

    //
    result = IsValid();
    if (!result)
    {
        return result;
    }

    //
    bool is1DBullish = IsBullish(d1MarketDirection);
    bool is1DBearish = IsBearish(d1MarketDirection);

    //
    bool is4HBullish = IsBullish(h4MarketDirection);
    bool is4HBearish = IsBearish(h4MarketDirection);

    //
    bool is2HBullish = IsBullish(h2MarketDirection);
    bool is2HBearish = IsBearish(h2MarketDirection);

    //
    bool is1HBullish = IsBullish(h1MarketDirection);
    bool is1HBearish = IsBearish(h1MarketDirection);

    //
    bool is15MBullish = IsBullish(m15MarketDirection);
    bool is15MBearish = IsBearish(m15MarketDirection);

    //
    bool is5MBullish = IsBullish(m5MarketDirection);
    bool is5MBearish = IsBearish(m5MarketDirection);

    //
    bool is1MBullish = IsBullish(m1MarketDirection);
    bool is1MBearish = IsBearish(m1MarketDirection);

    //
    bool isStructuresBullish =
        //
        is1HBullish &&
        is15MBullish &&
        is5MBullish
        //
        ;

    //
    bool isStructuresBearish =
        //
        is1HBearish &&
        is15MBearish &&
        is5MBearish
        //
        ;

    //
    bool hasMarketStructure =
        isStructuresBullish ||
        isStructuresBearish;
    result = hasMarketStructure;
    if (!result)
    {
        return result;
    }

    //
    structure =
        isStructuresBullish
            ? X_DIRECTION_BULLISH
            : X_DIRECTION_BEARISH;

    //
    return result;
}

//
// Strategy Class Calling on Conditions Detections ...

//
// Detect Market Structures ...

//
// 1D ...
conditions.d1State = _1DState;
result = DetectMarketStructure(
    conditions.d1MarketDirection,
    conditions.d1SupportZones,
    conditions.d1ResistanceZones,
    _1DState //
);
if (!result)
{
    return result;
}

//
// 4H ...
conditions.h4State = _4HState;
result = DetectMarketStructure(
    conditions.h4MarketDirection,
    conditions.h4SupportZones,
    conditions.h4ResistanceZones,
    _4HState //
);
if (!result)
{
    return result;
}

//
// 2H ...
conditions.h2State = _2HState;
result = DetectMarketStructure(
    conditions.h2MarketDirection,
    conditions.h2SupportZones,
    conditions.h2ResistanceZones,
    _2HState //
);
if (!result)
{
    return result;
}

//
// 1H ...
conditions.h1State = _1HState;
result = DetectMarketStructure(
    conditions.h1MarketDirection,
    conditions.h1SupportZones,
    conditions.h1ResistanceZones,
    _1HState //
);
if (!result)
{
    return result;
}

//
// 15M ...
conditions.m15State = _15MState;
result = DetectMarketStructure(
    conditions.m15MarketDirection,
    conditions.m15SupportZones,
    conditions.m15ResistanceZones,
    _15MState //
);
if (!result)
{
    return result;
}

//
// 5M ...
conditions.m5State = _5MState;
result = DetectMarketStructure(
    conditions.m5MarketDirection,
    conditions.m5SupportZones,
    conditions.m5ResistanceZones,
    _5MState //
);
if (!result)
{
    return result;
}

//
// 1M ...
conditions.m1State = _1MState;
result = DetectMarketStructure(
    conditions.m1MarketDirection,
    conditions.m1SupportZones,
    conditions.m1ResistanceZones,
    _1MState //
);
if (!result)
{
    return result;
}

//
// 1H-15M-5M ...
ENUM_X_DIRECTION marketStructure = X_DIRECTION_NONE;
result = conditions.HasMarketStructure(marketStructure);
if (!result)
{
    return result;
}

//
// Detect Swing High and Swing Low ...
// 1H-15M-5M ...
int count = 0;

//
// 1H ...

//
XCSwing *h1SwingLows[];
XCSwing *h1SwingHighs[];
XCSupportZone *h1SupportZone = NULL;
XCResistanceZone *h1ResistanceZone = NULL;

//
count = ArraySize(conditions.h1SupportZones);
if (IsValidSize(count))
{
    //
    for (int i = 0; i < count; i++)
    {
        //
        XCSupportZone *item = conditions.h1SupportZones[i];

        //
        bool canSelect =
            h1SupportZone == NULL ||
            h1SupportZone.Lower() < item.Lower();
        if (canSelect)
        {
            h1SupportZone = item;
        }
    }
}
if (h1SupportZone != NULL)
{
    //
    // Detect Swings ...
    count = ArraySize(conditions.h1State.swingLows);
    if (IsValidSize(count))
    {
        //
        double upper = h1SupportZone.Upper();
        double lower = h1SupportZone.Lower();

        //
        for (int i = 0; i < count; i++)
        {
            //
            XCSwing *item = conditions.h1State.swingLows[i];

            //
            XOHCL iBar;
            bool isFilled = item.FillBar(iBar);
            if (!isFilled)
            {
                continue;
            }

            //
            bool canSelect = (iBar.high <= upper &&
                              iBar.low >= lower) ||
                             (iBar.high >= upper &&
                              iBar.low <= lower);
            if (canSelect)
            {
                //
                Add(
                    item,
                    h1SwingLows //
                );

                //
                // Draw ...
                XCSwingLowObject *iObj;
                bool isCreated = mPOIDrawer.CreateSwingLow(
                    item,
                    iObj //
                );
                if (isCreated)
                {
                    AddObjectIfNotExists(iObj);
                }
            }
        }
    }

    //
    // Draw ...
    XCSupportZoneObject *iObj;
    bool isCreated = mPOIDrawer.CreateSupportZone(
        h1SupportZone,
        iObj //
    );
    if (isCreated)
    {
        AddObjectIfNotExists(iObj);
    }
}

//
count = ArraySize(conditions.h1ResistanceZones);
if (IsValidSize(count))
{
    //
    for (int i = 0; i < count; i++)
    {
        //
        XCResistanceZone *item = conditions.h1ResistanceZones[i];

        //
        bool canSelect =
            h1ResistanceZone == NULL ||
            h1ResistanceZone.Upper() > item.Upper();
        if (canSelect)
        {
            h1ResistanceZone = item;
        }
    }
}
if (h1ResistanceZone != NULL)
{
    //
    // Detect Swings ...
    count = ArraySize(conditions.h1State.swingHighs);
    if (IsValidSize(count))
    {
        //
        double upper = h1ResistanceZone.Upper();
        double lower = h1ResistanceZone.Lower();

        //
        for (int i = 0; i < count; i++)
        {
            //
            XCSwing *item = conditions.h1State.swingHighs[i];

            //
            XOHCL iBar;
            bool isFilled = item.FillBar(iBar);
            if (!isFilled)
            {
                continue;
            }

            //
            bool canSelect = (iBar.high <= upper &&
                              iBar.low >= lower) ||
                             (iBar.high >= upper &&
                              iBar.low <= lower);
            if (canSelect)
            {
                //
                Add(
                    item,
                    h1SwingHighs //
                );

                //
                // Draw ...
                XCSwingHighObject *iObj;
                bool isCreated = mPOIDrawer.CreateSwingHigh(
                    item,
                    iObj //
                );
                if (isCreated)
                {
                    AddObjectIfNotExists(iObj);
                }
            }
        }
    }

    //
    // Draw ...
    XCResistanceZoneObject *iObj;
    bool isCreated = mPOIDrawer.CreateResistanceZone(
        h1ResistanceZone,
        iObj //
    );
    if (isCreated)
    {
        AddObjectIfNotExists(iObj);
    }
}

//
// 15M ...

//
XCSupportZone *m15SupportZone = NULL;
count = ArraySize(conditions.m15SupportZones);
if (IsValidSize(count))
{
    //
    for (int i = 0; i < count; i++)
    {
        //
        XCSupportZone *item = conditions.m15SupportZones[i];

        //
        bool canSelect =
            m15SupportZone == NULL ||
            m15SupportZone.Lower() < item.Lower();
        if (canSelect)
        {
            m15SupportZone = item;
        }
    }
}
if (m15SupportZone != NULL)
{
    //
    XCSupportZoneObject *iObj;
    bool isCreated = mPOIDrawer.CreateSupportZone(
        m15SupportZone,
        iObj //
    );
    if (isCreated)
    {
        AddObjectIfNotExists(iObj);
    }
}

//
XCResistanceZone *m15ResistanceZone = NULL;
count = ArraySize(conditions.m15ResistanceZones);
if (IsValidSize(count))
{
    //
    for (int i = 0; i < count; i++)
    {
        //
        XCResistanceZone *item = conditions.m15ResistanceZones[i];

        //
        bool canSelect =
            m15ResistanceZone == NULL ||
            m15ResistanceZone.Upper() > item.Upper();
        if (canSelect)
        {
            m15ResistanceZone = item;
        }
    }
}
if (m15ResistanceZone != NULL)
{
    //
    XCResistanceZoneObject *iObj;
    bool isCreated = mPOIDrawer.CreateResistanceZone(
        m15ResistanceZone,
        iObj //
    );
    if (isCreated)
    {
        AddObjectIfNotExists(iObj);
    }
}

//
// 5M ...

//
XCSupportZone *m5SupportZone = NULL;
count = ArraySize(conditions.m5SupportZones);
if (IsValidSize(count))
{
    //
    for (int i = 0; i < count; i++)
    {
        //
        XCSupportZone *item = conditions.m5SupportZones[i];

        //
        bool canSelect =
            m5SupportZone == NULL ||
            m5SupportZone.Lower() < item.Lower();
        if (canSelect)
        {
            m5SupportZone = item;
        }
    }
}
if (m5SupportZone != NULL)
{
    //
    XCSupportZoneObject *iObj;
    bool isCreated = mPOIDrawer.CreateSupportZone(
        m5SupportZone,
        iObj //
    );
    if (isCreated)
    {
        AddObjectIfNotExists(iObj);
    }
}

//
XCResistanceZone *m5ResistanceZone = NULL;
count = ArraySize(conditions.m5ResistanceZones);
if (IsValidSize(count))
{
    //
    for (int i = 0; i < count; i++)
    {
        //
        XCResistanceZone *item = conditions.m5ResistanceZones[i];

        //
        bool canSelect =
            m5ResistanceZone == NULL ||
            m5ResistanceZone.Upper() > item.Upper();
        if (canSelect)
        {
            m5ResistanceZone = item;
        }
    }
}
if (m5ResistanceZone != NULL)
{
    //
    XCResistanceZoneObject *iObj;
    bool isCreated = mPOIDrawer.CreateResistanceZone(
        m5ResistanceZone,
        iObj //
    );
    if (isCreated)
    {
        AddObjectIfNotExists(iObj);
    }
}

//
// DrawState(_5MState);

//
//
// Strategy Class Tools Functions ...

/**
 * Detect Specified States Market Structure ...
 *
 * @param  dir: ENUM_X_DIRECTION member, Refrence ...
 * @param  state: XPOIState instance ...
 *
 * @return ( bool )
 */
bool DetectMarketStructure(
    ENUM_X_DIRECTION &dir,
    XCSupportZone *&supportZones[],
    XCResistanceZone *&resistanceZones[],
    XPOIState &state //
)
{
    //
    bool result = false;

    //
    int count = 0;

    //
    // Filter Untouched Supports ...
    Clean(supportZones);
    int untouchedSupportsCount = 0;
    count = ArraySize(state.supportZones);
    if (IsValidSize(count))
    {
        //
        for (int i = 0; i < count; i++)
        {
            //
            XCSupportZone *item = state.supportZones[i];

            //
            // Find Breakout Bar
            XOHCL iBar;
            bool isFilled = item.FillBar(iBar);
            if (!isFilled)
            {
                break;
            }

            //
            int iBarIndex = iBar.Index();
            int iBarUnTouchedCount = 0;
            for (int j = 0; j < iBarIndex; j++)
            {
                //
                XOHCL jBar;
                bool isInited = jBar.Init(
                    iBar.symbol,
                    iBar.period,
                    j //
                );
                if (!isInited)
                {
                    break;
                }

                //
                bool isUntouched =
                    jBar.low > item.Upper();
                if (isUntouched)
                {
                    iBarUnTouchedCount++;
                }
                else
                {
                    iBarUnTouchedCount--;
                }
            }

            //
            if (iBarUnTouchedCount > 0)
            {
                //
                Add(
                    item,
                    supportZones //
                );
            }
        }

        //
        untouchedSupportsCount = ArraySize(supportZones);
        if (IsValidSize(untouchedSupportsCount))
        {
            //
            // Draw ...
            // for (int i = 0; i < untouchedSupportsCount; i++)
            // {
            //     //
            //     XCSupportZone *item = supportZones[i];

            //     //
            //     XCSupportZoneObject *iObj;
            //     bool isCreated = mPOIDrawer.CreateSupportZone(
            //         item,
            //         iObj //
            //     );
            //     if (isCreated)
            //     {
            //         AddObjectIfNotExists(iObj);
            //     }
            // }
        }
    }

    //
    // Filter Untouched Resistances ...
    Clean(resistanceZones);
    int untouchedResistancesCount = 0;
    count = ArraySize(state.resistanceZones);
    if (IsValidSize(count))
    {
        //
        for (int i = 0; i < count; i++)
        {
            //
            XCResistanceZone *item = state.resistanceZones[i];

            //
            // Find Breakout Bar
            XOHCL iBar;
            bool isFilled = item.FillBar(iBar);
            if (!isFilled)
            {
                break;
            }

            //
            int iBarIndex = iBar.Index();
            int iBarUnTouchedCount = 0;
            for (int j = 0; j < iBarIndex; j++)
            {
                //
                XOHCL jBar;
                bool isInited = jBar.Init(
                    iBar.symbol,
                    iBar.period,
                    j //
                );
                if (!isInited)
                {
                    break;
                }

                //
                bool isUntouched =
                    jBar.high < item.Lower();
                if (isUntouched)
                {
                    iBarUnTouchedCount++;
                }
                else
                {
                    iBarUnTouchedCount--;
                }
            }

            //
            if (iBarUnTouchedCount > 0)
            {
                //
                Add(
                    item,
                    resistanceZones //
                );
            }
        }

        //
        untouchedResistancesCount = ArraySize(resistanceZones);
        if (IsValidSize(untouchedResistancesCount))
        {
            //
            // Draw ...
            // for (int i = 0; i < untouchedResistancesCount; i++)
            // {
            //     //
            //     XCResistanceZone *item = resistanceZones[i];

            //     //
            //     XCResistanceZoneObject *iObj;
            //     bool isCreated = mPOIDrawer.CreateResistanceZone(
            //         item,
            //         iObj //
            //     );
            //     if (isCreated)
            //     {
            //         AddObjectIfNotExists(iObj);
            //     }
            // }
        }
    }

    //
    bool hasBullishStructure =
        IsValidSize(untouchedSupportsCount) &&
        untouchedSupportsCount > untouchedResistancesCount;
    bool hasBearishStructure =
        IsValidSize(untouchedResistancesCount) &&
        untouchedResistancesCount > untouchedSupportsCount;

    //
    result = (hasBullishStructure &&
              !hasBearishStructure) ||
             (hasBearishStructure &&
              !hasBullishStructure);

    //
    if (result)
    {
        //
        dir =
            hasBullishStructure
                ? X_DIRECTION_BULLISH
                : X_DIRECTION_BEARISH;
    }

    //
    return result;
}

////////////////////////////////////////////////////////////////////////////

//
// Detect Order Blocks ...
// int obsCount = 0;

//
// Find Bullish Order Block ...
// XCOrderBlock *bullishOB = NULL;
// XCRejectionBar *bullishOBRejectionBar = NULL;
// obsCount = lastPivot.state.CountBullishOrderBlocks();
// if (IsValidSize(obsCount))
// {
//     //
//     for (int i = 0; i < obsCount; i++)
//     {
//         //
//         XCOrderBlock *iOB = lastPivot.state.bullishOrderBlocks[i];

//         //
//         XOHCL iBar;
//         bool hasBar = iOB.FillBar(iBar);
//         bool isPeriodSame = hasBar &&
//                             iBar.period == _period;

//         //
//         if (iOB.Upper() <= pivotMid &&
//             iOB.Lower() >= lastPivot.lower)
//         {
//             //
//             bullishOB = iOB;
//             break;
//         }
//     }
// }
// bool hasBullishOB = bullishOB != NULL;
// bool isBullishOBRejected = false;
// if (hasBullishOB)
// {
//     //
//     int bullishRejectedBarsCount = lastPivot.state.CountBullishRejectionBars();
//     if (IsValidSize(bullishRejectedBarsCount))
//     {
//         //
//         for (int i = 0; i < bullishRejectedBarsCount; i++)
//         {
//             //
//             XCRejectionBar *item = lastPivot.state.bullishRejectionBars[i];

//             //
//             XOHCL iBar;
//             bool isFilled = item.FillBar(iBar);
//             if (!isFilled)
//             {
//                 continue;
//             }

//             //
//             bool isRejected = iBar.low <= bullishOB.Lower() &&
//                               (iBar.GetDown() <= bullishOB.Upper() ||
//                                iBar.GetDown() > bullishOB.Upper());

//             //
//             isBullishOBRejected =
//                 bullishOBRejectionBar == NULL
//                     ? isRejected
//                     : isRejected &&
//                           item.From() > bullishOBRejectionBar.From();
//             if (isBullishOBRejected)
//             {
//                 bullishOBRejectionBar = item;
//             }
//         }
//     }
//     if (isBullishOBRejected)
//     {
//         //
//         bullishOBRejectionBar.To(cTime);
//         XCBullishRejectionBarObject *iObj;
//         bool isCreated = mPOIDrawer.CreateBullishRejectionBar(
//             bullishOBRejectionBar,
//             iObj //
//         );
//         if (isCreated)
//         {
//             AddObjectIfNotExists(iObj);
//         }
//     }

//     //
//     bullishOB.To(cTime);
//     XCBullishOrderBlockObject *iObj;
//     bool isCreated = mPOIDrawer.CreateBullishOrderBlock(
//         bullishOB,
//         iObj //
//     );
//     if (isCreated)
//     {
//         AddObjectIfNotExists(iObj);
//     }
// }

//
// Find Bearish Order Block ...
// XCOrderBlock *bearishOB = NULL;
// XCRejectionBar *bearishOBRejectionBar = NULL;
// obsCount = lastPivot.state.CountBearishOrderBlocks();
// if (IsValidSize(obsCount))
// {
//     //
//     for (int i = 0; i < obsCount; i++)
//     {
//         //
//         XCOrderBlock *iOB = lastPivot.state.bearishOrderBlocks[i];

//         //
//         XOHCL iBar;
//         bool hasBar = iOB.FillBar(iBar);
//         bool isPeriodSame = hasBar &&
//                             iBar.period == _period;

//         //
//         if (iOB.Lower() >= pivotMid &&
//             iOB.Upper() <= lastPivot.upper)
//         {
//             //
//             bearishOB = iOB;
//             break;
//         }
//     }
// }
// bool hasBearishOB = bearishOB != NULL;
// bool isBearishOBRejected = false;
// if (hasBearishOB)
// {
//     //
//     int bearishRejectedBarsCount = lastPivot.state.CountBearishRejectionBars();
//     if (IsValidSize(bearishRejectedBarsCount))
//     {
//         //
//         for (int i = 0; i < bearishRejectedBarsCount; i++)
//         {
//             //
//             XCRejectionBar *item = lastPivot.state.bearishRejectionBars[i];

//             //
//             XOHCL iBar;
//             bool isFilled = item.FillBar(iBar);
//             if (!isFilled)
//             {
//                 continue;
//             }

//             //
//             bool isRejected = iBar.high >= bearishOB.Upper() &&
//                               (iBar.GetUp() <= bearishOB.Lower() ||
//                                iBar.GetUp() > bearishOB.Lower());

//             //
//             isBearishOBRejected =
//                 bearishOBRejectionBar == NULL
//                     ? isRejected
//                     : isRejected &&
//                           item.From() > bearishOBRejectionBar.From();
//             if (isBearishOBRejected)
//             {
//                 bearishOBRejectionBar = item;
//             }
//         }
//     }
//     if (isBearishOBRejected)
//     {
//         //
//         bearishOBRejectionBar.To(cTime);
//         XCBearishRejectionBarObject *iObj;
//         bool isCreated = mPOIDrawer.CreateBearishRejectionBar(
//             bearishOBRejectionBar,
//             iObj //
//         );
//         if (isCreated)
//         {
//             AddObjectIfNotExists(iObj);
//         }
//     }

//     //
//     bearishOB.To(cTime);
//     XCBearishOrderBlockObject *iObj;
//     bool isCreated = mPOIDrawer.CreateBearishOrderBlock(
//         bearishOB,
//         iObj //
//     );
//     if (isCreated)
//     {
//         AddObjectIfNotExists(iObj);
//     }
// }

// //
// // Find an Order Block ...
// bool isBearishOrderBlockRejected = false;

/////////////////////////////////////////////////////////////////////////////

//
RedrawOrderFlow();

//
// Check Candlestick PullBacks ...
ENUM_X_DIRECTION pullBackDir;
bool hasPullBack = mBarAnalyser.HasPullBack(
    pullBackDir,
    cBar,
    3,   // Loopback ...
    true // Force Body ...
);
bool hasBullishPullback =
    hasPullBack &&
    pullBackDir == X_DIRECTION_BULLISH;
bool hasBearishPullback =
    hasPullBack &&
    pullBackDir == X_DIRECTION_BEARISH;

//
bool isInDiscount =
    bid < pivotMid &&
    bid > lastPivot.lower;

//
bool isInPremium =
    bid > pivotMid &&
              bid < lastPivot.upper;

//
// Check Order Flow Validation ...

//
// For Bullish Order Flow ...
// if Price Breakes Lower to Down, means Change of Charcter Happens ...
bool isCHOCHHappens =
    isBullishOrderFlow ? bid < lastPivot.lower - pip
                       : bid > lastPivot.upper + pip;

//
// For Bullish Order Flow ...
// if Price Breakes Upper to Up, means Breake of Structure Happens ...
bool isBOSHappens =
    isBullishOrderFlow ? bid > lastPivot.upper + pip
                       : bid < lastPivot.lower - pip;

//
if (isBOSHappens)
{
    //
    // RedrawOrderFlow();
    Print("");
}

//
if (isCHOCHHappens)
{
    //
    result = false;
    ResetOrderFlow();
    return result;
}

//
// Check 3MA and 3VWAP State ...

//
bool isVWAPBullishOrdered =
    //
    (
        //
        (conditions.x3vwapConditions.isBullishOrdered ||
         conditions.x3vwapConditions.isSwitchedToBullishOrdered)
        //
        ||
        //
        conditions.x3vwapConditions.fasts[cIndex] > conditions.x3vwapConditions.mids[cIndex]
        //
        ||
        //
        conditions.x3vwapConditions.mids[cIndex] > conditions.x3vwapConditions.slows[cIndex]
        //
        )
    //
    ;

//
bool isVWAPBearishOrdered =
    //
    (
        //
        (conditions.x3vwapConditions.isBearishOrdered ||
         conditions.x3vwapConditions.isSwitchedToBearishOrdered)
        //
        ||
        //
        conditions.x3vwapConditions.fasts[cIndex] < conditions.x3vwapConditions.mids[cIndex]
        //
        ||
        //
        conditions.x3vwapConditions.mids[cIndex] < conditions.x3vwapConditions.slows[cIndex]
        //
        )
    //
    ;

//
bool isVWapBullishState =
    //
    (
        //
        (conditions.x3vwapConditions.isBullishState ||
         conditions.x3vwapConditions.isSwitchedToBullishState)
        //
        ||
        //
        (x3vwapHelper.IsBullish(conditions.x3vwapConditions.fastStates[cIndex]) &&
         x3vwapHelper.IsBullish(conditions.x3vwapConditions.midStates[cIndex]))
        //
        ||
        //
        (x3vwapHelper.IsBullish(conditions.x3vwapConditions.midStates[cIndex]) &&
         x3vwapHelper.IsBullish(conditions.x3vwapConditions.slowStates[cIndex]))
        //
        )
    //
    ;

//
bool isVWapBearishState =
    //
    (
        //
        (conditions.x3vwapConditions.isBearishState ||
         conditions.x3vwapConditions.isSwitchedToBearishState)
        //
        ||
        //
        (x3vwapHelper.IsBearish(conditions.x3vwapConditions.fastStates[cIndex]) &&
         x3vwapHelper.IsBearish(conditions.x3vwapConditions.midStates[cIndex]))
        //
        ||
        //
        (x3vwapHelper.IsBearish(conditions.x3vwapConditions.midStates[cIndex]) &&
         x3vwapHelper.IsBearish(conditions.x3vwapConditions.slowStates[cIndex]))
        //
        )
    //
    ;

//
bool isVWapOverFastMA =
    //
    (
        //
        (conditions.x3vwapConditions.fasts[cIndex] > conditions.x3maConditions.fasts[cIndex] &&
         conditions.x3vwapConditions.mids[cIndex] > conditions.x3maConditions.fasts[cIndex])
        //
        ||
        //
        (conditions.x3vwapConditions.fasts[cIndex] > conditions.x3maConditions.fasts[cIndex] &&
         conditions.x3vwapConditions.mids[cIndex] > conditions.x3maConditions.fasts[cIndex] &&
         conditions.x3vwapConditions.slows[cIndex] > conditions.x3maConditions.fasts[cIndex])
        //
        )
    //
    ;

//
bool isVWapUnderFastMA =
    //
    (
        //
        (conditions.x3vwapConditions.fasts[cIndex] < conditions.x3maConditions.fasts[cIndex] &&
         conditions.x3vwapConditions.mids[cIndex] < conditions.x3maConditions.fasts[cIndex])
        //
        ||
        //
        (conditions.x3vwapConditions.fasts[cIndex] < conditions.x3maConditions.fasts[cIndex] &&
         conditions.x3vwapConditions.mids[cIndex] < conditions.x3maConditions.fasts[cIndex] &&
         conditions.x3vwapConditions.slows[cIndex] < conditions.x3maConditions.fasts[cIndex])
        //
        )
    //
    ;

//
bool is3Bullish =
    //
    (
        //
        (isVWAPBullishOrdered &&
         isVWapBullishState)
        //
        ||
        //
        (isVWAPBullishOrdered &&
         isVWapOverFastMA)
        //
        ||
        //
        (isVWapBullishState &&
         isVWapOverFastMA)
        //
        )
    //
    ;

//
bool is3Bearish =
    //
    (
        //
        (isVWAPBearishOrdered &&
         isVWapBearishState)
        //
        ||
        //
        (isVWAPBearishOrdered &&
         isVWapUnderFastMA)
        //
        ||
        //
        (isVWapBearishState &&
         isVWapUnderFastMA)
        //
        )
    //
    ;

//
// Check Parabolic Sars State ...

//
bool isSarBullish =
    //
    (conditions.xchsarConditions.isCBullish &&
     conditions.xchsarConditions.isSSwitchedBullish)
    //
    ||
    //
    (conditions.xchsarConditions.isSBullish &&
     conditions.xchsarConditions.isCSwitchedBullish)
    //
    ;
bool isSarBearish =
    //
    (conditions.xchsarConditions.isCBearish &&
     conditions.xchsarConditions.isSSwitchedBearish)
    //
    ||
    //
    (conditions.xchsarConditions.isSBearish &&
     conditions.xchsarConditions.isCSwitchedBearish)
    //
    ;

// //
// hasLong =
//     //
//     is3Bullish &&
//     // isInDiscount &&
//     isSarBullish // &&
//     // hasBullishPullback &&
//     // bullishLiquidityPercent > 30
//     //
//     ;

// //
// hasShort =
//     //
//     is3Bearish &&
//     // isInPremium &&
//     isSarBearish // &&
//     // hasBearishPullback &&
//     // bearishLiquidityPercent > 30
//     //
//     ;

//////////////////////

//
XPVPivot lastPivot;
result = GetLastItem(
    lastPivot,
    mOrderFlow //
);
if (!result)
{
    return result;
}
bool isBullishOrderFlow = IsBullish(mOrderFlowDir);
bool isBearishOrderFlow = IsBearish(mOrderFlowDir);
double pivotMid = lastPivot.CalculateMid();

//
// Calculate Liquidity Percent ...
double bullishLiquidityPercent = lastPivot
                                     .CalculateLiquidityPercent(X_DIRECTION_BULLISH);
double bearishLiquidityPercent = lastPivot
                                     .CalculateLiquidityPercent(X_DIRECTION_BEARISH);
double minLiquidityPercent = 35;
bool hasBullishLiquidity = bullishLiquidityPercent >= minLiquidityPercent;
bool hasBearishLiquidity = bearishLiquidityPercent >= minLiquidityPercent;
result = hasBullishLiquidity ||
         hasBearishLiquidity;
if (!result)
{
    return result;
}

/////////////////////////////////////////////////////////////////

// //
// // 1D Period ...
// // POI Detector ...
// m1DPOI = new XCPOIDetector(
//     symbol,
//     PERIOD_D1 //
// );

// //
// m1DPOI.MaxNumberOfRequiredPOIs(poiRequired);

// //
// m1DPOI.Init();

// //
// // 4H Period ...
// // POI Detector ...
// m4HPOI = new XCPOIDetector(
//     symbol,
//     PERIOD_H4 //
// );

// //
// m4HPOI.MaxNumberOfRequiredPOIs(poiRequired);

// //
// m4HPOI.Init();

// //
// // 2H Period ...
// // POI Detector ...
// m2HPOI = new XCPOIDetector(
//     symbol,
//     PERIOD_H2 //
// );

// //
// m2HPOI.MaxNumberOfRequiredPOIs(poiRequired);

// //
// m2HPOI.Init();

//
// 1H Period ...
// POI Detector ...
// m1HPOI = new XCPOIDetector(
//     symbol,
//     PERIOD_H1 //
// );

// //
// m1HPOI.MaxNumberOfRequiredPOIs(poiRequired);

// //
// m1HPOI.Init();

//
// 15M Period ...
// POI Detector ...
// m15MPOI = new XCPOIDetector(
//     symbol,
//     PERIOD_M15 //
// );

// //
// m15MPOI.MaxNumberOfRequiredPOIs(poiRequired);

// //
// m15MPOI.Init();

// //
// // 5M Period ...
// // POI Detector ...
// m5MPOI = new XCPOIDetector(
//     symbol,
//     PERIOD_M5 //
// );

// //
// m5MPOI.MaxNumberOfRequiredPOIs(poiRequired);

// //
// m5MPOI.Init();

// //
// // 1M Period ...
// // POI Detector ...
// m1MPOI = new XCPOIDetector(
//     symbol,
//     PERIOD_M1 //
// );

// //
// m1MPOI.MaxNumberOfRequiredPOIs(poiRequired);

// //
// m1MPOI.Init();

////////////////////////////////

// delete m1DPOI;
// delete m4HPOI;
// delete m2HPOI;
delete m1HPOI;
delete m15MPOI;
// delete m5MPOI;
// delete m1MPOI;

///////////////////////////////////

//
// Point Of Interests ...
XCPOIDetector *mTriggerPOIDetector;
XCPOIDetector *mAnalysePOIDetector;
XCPOIDetector *mVisionPOIDetector;

//
// XCPOIDetector *m1DPOI;
// XCPOIDetector *m4HPOI;
// XCPOIDetector *m2HPOI;
// XCPOIDetector *m1HPOI;
// XCPOIDetector *m15MPOI;
// XCPOIDetector *m5MPOI;
// XCPOIDetector *m1MPOI;

//
XPOIState mTriggerPOIState;
XPOIState mAnalysePOIState;
XPOIState mVisionPOIState;

// XPOIState _1DState;
// XPOIState _4HState;
// XPOIState _2HState;
// XPOIState _1HState;
// XPOIState _15MState;
// XPOIState _5MState;
// XPOIState _1MState;
// XPOIState _CombineState;

///////////////////////////////////////////

//
// Update POIs ...

//
ENUM_XPOI_EVENTS _events[];
mPOIDetector.Update(_events);

// //
// ENUM_XPOI_EVENTS _1DStates[];
// m1DPOI.Update(_1DStates);

// //
// ENUM_XPOI_EVENTS _4HStates[];
// m4HPOI.Update(_4HStates);

// //
// ENUM_XPOI_EVENTS _2HStates[];
// m2HPOI.Update(_2HStates);

//
ENUM_XPOI_EVENTS _1HStates[];
m1HPOI.Update(_1HStates);

// //
// ENUM_XPOI_EVENTS _15MStates[];
// m15MPOI.Update(_15MStates);

// //
// ENUM_XPOI_EVENTS _5MStates[];
// m5MPOI.Update(_5MStates);

// //
// ENUM_XPOI_EVENTS _1MStates[];
// m1MPOI.Update(_1MStates);

// //
// // Read all POI States ...
mPOIDetector.GetState(_state);
// m1DPOI.GetState(_1DState);
// m4HPOI.GetState(_4HState);
// m2HPOI.GetState(_2HState);
m1HPOI.GetState(_1HState);
// m15MPOI.GetState(_15MState);
// m5MPOI.GetState(_5MState);
// m1MPOI.GetState(_1MState);

//
// Combine States ...
// XPOIState _States[];
// AddRef(
//     _1DState,
//     _States //
// );
// AddRef(
//     _4HState,
//     _States //
// );
// AddRef(
//     _2HState,
//     _States //
// );
// AddRef(
//     _1HState,
//     _States //
// );
// AddRef(
//     _15MState,
//     _States //
// );
// AddRef(
//     _5MState,
//     _States //
// );
// AddRef(
//     _1MState,
//     _States //
// );
// CombineStates(
//     _CombineState,
//     _States //
// );

////////////////////////////////////////////////////////////////

//
// Works by WVAP and PSar ...
bool long1 =
    //
    conditions.x3vwapConditions.isBullishState &&
    conditions.x3vwapConditions.isBullishOrdered &&
    // conditions.xpvConditions.vales[cIndex] == conditions.xchsarConditions.cSars[cIndex] &&
    conditions.xchsarConditions.cSars[cIndex] < conditions.x3vwapConditions.slows[cIndex]
    //
    ;
if (long1)
{
    //
    CustomStateDrawing(_1HState);
    selectedSL = conditions.xpvConditions.vales[cIndex];
}

//
// Works by WVAP and PSar ...
bool short1 =
    //
    conditions.x3vwapConditions.isBearishState &&
    conditions.x3vwapConditions.isBearishOrdered &&
    // conditions.xpvConditions.peaks[cIndex] == conditions.xchsarConditions.cSars[cIndex] &&
    conditions.xchsarConditions.cSars[cIndex] > conditions.x3vwapConditions.slows[cIndex]
    //
    ;
if (short1)
{
    //
    CustomStateDrawing(_1HState);
    selectedSL = conditions.xpvConditions.peaks[cIndex];
}

/////////////////////////////////////////////////////////////////////////////////////////////////////

// mOrderFlow[pivotIDX].state.ticksZone =
//_15MState.ticksZone;

// //
// // D1 ...
// XPOIState d1;
// if (_1DState.HasChild())
// {
//     //
//     DetectPivotPOIs(
//         mOrderFlow[pivotIDX],
//         _1DState,
//         d1,
//         lookupSwingHighs,
//         lookupSwingLows,
//         lookupSupportZones,
//         lookupResistanceZones,
//         lookupSupplyZones,
//         lookupDemandZones,
//         lookupBullishOrderBlocks,
//         lookupBearishOrderBlocks,
//         lookupBullishFairValueGaps,
//         lookupBearishFairValueGaps,
//         lookupBullishRejectionBars,
//         lookupBearishRejectionBars,
//         lookupBullishMomentumBars,
//         lookupBearishMomentumBars //
//     );

//     //
//     if (d1.HasChild())
//     {
//         d1.Fill(mOrderFlow[pivotIDX].state);
//     }
// }

// //
// // H4 ...
// XPOIState h4;
// if (_4HState.HasChild())
// {
//     //
//     DetectPivotPOIs(
//         mOrderFlow[pivotIDX],
//         _4HState,
//         h4,
//         lookupSwingHighs,
//         lookupSwingLows,
//         lookupSupportZones,
//         lookupResistanceZones,
//         lookupSupplyZones,
//         lookupDemandZones,
//         lookupBullishOrderBlocks,
//         lookupBearishOrderBlocks,
//         lookupBullishFairValueGaps,
//         lookupBearishFairValueGaps,
//         lookupBullishRejectionBars,
//         lookupBearishRejectionBars,
//         lookupBullishMomentumBars,
//         lookupBearishMomentumBars //
//     );

//     //
//     if (h4.HasChild())
//     {
//         h4.Fill(mOrderFlow[pivotIDX].state);
//     }
// }

//
// H2 ...
// XPOIState h2;
// if (_2HState.HasChild())
// {
//     //
//     DetectPivotPOIs(
//         mOrderFlow[pivotIDX],
//         _2HState,
//         h2,
//         lookupSwingHighs,
//         lookupSwingLows,
//         lookupSupportZones,
//         lookupResistanceZones,
//         lookupSupplyZones,
//         lookupDemandZones,
//         lookupBullishOrderBlocks,
//         lookupBearishOrderBlocks,
//         lookupBullishFairValueGaps,
//         lookupBearishFairValueGaps,
//         lookupBullishRejectionBars,
//         lookupBearishRejectionBars,
//         lookupBullishMomentumBars,
//         lookupBearishMomentumBars //
//     );

//     //
//     if (h2.HasChild())
//     {
//         h2.Fill(mOrderFlow[pivotIDX].state);
//     }
// }

//
// H1 ...
XPOIState h1;
if (_1HState.HasChild())
{
    //
    DetectPivotPOIs(
        mOrderFlow[pivotIDX],
        _1HState,
        h1,
        lookupSwingHighs,
        lookupSwingLows,
        lookupSupportZones,
        lookupResistanceZones,
        lookupSupplyZones,
        lookupDemandZones,
        lookupBullishOrderBlocks,
        lookupBearishOrderBlocks,
        lookupBullishFairValueGaps,
        lookupBearishFairValueGaps,
        lookupBullishRejectionBars,
        lookupBearishRejectionBars,
        lookupBullishMomentumBars,
        lookupBearishMomentumBars //
    );

    //
    if (h1.HasChild())
    {
        h1.Fill(mOrderFlow[pivotIDX].state);
    }
}

//
// M15 ...
// XPOIState m15;
// if (_15MState.HasChild())
// {
//     //
//     DetectPivotPOIs(
//         mOrderFlow[pivotIDX],
//         _15MState,
//         m15,
//         lookupSwingHighs,
//         lookupSwingLows,
//         lookupSupportZones,
//         lookupResistanceZones,
//         lookupSupplyZones,
//         lookupDemandZones,
//         lookupBullishOrderBlocks,
//         lookupBearishOrderBlocks,
//         lookupBullishFairValueGaps,
//         lookupBearishFairValueGaps,
//         lookupBullishRejectionBars,
//         lookupBearishRejectionBars,
//         lookupBullishMomentumBars,
//         lookupBearishMomentumBars //
//     );

//     //
//     if (m15.HasChild())
//     {
//         m15.Fill(mOrderFlow[pivotIDX].state);
//     }
// }

//
// M5 ...
// XPOIState m5;
// if (_5MState.HasChild())
// {
//     //
//     DetectPivotPOIs(
//         mOrderFlow[pivotIDX],
//         _5MState,
//         m5,
//         lookupSwingHighs,
//         lookupSwingLows,
//         lookupSupportZones,
//         lookupResistanceZones,
//         lookupSupplyZones,
//         lookupDemandZones,
//         lookupBullishOrderBlocks,
//         lookupBearishOrderBlocks,
//         lookupBullishFairValueGaps,
//         lookupBearishFairValueGaps,
//         lookupBullishRejectionBars,
//         lookupBearishRejectionBars,
//         lookupBullishMomentumBars,
//         lookupBearishMomentumBars //
//     );

//     //
//     if (m5.HasChild())
//     {
//         m5.Fill(mOrderFlow[pivotIDX].state);
//     }
// }

//
// M1 ...
// XPOIState m1;
// if (_1MState.HasChild())
// {
//     //
//     DetectPivotPOIs(
//         mOrderFlow[pivotIDX],
//         _1MState,
//         m1,
//         lookupSwingHighs,
//         lookupSwingLows,
//         lookupSupportZones,
//         lookupResistanceZones,
//         lookupSupplyZones,
//         lookupDemandZones,
//         lookupBullishOrderBlocks,
//         lookupBearishOrderBlocks,
//         lookupBullishFairValueGaps,
//         lookupBearishFairValueGaps,
//         lookupBullishRejectionBars,
//         lookupBearishRejectionBars,
//         lookupBullishMomentumBars,
//         lookupBearishMomentumBars //
//     );

//     //
//     if (m1.HasChild())
//     {
//         m1.Fill(mOrderFlow[pivotIDX].state);
//     }
// }

//////////////////////////////////

/**
 * Detect SL Candidates based on Strategy and Conditions ...
 *
 * @param  result: Double array reference ...
 * @param  entry: Double, Position Entry Price ...
 * @param  conditions: X121SMCStrategyConditions instance, Provides Configurations ...
 * @param  type: ENUM_X_POSITION_TYPES member, Specified Position Type ...
 */
void DetectSLCandidates(
    double &result[],
    double entry,
    X121SMCStrategyConditions &conditions,
    ENUM_X_POSITION_TYPES type //
    ) override
{
    //
    Clean(result);

    //
    int cIndex = 1;

    //
    if (entry <= 0 ||
        !conditions.IsValid() ||
        type == X_POSITION_TYPE_ALL ||
        type == X_POSITION_TYPE_NONE)
    {
        return;
    }

    //
    Add(
        conditions.x3vwapConditions.fasts[cIndex],
        result //
    );

    //
    Add(
        conditions.x3vwapConditions.mids[cIndex],
        result //
    );

    //
    Add(
        conditions.x3vwapConditions.slows[cIndex],
        result //
    );

    //
    Add(
        conditions.x3maConditions.fasts[cIndex],
        result //
    );

    //
    Add(
        conditions.xpvConditions.vales[cIndex],
        result //
    );

    //
    Add(
        conditions.xpvConditions.peaks[cIndex],
        result //
    );

    //
}

////////////////////////////////////////

bool canContinue = true;
while (canContinue)
{
    //
    XOHCL iBar;
    bool isBarInited = iBar.Init(
        mBar.symbol,
        mBar.period,
        barIndex //
    );
    if (!isBarInited)
    {
        break;
    }

    //
    if (bullOB == NULL)
    {
        //
        XCOrderBlock *ob;
        bool isBullOB = cycleHelper
                            .mPOIDetector
                            .DetectBullishOrderBlock(
                                mBar,
                                ob //
                            );
        if (isBullOB)
        {
            //
            bool isPricePassed = bar.low > ob.Upper();
            if (isPricePassed)
            {
                //
                if (mBullOB == NULL)
                {
                    //
                    mBullOB = ob;
                }
                else
                {
                    //
                    bool isRefined = mBullOB.Upper() < ob.Upper();
                    if (isRefined)
                    {
                        mBullOB = ob;
                    }
                }
            }
        }
    }

    //
    if (bearOB == NULL)
    {
        //
        XCOrderBlock *ob;
        bool isBearOB = cycleHelper
                            .mPOIDetector
                            .DetectBearishOrderBlock(
                                mBar,
                                ob //
                            );
        if (isBearOB)
        {
            //
            bool isPricePassed = bar.high < ob.Lower();
            if (isPricePassed)
            {
                //
                if (mBearOB == NULL)
                {
                    //
                    mBearOB = ob;
                }
                else
                {
                    //
                    bool isRefined = mBearOB.Lower() > ob.Lower();
                    if (isRefined)
                    {
                        mBearOB = ob;
                    }
                }
            }
        }
    }

    //
    canContinue =
        (bullOB == NULL && mBullOB == NULL) ||
        (bearOB == NULL && mBearOB == NULL);
    if (canContinue)
    {
        barIndex++;
    }
}

//
if (mBullOB != NULL)
{
    bullOB = mBullOB;
}

//
if (mBearOB != NULL)
{
    bearOB = mBearOB;
}

////////////////////////////////////////////////////////////

//
// Detect an Order Block in Vision ...
if (conditions.visionBullOB == NULL ||
    conditions.visionBearOB == NULL)
{
    //
    result = DetectOrderBlocks(
        NULL,
        NULL,
        conditions.visionBullOB,
        conditions.visionBearOB,
        cBar,
        mVisionState //
    );
    if (!result)
    {
        //
        conditions.Clean();
        return result;
    }

    //
    XCBullishOrderBlockObject *iBullOBObj;
    conditions.visionBullOB.To(cTime);
    result = mPOIDrawer.CreateBullishOrderBlock(
        conditions.visionBullOB,
        iBullOBObj //
    );
    if (result)
    {
        AddObjectIfNotExists(iBullOBObj);
    }

    //
    XCBearishOrderBlockObject *iBearOBObj;
    conditions.visionBearOB.To(cTime);
    result = mPOIDrawer.CreateBearishOrderBlock(
        conditions.visionBearOB,
        iBearOBObj //
    );
    if (result)
    {
        AddObjectIfNotExists(iBearOBObj);
    }
}

//
// Consolidation Order Blocks ...
if (conditions.consolidationBullOB == NULL ||
    conditions.consolidationBearOB == NULL)
{
    //
    result = DetectOrderBlocks(
        conditions.visionBullOB,
        conditions.visionBearOB,
        conditions.consolidationBullOB,
        conditions.consolidationBearOB,
        cBar,
        mConsolidationState //
    );
    if (!result)
    {
        //
        conditions.Clean();
        return result;
    }

    //
    XCBullishOrderBlockObject *iBullOBObj;
    conditions.consolidationBullOB.To(cTime);
    result = mPOIDrawer.CreateBullishOrderBlock(
        conditions.consolidationBullOB,
        iBullOBObj //
    );
    if (result)
    {
        AddObjectIfNotExists(iBullOBObj);
    }

    //
    XCBearishOrderBlockObject *iBearOBObj;
    conditions.consolidationBearOB.To(cTime);
    result = mPOIDrawer.CreateBearishOrderBlock(
        conditions.consolidationBearOB,
        iBearOBObj //
    );
    if (result)
    {
        AddObjectIfNotExists(iBearOBObj);
    }
}

//
msg = "OrderBlocks Detected ...";
Alert(msg);

//
// Detect Trigger Order Flow ...
if (!HasValidOrderFlow())
{
    //
    int samePivots = 40;
    int requiredPivots = 10;

    //
    bool useVisionState = false;
    bool useConsolidationState = false;
    bool useVerificationState = false;
    bool useAnalyseState = false;
    bool useDecisionState = true;
    bool useTriggerState = false;

    //
    DetectOrderFlow(
        cIndex,
        samePivots,
        requiredPivots,
        mTriggerCycleHelper,
        mOrderFlow,
        mOrderFlowDir,
        //
        // Filling Pivot State ...
        useVisionState,        // Use Vision State ...
        useConsolidationState, // Use Consolidation State ...
        useVerificationState,  // Use Verification State ...
        useAnalyseState,       // Use Analyse State ...
        useDecisionState,      // Use Decision State ...
        useTriggerState        // Use Trigger State ...
    );

    //
    result = HasValidOrderFlow();
    if (!result)
    {
        //
        conditions.Clean();
        return result;
    }

    //
    bool ignoreSwingHighs = true;
    bool ignoreSwingLows = true;
    bool ignoreSupportZones = true;
    bool ignoreResistanceZones = true;
    bool ignoreSupplyZones = true;
    bool ignoreDemandZones = true;
    bool ignoreBullishOrderBlocks = true;
    bool ignoreBearishOrderBlocks = true;
    bool ignoreBullishFairValueGaps = true;
    bool ignoreBearishFairValueGaps = true;
    bool ignoreBullishRejectionBars = true;
    bool ignoreBearishRejectionBars = true;
    bool ignoreBullishMomentumBars = true;
    bool ignoreBearishMomentumBars = true;

    //
    RedrawOrderFlow(
        false, // Force Clean ...
        false, // Same Period ...
        true,  // Order Flow ...
        true,  // Order Flow State ...
        false, // Only Last Order Flow ...
        true,  // Only Last Order Flow State ...
        //
        mOrderFlowDir, // Direction Force ...
        ignoreSwingHighs,
        ignoreSwingLows,
        ignoreSupportZones,
        ignoreResistanceZones,
        ignoreSupplyZones,
        ignoreDemandZones,
        ignoreBullishOrderBlocks,
        ignoreBearishOrderBlocks,
        ignoreBullishFairValueGaps,
        ignoreBearishFairValueGaps,
        ignoreBullishRejectionBars,
        ignoreBearishRejectionBars,
        ignoreBullishMomentumBars,
        ignoreBearishMomentumBars //
    );
}

//
msg = "Found OrderFlow : " + (IsBullish(mOrderFlowDir) ? "Bullish" : "Berish");
Alert(msg);

//
// Check Market Conditions for
// Specified Structure ...
// ENUM_X_DIRECTION marketStructureDir = X_DIRECTION_NONE;
// result = conditions.HasDirection(
//     marketStructureDir,
//     cBar //
// );
// if (!result)
// {
//     //
//     conditions.Clean();
//     return result;
// }
// msg = "Found Market Strucutre : " + (IsBullish(marketStructureDir) ? "Bullish" : "Berish");
// Alert(msg);

//
// conditions.marketStructureDir = marketStructureDir;

// //
// XPVPivot lastPivot;
// result = GetLastItem(
//     lastPivot,
//     mOrderFlow //
// );
// if (!result)
// {
//     //
//     conditions.Clean();
//     return result;
// }

//
// Detect Last FVG ...
// XOHCL breakerBar;
// result = DetectLastBreakerBar(
//     cBar,
//     breakerBar,
//     lastPivot,
//     marketStructureDir //
// );
// if (!result)
// {
//     //
//     conditions.Clean();
//     return result;
// }
// msg = "Found Breaker Bar: " + breakerBar.GetTag();
// Alert(msg);

// //
// // Detect Nearest Momentum or Rejection Bar ...
// XOHCL decisionBar;
// result = mDecisionCycleHelper.DetectNearestDecisionBar(
//     decisionBar,
//     marketStructureDir,
//     cBar //
// );
// if (!result)
// {
//     return result;
// }
// msg = "Found Decision Bar: " + decisionBar.GetTag();
// Alert(msg);

// //
// // Detect Nearest Sar Change ...
// XOHCL sarChangeBar;
// result = mTriggerCycleHelper.DetectNearestCSARChange(
//     sarChangeBar,
//     cBar //
// );
// if (!result)
// {
//     //
//     conditions.Clean();
//     return result;
// }
// msg = "Found Sar Change Bar: " + sarChangeBar.GetTag();
// Alert(msg);

// //
// // Now we Hvae to Check Other Conditions ...
// result =
//     // breakerBar.time > sarChangeBar.time &&
//     // decisionBar.time > breakerBar.time;
//     decisionBar.time > sarChangeBar.time;
// if (!result)
// {
//     //
//     conditions.Clean();
//     return result;
// }

// //
// // Now we Have Check Direction Related Conditions ...
// if (IsBullish(marketStructureDir))
// {
//     //
//     result =
//         // bid > decisionBar.high &&
//         // bid > breakerBar.high &&
//         bid > sarChangeBar.high &&
//         bid > conditions.triggerConditions.xchsarConditions.cSars[0];
// }
// else
// {
//     //
//     result =
//         // bid < decisionBar.low &&
//         // bid < breakerBar.low &&
//         bid < sarChangeBar.high &&
//         bid < conditions.triggerConditions.xchsarConditions.cSars[0];
// }
// if (!result)
// {
//     //
//     conditions.Clean();
//     return result;
// }

// //
// conditions.provider = "X121SMC";
// if (IsBullish(marketStructureDir))
// {
//     //
//     // conditions.sl = decisionBar.low;
//     // conditions.sl = breakerBar.low;
//     conditions.sl = conditions.triggerConditions.xchsarConditions.cSars[0];
// }
// else
// {
//     //
//     // conditions.sl = decisionBar.high;
//     // conditions.sl = breakerBar.high;
//     conditions.sl = conditions.triggerConditions.xchsarConditions.cSars[0];
// }

//////////////////////////////////////////////////////////////////

//
bool isSamePeaks =
    //
    conditions.triggerConditions.x121Conditions.peaksBuffer[0] == conditions.decisionConditions.x121Conditions.peaksBuffer[0] &&
    conditions.decisionConditions.x121Conditions.peaksBuffer[0] == conditions.analyseConditions.x121Conditions.peaksBuffer[0]
    //  &&
    // conditions.analyseConditions.x121Conditions.peaksBuffer[0] == conditions.verificationConditions.x121Conditions.peaksBuffer[0] &&
    // conditions.verificationConditions.x121Conditions.peaksBuffer[0] == conditions.consolidationConditions.x121Conditions.peaksBuffer[0] &&
    // conditions.consolidationConditions.x121Conditions.peaksBuffer[0] == conditions.visionConditions.x121Conditions.peaksBuffer[0]
    //
    ;
if (isSamePeaks)
{
    Print("isSamePeaks");
}

//
bool isSameVales =
    //
    conditions.triggerConditions.x121Conditions.valesBuffer[0] == conditions.decisionConditions.x121Conditions.valesBuffer[0] &&
    conditions.decisionConditions.x121Conditions.valesBuffer[0] == conditions.analyseConditions.x121Conditions.valesBuffer[0]
    // &&
    // conditions.analyseConditions.x121Conditions.valesBuffer[0] == conditions.verificationConditions.x121Conditions.valesBuffer[0] &&
    // conditions.verificationConditions.x121Conditions.valesBuffer[0] == conditions.consolidationConditions.x121Conditions.valesBuffer[0] &&
    // conditions.consolidationConditions.x121Conditions.valesBuffer[0] == conditions.visionConditions.x121Conditions.valesBuffer[0]
    //
    ;
if (isSameVales)
{
    Print("isSameVales");
}

//////////////////////////////////////////////////////////////////////

//
// Detect Valid Supply and Demand Zones ...
XCSupplyZone *supplyZone;
XCDemandZone *demandZone;
result = mTriggerCycleHelper
             .DetectValisSupplyZone(
                 cBar,
                 supplyZone,
                 demandZone //
             );
if (!result)
{
    //
    conditions.Clean();
    return result;
}

//
supplyZone.To(cTime);
XCSupplyZoneObject *iSupplyZoneObj;
result = mPOIDrawer.CreateSupplyZone(
    supplyZone,
    iSupplyZoneObj //
);
if (!result)
{
    //
    conditions.Clean();
    return result;
}

//
demandZone.To(cTime);
XCDemandZoneObject *iDemandZoneObj;
result = mPOIDrawer.CreateDemandZone(
    demandZone,
    iDemandZoneObj //
);
if (!result)
{
    //
    conditions.Clean();
    return result;
}

//
Print("Supply and Demand Zone Created ...");

//////////////////////////////////////////////////////////////////////

//
int consolidationsCount = mTriggerCycleHelper.CountConsolidationZones();
result = IsValidSize(consolidationsCount);
if (!result)
{
    //
    conditions.Clean();
    return result;
}
XConsolidationZone consolidations[];
mTriggerCycleHelper.FillConsolidationZones(consolidations);

//
// Detect Bid inside Of Zones ...
bool hasSupply = false;
bool hasDemand = false;
XCSupplyZone *supplyZone;
XCDemandZone *demandZone;
bool isBidInsideZone = false;
XConsolidationZone bidContainsConsolidationZone;
for (int i = consolidationsCount - 1; i >= 0; i--)
{
    //
    XConsolidationZone iZone = consolidations[i];

    //
    // Check  Supply or Demand Zone ...
    hasSupply = iZone.HasSupplyZone(supplyZone);
    hasDemand = iZone.HasDemandZone(demandZone);

    //
    result = hasSupply ||
             hasDemand;
    if (!result)
    {
        continue;
    }

    //
    // Check Bid inside Zone ...
    if (hasSupply)
    {
        //
        result = bid < supplyZone.Upper() &&
                 bid > supplyZone.Lower();
    }
    else
    {
        //
        result = bid < demandZone.Upper() &&
                 bid > demandZone.Lower();
    }

    //
    if (result)
    {
        break;
    }
}
if (!result)
{
    //
    conditions.Clean();
    return result;
}

//
if (hasSupply)
{
    //
    supplyZone.To(cTime);
    XCSupplyZoneObject *iSupplyZoneObj;
    result = mPOIDrawer.CreateSupplyZone(
        supplyZone,
        iSupplyZoneObj //
    );
    if (!result)
    {
        //
        conditions.Clean();
        return result;
    }
}

//
if (hasDemand)
{
    //
    demandZone.To(cTime);
    XCDemandZoneObject *iDemandZoneObj;
    result = mPOIDrawer.CreateDemandZone(
        demandZone,
        iDemandZoneObj //
    );
    if (!result)
    {
        //
        conditions.Clean();
        return result;
    }
}

//
Print("BID Inside Zone ...");

//////////////////////////////////////////////////////////////////////////

bool DetectCandlestic(
    ENUM_X_DIRECTION &dir,
    X121SMCStrategyConditions &conditions //
)
{
    //
    bool result = false;

    //
    dir = X_DIRECTION_NONE;

    //
    string symbol = GetSymbol();
    ENUM_TIMEFRAMES period = GetPeriod();

    //
    int cIndex = 1;
    int pIndex = cIndex + 1;

    //
    XOHCL cBar;
    result = cBar.Init(
        symbol,
        period,
        cIndex //
    );
    if (!result)
    {
        return result;
    }

    //
    XOHCL pBar;
    result = pBar.Init(
        symbol,
        period,
        pIndex //
    );
    if (!result)
    {
        return result;
    }

    //
    // Momentum Bars ...
    XCMomentumBar *cBullishMomentum = NULL;
    XCMomentumBar *cBearishMomentum = NULL;
    XCMomentumBar *pBullishMomentum = NULL;
    XCMomentumBar *pBearishMomentum = NULL;
    int bullishMomentumBarsCount = conditions.triggerConditions.state
                                       .CountBullishMomentumBars();
    int bearishMomentumBarsCount = conditions.triggerConditions.state
                                       .CountBearishMomentumBars();
    if (IsValidSize(bullishMomentumBarsCount))
    {
        //
        cBullishMomentum = conditions.triggerConditions.state.bullishMomentumBars[bullishMomentumBarsCount - 1];
        pBullishMomentum = conditions.triggerConditions.state.bullishMomentumBars[bullishMomentumBarsCount - 2];
    }
    if (IsValidSize(bearishMomentumBarsCount))
    {
        //
        cBearishMomentum = conditions.triggerConditions.state.bearishMomentumBars[bearishMomentumBarsCount - 1];
        pBearishMomentum = conditions.triggerConditions.state.bearishMomentumBars[bearishMomentumBarsCount - 2];
    }

    //
    // Rejection Bars ...
    XCRejectionBar *cBullishRejection = NULL;
    XCRejectionBar *cBearishRejection = NULL;
    XCRejectionBar *pBullishRejection = NULL;
    XCRejectionBar *pBearishRejection = NULL;
    int bullishRejectionBarsCount = conditions.triggerConditions.state
                                        .CountBullishRejectionBars();
    int bearishRejectionBarsCount = conditions.triggerConditions.state
                                        .CountBearishRejectionBars();
    if (IsValidSize(bullishRejectionBarsCount))
    {
        //
        cBullishRejection = conditions.triggerConditions.state.bullishRejectionBars[bullishRejectionBarsCount - 1];
        pBullishRejection = conditions.triggerConditions.state.bullishRejectionBars[bullishRejectionBarsCount - 2];
    }
    if (IsValidSize(bearishRejectionBarsCount))
    {
        //
        cBearishRejection = conditions.triggerConditions.state.bearishRejectionBars[bearishRejectionBarsCount - 1];
        pBearishRejection = conditions.triggerConditions.state.bearishRejectionBars[bearishRejectionBarsCount - 2];
    }

    //
    bool isBullish =
        //
        // pBar is Rejection and cBar is Momentum ...
        // pBar is Momentum and cBar is Rejection ...
        // cBar is Momentum and Rejection ...
        //
        pBullishMomentum != NULL &&
        pBullishMomentum.IsValid() &&
        //
        cBullishMomentum != NULL &&
        cBullishMomentum.IsValid() &&
        //
        //
        pBullishRejection != NULL &&
        pBullishRejection.IsValid() &&
        //
        cBullishRejection != NULL &&
        cBullishRejection.IsValid() &&
        //
        (
            //
            (pBar.time == pBullishRejection.BarTime() &&
             cBar.time == cBullishMomentum.BarTime())
            //
            ||
            //
            (pBar.time == pBullishMomentum.BarTime() &&
             cBar.time == cBullishRejection.BarTime())
            //
            ||
            //
            (cBar.time == cBullishMomentum.BarTime() &&
             cBar.time == cBullishRejection.BarTime())
            //
            )
        //
        ;

    //
    bool isBearish =
        //
        // pBar is Rejection and cBar is Momentum ...
        // pBar is Momentum and cBar is Rejection ...
        // cBar is Momentum and Rejection ...
        //
        pBearishMomentum != NULL &&
        pBearishMomentum.IsValid() &&
        //
        cBearishMomentum != NULL &&
        cBearishMomentum.IsValid() &&
        //
        //
        pBearishRejection != NULL &&
        pBearishRejection.IsValid() &&
        //
        cBearishRejection != NULL &&
        cBearishRejection.IsValid() &&
        //
        (
            //
            (pBar.time == pBearishRejection.BarTime() &&
             cBar.time == cBearishMomentum.BarTime())
            //
            ||
            //
            (pBar.time == pBearishMomentum.BarTime() &&
             cBar.time == cBearishRejection.BarTime())
            //
            ||
            //
            (cBar.time == cBearishMomentum.BarTime() &&
             cBar.time == cBearishRejection.BarTime())
            //
            )
        //
        ;

    //
    result = isBullish ||
             isBearish;
    if (!result)
    {
        return result;
    }

    //
    dir =
        isBullish
            ? X_DIRECTION_BULLISH
            : X_DIRECTION_BEARISH;

    //
    return result;
}

/////////////////////////////////////////////////////////////////////////////////////

/**
 * Detect Nearest Supply/Demand Zones ...
 *
 * @param  bar: XOHCL instance, Start Bar ...
 *
 * @return ( bool )
 */
bool DetectValisSupplyZone(
    XOHCL &bar,
    XCSupplyZone *&supplyZone,
    XCDemandZone *&demandZone //
)
{
    //
    bool result = false;

    //
    result = bar.IsValid();
    if (!result)
    {
        return result;
    }

    //
    int index = bar.Index();

    //
    double bid = GetBid(bar.symbol);
    double ask = GetAsk(bar.symbol);

    //
    // Retrieve X121 Cnditions ...
    int conditionsLoopback = 10;
    X121Conditions x121Conditions;
    result = mX121Helper.GetConditions(
        x121Conditions,
        index,
        conditionsLoopback //
    );
    if (!result)
    {
        return result;
    }
    int validPeaksCount = ArraySize(x121Conditions.validPeaksBuffer);
    int validValesCount = ArraySize(x121Conditions.validValesBuffer);

    //
    XPOIState state;
    ENUM_XPOI_EVENTS events[];
    mPOIDetector.Update(events);
    mPOIDetector.GetState(state);
    result = state.IsValid() &&
             state.HasChild();
    if (!result)
    {
        return result;
    }

    //
    // Supply Zones ...
    XCSupplyZone *supplies[];
    int suppliesCount = state.CountSupplyZones();

    //
    // Select Bar Validated Supply Zones ...
    if (IsValidSize(suppliesCount))
    {
        //
        for (int i = 0; i < suppliesCount; i++)
        {
            //
            XCSupplyZone *iZone = state.supplyZones[i];

            //
            // Check Zone is Valid For Bar ...
            bool isValid = bar.high < iZone.Lower() &&
                           ask < iZone.Lower() &&
                           bid < iZone.Lower();
            if (isValid)
            {
                //
                Add(
                    iZone,
                    supplies //
                );
            }
        }
    }
    suppliesCount = ArraySize(supplies);

    //
    // Select Valid Peaks Filtered Supplies ...
    if (IsValidSize(suppliesCount))
    {
        //
        // Check Valid Peaks ...
        XCSupplyZone *tmp[];
        if (IsValidSize(validPeaksCount))
        {
            //
            for (int i = 0; i < suppliesCount; i++)
            {
                //
                XCSupplyZone *iZone = supplies[i];

                //
                for (int j = 0; j < validPeaksCount; j++)
                {
                    //
                    double value = x121Conditions.validPeaksBuffer[j];

                    //
                    // Check Valid Peaks in Zone ...
                    bool isZoneContainsValidValue =
                        value >= iZone.Lower() &&
                        value <= iZone.Upper();
                    if (isZoneContainsValidValue)
                    {
                        //
                        Add(
                            iZone,
                            tmp //
                        );
                    }
                }
            }
        }

        //
        Clean(supplies);
        Copy(
            tmp,
            supplies //
        );
    }
    suppliesCount = ArraySize(supplies);

    //
    // Select Nearest Supply Zone ...
    if (IsValidSize(suppliesCount))
    {
        //
        // Check Nearest Supplies ...
        for (int i = 0; i < suppliesCount; i++)
        {
            //
            XCSupplyZone *iZone = supplies[i];
            if (supplyZone == NULL)
            {
                supplyZone = iZone;
            }
            else
            {
                //
                bool canChange =
                    iZone.Lower() < supplyZone.Lower();
                if (canChange)
                {
                    supplyZone = iZone;
                }
            }
        }
    }

    //
    // Demand Zones ...
    XCDemandZone *demands[];
    int demandsCount = state.CountDemandZones();

    //
    // Select Bar Validated Demand Zones ...
    if (IsValidSize(demandsCount))
    {
        //
        for (int i = 0; i < demandsCount; i++)
        {
            //
            XCDemandZone *iZone = state.demandZones[i];

            //
            // Check Zone is Valid For Bar ...
            bool isValid = bar.low > iZone.Upper() &&
                           ask > iZone.Upper() &&
                           bid > iZone.Upper();
            if (isValid)
            {
                //
                Add(
                    iZone,
                    demands //
                );
            }
        }
    }
    demandsCount = ArraySize(demands);

    //
    // Select Valid Vales Filtered Demands ...
    if (IsValidSize(demandsCount))
    {
        //
        // Check Valid Vales ...
        XCDemandZone *tmp[];
        if (IsValidSize(validValesCount))
        {
            //
            for (int i = 0; i < demandsCount; i++)
            {
                //
                XCDemandZone *iZone = demands[i];

                //
                for (int j = 0; j < validValesCount; j++)
                {
                    //
                    double value = x121Conditions.validValesBuffer[j];

                    //
                    // Check Valid Peaks in Zone ...
                    bool isZoneContainsValidValue =
                        value >= iZone.Lower() &&
                        value <= iZone.Upper();
                    if (isZoneContainsValidValue)
                    {
                        //
                        Add(
                            iZone,
                            tmp //
                        );
                    }
                }
            }
        }

        //
        Clean(demands);
        Copy(
            tmp,
            demands //
        );
    }
    demandsCount = ArraySize(demands);

    //
    // Select Nearest Demand Zone ...
    if (IsValidSize(demandsCount))
    {
        //
        // Check Nearest Demands ...
        for (int i = 0; i < demandsCount; i++)
        {
            //
            XCDemandZone *iZone = demands[i];
            if (demandZone == NULL)
            {
                demandZone = iZone;
            }
            else
            {
                //
                bool canChange =
                    iZone.Upper() > demandZone.Upper();
                if (canChange)
                {
                    demandZone = iZone;
                }
            }
        }
    }

    //
    // Validate Founded Zones ...
    result = (supplyZone != NULL &&
              supplyZone.IsValid()) &&
             (demandZone != NULL &&
              demandZone.IsValid());

    //
    return result;
}

////////////////////////////////////////////////////////////////////

            //
            CustomStateDrawing(
                conditions.consolidationConditions.state,
                false, //
                X_DIRECTION_NONE,
                false, // ignoreSwingHighs
                false, // ignoreSwingLows
                false, // ignoreSupportZones
                false, // ignoreResistanceZones
                false, // ignoreSupplyZones
                false, // ignoreDemandZones
                true,  // ignoreBullishOrderBlocks
                true,  // ignoreBearishOrderBlocks
                true,  // ignoreBullishFairValueGaps
                true,  // ignoreBearishFairValueGaps
                true,  // ignoreBullishRejectionBars
                true,  // ignoreBearishRejectionBars
                true,  // ignoreBullishMomentumBars
                true   // ignoreBearishMomentumBars
            );

            //
            // TODO: Remove ...
            // Draw ...
            if (hasVisionSupplyZone && visionSupplyZone != NULL)
            {
                //
                visionSupplyZone.To(TimeCurrent());
                XCSupplyZoneObject *iObj;
                bool isCreated = mPOIDrawer.CreateSupplyZone(
                    visionSupplyZone,
                    iObj //
                );
                if (isCreated)
                {
                    //
                    iObj.ZoneWidth(4);
                    iObj.ZoneColor(clrMagenta);
                    AddObjectIfNotExists(iObj);
                }
            }

            //
            // TODO: Remove ...
            // Draw ...
            if (hasVisionDemandZone && visionDemandZone != NULL)
            {
                //
                visionDemandZone.To(TimeCurrent());
                XCDemandZoneObject *iObj;
                bool isCreated = mPOIDrawer.CreateDemandZone(
                    visionDemandZone,
                    iObj //
                );
                if (isCreated)
                {
                    //
                    iObj.ZoneWidth(4);
                    iObj.ZoneColor(clrAqua);
                    AddObjectIfNotExists(iObj);
                }
            }

            //
            if (result)
            {
                ClearDraws();
            }


            //
            // TODO: Remove this ...
            // Draw ...
            if (hasConsolidationSupportZone &&
                consolidationSupportZone != NULL)
            {
                //
                consolidationSupportZone.To(TimeCurrent());
                XCSupportZoneObject *iObj;
                bool isCreated = mPOIDrawer.CreateSupportZone(
                    consolidationSupportZone,
                    iObj //
                );
                if (isCreated)
                {
                    AddObjectIfNotExists(iObj);
                }
            }

            //
            // TODO: Remove this ...
            // Draw ...
            if (hasConsolidationResistanceZone &&
                consolidationResistanceZone != NULL)
            {
                //
                consolidationResistanceZone.To(TimeCurrent());
                XCResistanceZoneObject *iObj;
                bool isCreated = mPOIDrawer.CreateResistanceZone(
                    consolidationResistanceZone,
                    iObj //
                );
                if (isCreated)
                {
                    AddObjectIfNotExists(iObj);
                }
            }

////////////////////////////////////////////////////////////////////////////////////

            //
            XCSwing *swingLow = NULL;
            XCSwing *swingHigh = NULL;
            bool isSwingLowRejected = false;
            bool isSwingHighRejected = false;
            int swingLowsCount = decisionConditions.state.CountSwingLows();
            int swingHighsCount = decisionConditions.state.CountSwingHighs();
            if (IsValidSize(swingLowsCount))
            {
                swingLow = decisionConditions.state.swingLows[swingLowsCount - 1];
            }
            if (IsValidSize(swingHighsCount))
            {
                swingHigh = decisionConditions.state.swingHighs[swingHighsCount - 1];
            }

            //
            isSwingLowRejected = swingLow != NULL &&
                                 swingLow.IsValid() &&
                                 decisionCBar.low > swingLow.GetValue();

            //
            isSwingHighRejected = swingHigh != NULL &&
                                  swingHigh.IsValid() &&
                                  decisionCBar.high < swingHigh.GetValue();


///////////////////////////////////////////////////////////////////////////////////////////


    //
    // TODO: Remove this ...
    XTestProiderConditions mTestConditions;
    bool DetectTestSignal(
        X121SMCStrategyConditions &conditions //
    )
    {
        //
        bool result = false;

        //
        string symbol = GetSymbol();
        ENUM_TIMEFRAMES period = GetPeriod();

        //
        ENUM_X_121_SMC_PROVIDERS provider = X_121_SMC_PROVIDER_SMPV;
        string providerStr = ToString(provider);

        //
        int zIndex = 0;
        int cIndex = zIndex + 1;
        int pIndex = cIndex + 1;
        int ppIndex = pIndex + 1;

        //
        XOHCL zBar;
        result = zBar.Init(
            symbol,
            period,
            zIndex //
        );
        if (!result)
        {
            return result;
        }

        //
        XOHCL cBar;
        result = cBar.Init(
            symbol,
            period,
            cIndex //
        );
        if (!result)
        {
            return result;
        }

        //
        bool isBullish = false;
        bool isBearish = false;

        //
        double bid = GetBid(symbol);
        datetime cTime = TimeCurrent();

        //
        double selectedSL = 0;

        //
        // Retrieve Peak and Vale ...
        double peak = conditions.triggerConditions.x121Conditions.peaksBuffer[0];
        double vale = conditions.triggerConditions.x121Conditions.valesBuffer[0];

        //
        X121SMCCycleConditions triggerConditions = conditions.triggerConditions;
        X121SMCCycleConditions decisionConditions = conditions.decisionConditions;
        X121SMCCycleConditions analyseConditions = conditions.analyseConditions;
        X121SMCCycleConditions verificationConditions = conditions.verificationConditions;
        X121SMCCycleConditions consolidationConditions = conditions.consolidationConditions;
        X121SMCCycleConditions visionConditions = conditions.visionConditions;

        //
        XPOIState triggerState = triggerConditions.state;
        XPOIState decisionState = decisionConditions.state;
        XPOIState analyseState = analyseConditions.state;
        XPOIState verificationState = verificationConditions.state;
        XPOIState consolidationState = consolidationConditions.state;
        XPOIState visionState = visionConditions.state;

        //
        int zoneValidationDivider = 10;

        //
        // Try to Detect Setup Conditions ...
        ENUM_X_DIRECTION setupDir;
        result = mTestConditions.IsSetuped(setupDir);
        if (!result)
        {
            //
            // First we must check a new Peak or Vale Happens ...
            bool isNewPeak = conditions.triggerConditions.x121Conditions.isNewPeak;
            bool isNewVale = conditions.triggerConditions.x121Conditions.isNewVale;

            //
            result = isNewPeak ||
                     isNewVale;
            if (!result)
            {
                return result;
            }

            //
            mTestConditions.isNewPeak = isNewPeak;
            mTestConditions.isNewVale = isNewVale;

            //
            // We have to Check the Peaks and Vales Happens inside a Demand or Supply Zone ...
            // in Vision State ...

            //
            bool hasVisionSupplyZone = false;
            XCSupplyZone *visionSupplyZone = NULL;
            int visionSupplyZonesCount = visionState.CountSupplyZones();
            if (isNewPeak &&
                IsValidSize(visionSupplyZonesCount))
            {
                //
                // Try to Find Inside Zone ...
                for (int i = 0; i < visionSupplyZonesCount; i++)
                {
                    //
                    XCSupplyZone *iZone = visionState.supplyZones[i];
                    double zoneValidRange = (iZone.Upper() - iZone.Lower()) / zoneValidationDivider;

                    //
                    hasVisionSupplyZone =
                        //
                        peak >= iZone.Lower() &&
                        peak <= iZone.Upper() &&
                        peak > iZone.Upper() - zoneValidRange
                        //
                        ;
                    if (hasVisionSupplyZone)
                    {
                        //
                        visionSupplyZone = iZone;
                        break;
                    }
                }
            }

            //
            bool hasVisionDemandZone = false;
            XCDemandZone *visionDemandZone = NULL;
            int visionDemandZonesCount = visionState.CountDemandZones();
            if (isNewVale &&
                IsValidSize(visionDemandZonesCount))
            {
                //
                // Try to Find Inside Zone ...
                for (int i = 0; i < visionDemandZonesCount; i++)
                {
                    //
                    XCDemandZone *iZone = visionState.demandZones[i];
                    double zoneValidRange = (iZone.Upper() - iZone.Lower()) / zoneValidationDivider;

                    //
                    hasVisionDemandZone =
                        //
                        vale >= iZone.Lower() &&
                        vale <= iZone.Upper() &&
                        vale < iZone.Lower() + zoneValidRange
                        //
                        ;
                    if (hasVisionDemandZone)
                    {
                        //
                        visionDemandZone = iZone;
                        break;
                    }
                }
            }

            //
            result = hasVisionSupplyZone ||
                     hasVisionDemandZone;
            if (!result)
            {
                return result;
            }

            //
            mTestConditions.visionSupplyZone = visionSupplyZone;
            mTestConditions.visionDemandZone = visionDemandZone;

            //
            mTestConditions.hasVisionSupplyZone = hasVisionSupplyZone;
            mTestConditions.hasVisionDemandZone = hasVisionDemandZone;

            //
            double triggerPeak = conditions.triggerConditions.x121Conditions.peaksBuffer[0];
            double decisionPeak = conditions.decisionConditions.x121Conditions.peaksBuffer[0];
            double analysePeak = conditions.analyseConditions.x121Conditions.peaksBuffer[0];
            double verificationPeak = conditions.verificationConditions.x121Conditions.peaksBuffer[0];
            double consolidationPeak = conditions.consolidationConditions.x121Conditions.peaksBuffer[0];
            double visionPeak = conditions.visionConditions.x121Conditions.peaksBuffer[0];

            //
            bool isPeaksSame =
                //
                triggerPeak &&
                decisionPeak &&
                analysePeak &&
                verificationPeak &&
                consolidationPeak &&
                visionPeak
                //
                ;

            //
            double triggerVale = conditions.triggerConditions.x121Conditions.valesBuffer[0];
            double decisionVale = conditions.decisionConditions.x121Conditions.valesBuffer[0];
            double analyseVale = conditions.analyseConditions.x121Conditions.valesBuffer[0];
            double verificationVale = conditions.verificationConditions.x121Conditions.valesBuffer[0];
            double consolidationVale = conditions.consolidationConditions.x121Conditions.valesBuffer[0];
            double visionVale = conditions.visionConditions.x121Conditions.valesBuffer[0];

            //
            bool isValesSame =
                //
                triggerVale &&
                decisionVale &&
                analyseVale &&
                verificationVale &&
                consolidationVale &&
                visionVale
                //
                ;

            //
            mTestConditions.hasSamePeaks = isPeaksSame;
            mTestConditions.hasSameVales = isValesSame;

            //
            isBullish =
                //
                isNewVale &&
                isPeaksSame &&
                isValesSame &&
                hasVisionDemandZone
                //
                ;

            //
            isBearish =
                //
                isNewPeak &&
                isPeaksSame &&
                isValesSame &&
                hasVisionSupplyZone
                //
                ;

            //
            result =
                isBullish ||
                isBearish;
            if (!result)
            {
                return result;
            }

            //
            mTestConditions.setupTime = TimeCurrent();

            //
            result = mTestConditions.IsSetuped(setupDir);
            if (!result)
            {
                return result;
            }

            //
            // Alert ...
            string message = providerStr + " Conditions Set Upped: " + ToString(setupDir);
            Alert(message);
        }
        else
        {
            //
            // Try to Detect Trigger Conditions ...
            mTestConditions.symbol = symbol;
            mTestConditions.period = period;

            //
            // Try to Find Support Zone which Vales Inside it ...
            bool hasConsolidationSupportZone = false;
            XCSupportZone *consolidationSupportZone = NULL;
            int consolidationSupportZonesCount = consolidationState.CountSupportZones();
            if (IsValidSize(consolidationSupportZonesCount))
            {
                //
                for (int i = 0; i < consolidationSupportZonesCount; i++)
                {
                    //
                    XCSupportZone *iZone = consolidationState.supportZones[i];
                    // double zoneValidRange = (iZone.Upper() - iZone.Lower()) / zoneValidationDivider;

                    //
                    hasConsolidationSupportZone =
                        //
                        peak >= iZone.Lower() &&
                        peak <= iZone.Upper()
                        // &&
                        // vale < iZone.Upper() - zoneValidRange
                        //
                        ;
                    if (hasConsolidationSupportZone)
                    {
                        //
                        consolidationSupportZone = iZone;
                        break;
                    }
                }
            }

            //
            // Try to Find Resistance Zone which Peaks Inside it ...
            bool hasConsolidationResistanceZone = false;
            XCResistanceZone *consolidationResistanceZone = NULL;
            int consolidationResistanceZonesCount = consolidationState.CountResistanceZones();
            if (IsValidSize(consolidationResistanceZonesCount))
            {
                //
                for (int i = 0; i < consolidationResistanceZonesCount; i++)
                {
                    //
                    XCResistanceZone *iZone = consolidationState.resistanceZones[i];
                    // double zoneValidRange = (iZone.Upper() - iZone.Lower()) / zoneValidationDivider;

                    //
                    hasConsolidationResistanceZone =
                        //
                        vale >= iZone.Lower() &&
                        vale <= iZone.Upper()
                        // &&
                        // peak > iZone.Lower() + zoneValidRange
                        //
                        ;
                    if (hasConsolidationResistanceZone)
                    {
                        //
                        consolidationResistanceZone = iZone;
                        break;
                    }
                }
            }

            //
            result = hasConsolidationSupportZone ||
                     hasConsolidationResistanceZone;
            if (!result)
            {
                return result;
            }

            //
            result =
                //
                (IsBullish(setupDir) &&
                 hasConsolidationResistanceZone)
                //
                ||
                //
                (IsBearish(setupDir) &&
                 hasConsolidationSupportZone)
                //
                ;
            if (!result)
            {
                return result;
            }

            //
            // Detect State Conditions ...

            //
            // Vision ...

            //
            bool isVisionBullishPassed =
                //
                // Sar ...
                visionConditions.x121Conditions.isSarBullish
                //
                &&
                //
                // VWap ...
                visionConditions.x121Conditions.isVWapFastBullish
                //
                ;

            //
            bool isVisionBearishPassed =
                //
                // Sar ...
                visionConditions.x121Conditions.isSarBearish
                //
                &&
                //
                // VWap ...
                visionConditions.x121Conditions.isVWapFastBearish
                //
                ;

            //
            bool isVisionPassed = isVisionBullishPassed ||
                                  isVisionBearishPassed;
            result = isVisionPassed;
            if (!result)
            {
                return result;
            }

            //
            // Consolidation ...

            //
            bool isConsolidationBullishPassed =
                //
                // Sar ...
                consolidationConditions.x121Conditions.isSarBullish
                //
                &&
                //
                // VWap State ...
                consolidationConditions.x121Conditions.isVWapBullishState
                //
                &&
                //
                // VWap Order ...
                consolidationConditions.x121Conditions.isVWapBullishOrdered
                //
                ;

            //
            bool isConsolidationBearishPassed =
                //
                //
                // Sar ...
                consolidationConditions.x121Conditions.isSarBearish
                //
                &&
                //
                // VWap State ...
                consolidationConditions.x121Conditions.isVWapBearishState
                //
                &&
                //
                // VWap Order ...
                consolidationConditions.x121Conditions.isVWapBearishOrdered
                //
                ;

            //
            bool isConsolidationPassed = isConsolidationBullishPassed ||
                                         isConsolidationBearishPassed;
            result = isConsolidationPassed;
            if (!result)
            {
                return result;
            }

            //
            // Verification ...

            //
            bool isVerificationBullishPassed =
                //
                // Sar ...
                verificationConditions.x121Conditions.isSarBullish
                //
                &&
                //
                // VWap State ...
                verificationConditions.x121Conditions.isVWapBullishState
                //
                &&
                //
                // VWap Order ...
                verificationConditions.x121Conditions.isVWapBullishOrdered
                //
                ;

            //
            bool isVerificationBearishPassed =
                //
                // Sar ...
                verificationConditions.x121Conditions.isSarBearish
                //
                &&
                //
                // VWap State ...
                verificationConditions.x121Conditions.isVWapBearishState
                //
                &&
                //
                // VWap Order ...
                verificationConditions.x121Conditions.isVWapBearishOrdered
                //
                ;

            //
            bool isVerificationPassed = isVerificationBullishPassed ||
                                        isVerificationBearishPassed;
            result = isVerificationPassed;
            if (!result)
            {
                return result;
            }

            //
            // Analyse ...

            //
            bool isAnalyseBullishPassed =
                //
                // Sar ...
                analyseConditions.x121Conditions.isSarBullish
                //
                &&
                //
                // VWap Order ...
                analyseConditions.x121Conditions.isVWapBullishOrdered
                //
                &&
                //
                // VWap State ...
                (analyseConditions.x121Conditions.isVWapBullishState ||
                 (analyseConditions.x121Conditions.isVWapMidBullish &&
                  analyseConditions.x121Conditions.isVWapSlowBullish))
                //
                ;

            //
            bool isAnalyseBearishPassed =
                //
                // Sar ...
                analyseConditions.x121Conditions.isSarBearish
                //
                &&
                //
                // VWap Order ...
                analyseConditions.x121Conditions.isVWapBearishOrdered
                //
                &&
                //
                // VWap State ...
                (analyseConditions.x121Conditions.isVWapBearishState ||
                 (analyseConditions.x121Conditions.isVWapMidBearish &&
                  analyseConditions.x121Conditions.isVWapSlowBearish))
                //
                ;

            //
            bool isAnalysePassed = isAnalyseBullishPassed ||
                                   isAnalyseBearishPassed;
            result = isAnalysePassed;
            if (!result)
            {
                return result;
            }

            //
            // Decision ...

            //
            double decisionPeak = decisionConditions.x121Conditions.peaksBuffer[1];
            double decisionVale = decisionConditions.x121Conditions.valesBuffer[1];

            //
            XOHCL decisionCBar;
            result = mDecisionCycleHelper.GetBar(
                decisionCBar,
                cIndex //
            );

            //
            // Check Fibo Pressure ...
            ENUM_X_DIRECTION pressureDir;
            bool hasPressurePin = mBarAnalyser.HasFiboPressure(
                decisionCBar,
                pressureDir //
            );

            //
            bool isBarBullish =
                //
                (hasPressurePin &&
                 IsBullish(pressureDir))
                //
                &&
                //
                decisionCBar.low == decisionVale
                //
                ;

            //
            bool isBarBearish =
                //
                (hasPressurePin &&
                 IsBearish(pressureDir))
                //
                &&
                //
                decisionCBar.high == decisionPeak
                //
                ;

            //
            bool isBarPassed = isBarBullish ||
                               isBarBearish;
            result = isBarPassed;
            if (!result)
            {
                return result;
            }

            //
            bool isDecisionBullishPassed =
                //
                // Bar ...
                isBarBullish
                //
                &&
                //
                // VWap Order ...
                decisionConditions.x121Conditions.isVWapBullishOrdered
                //
                ;

            //
            bool isDecisionBearishPassed =
                //
                // Bar ...
                isBarBearish
                //
                &&
                //
                // VWap Order ...
                decisionConditions.x121Conditions.isVWapBearishOrdered
                //
                ;

            //
            bool isDecisionPassed = isDecisionBullishPassed ||
                                    isDecisionBearishPassed;
            result = isDecisionPassed;
            if (!result)
            {
                return result;
            }

            //
            // Trigger ...

            //
            double donOpenUpper = triggerConditions.x121Conditions.donOpenUpperBuffer[1];
            double donOpenLower = triggerConditions.x121Conditions.donOpenLowerBuffer[1];

            //
            double donCloseUpper = triggerConditions.x121Conditions.donCloseUpperBuffer[1];
            double donCloseLower = triggerConditions.x121Conditions.donCloseLowerBuffer[1];

            //
            bool isDonBullish =
                //
                donCloseLower > donOpenUpper
                //
                &&
                //
                cBar.low > donCloseLower &&
                cBar.high > donCloseLower
                //
                ;

            //
            bool isDonBearish =
                //
                donOpenUpper > donCloseUpper
                //
                &&
                //
                cBar.low < donCloseUpper &&
                cBar.high < donCloseUpper
                //
                ;

            //
            bool isTriggerBullishPassed =
                //
                // Don ...
                isDonBullish
                //
                &&
                //
                // Sar ...
                triggerConditions.x121Conditions.isSarBullish
                //
                ;

            //
            bool isTriggerBearishPassed =
                //
                // Don ...
                isDonBearish
                //
                &&
                //
                // Sar ...
                triggerConditions.x121Conditions.isSarBearish
                //
                ;

            //
            bool isTriggerPassed = isTriggerBullishPassed ||
                                   isTriggerBearishPassed;
            result = isTriggerPassed;
            if (!result)
            {
                return result;
            }

            //
            //
            //

            //
            bool isBullishTriggerConditionsPassed =
                //
                isConsolidationBullishPassed &&
                isVerificationBullishPassed &&
                isAnalyseBullishPassed &&
                isDecisionBullishPassed &&
                isTriggerBullishPassed
                //
                ;

            //
            bool isBearishTriggerConditionsPassed =
                //
                isConsolidationBearishPassed &&
                isVerificationBearishPassed &&
                isAnalyseBearishPassed &&
                isDecisionBearishPassed &&
                isTriggerBearishPassed
                //
                ;

            //
            //
            //

            //
            bool isBullish =
                //
                IsBullish(setupDir) &&
                hasConsolidationSupportZone &&
                isBullishTriggerConditionsPassed
                //
                ;

            //
            bool isBearish =
                //
                IsBearish(setupDir) &&
                hasConsolidationResistanceZone &&
                isBearishTriggerConditionsPassed
                //
                ;

            //
            result =
                isBullish ||
                isBearish;
            if (!result)
            {
                return result;
            }

            //
            double entry = GetEntry(
                symbol,
                setupDir //
            );
            double spread = GetSpread(
                symbol //
            );

            //
            zoneValidationDivider = 8;
            double selectedSL = isBullish
                                    ? consolidationResistanceZone.Upper() - spread -
                                          ((consolidationResistanceZone.Upper() - consolidationResistanceZone.Lower()) /
                                           zoneValidationDivider)
                                    : consolidationSupportZone.Lower() + spread +
                                          ((consolidationSupportZone.Upper() - consolidationSupportZone.Lower()) /
                                           zoneValidationDivider);

            //
            mTestConditions.sl = selectedSL;
            mTestConditions.type =
                isBullish
                    ? X_POSITION_TYPE_LONG
                    : X_POSITION_TYPE_SHORT;
            mTestConditions.triggerTime = TimeCurrent();
        }

        //
        // Check Conditions is Prepared for Trigger ...
        result = mTestConditions.CanTrigger();
        if (!result)
        {
            return result;
        }

        //
        conditions.signalDir = setupDir;
        conditions.provider = providerStr;
        conditions.sl = mTestConditions.sl;

        //
        mTestConditions.Clean();

        //
        return result;
    }


///////////////////////////////////////////////////////////////////////////////////////////////

            //
            // Detect Supply and Demand Zones inside Order Block ...
            XCOrderBlock *orderBlock = NULL;
            if (isNewPeakInsideBearihOrderBlock)
            {
                orderBlock = mTestConditions.bearishOrderBlock;
            }
            else
            {
                orderBlock = mTestConditions.bullishOrderBlock;
            }

            //
            // Supply Zone ...
            XPOIState selectedState = visionState;
            bool hasSupplyZone = mTestConditions.HasSupplyZone();
            int supplyZonesCount = selectedState.CountSupplyZones();
            if (!hasSupplyZone)
            {
                //
                if (IsValidSize(supplyZonesCount))
                {
                    //
                    XCSupplyZone *supplyZones[];
                    for (int i = 0; i < supplyZonesCount; i++)
                    {
                        //
                        XCSupplyZone *iZone = selectedState.supplyZones[i];

                        //
                        bool isValid = iZone.Upper() <= orderBlock.Upper() &&
                                       iZone.Lower() >= orderBlock.Lower();
                        if (isValid)
                        {
                            //
                            Add(
                                iZone,
                                supplyZones //
                            );
                        }
                    }

                    //
                    XCSupplyZone *supply = NULL;
                    supplyZonesCount = ArraySize(supplyZones);
                    for (int i = 0; i < supplyZonesCount; i++)
                    {
                        //
                        XCSupplyZone *iZone = supplyZones[i];

                        //
                        bool isValid = supply == NULL
                                           ? true
                                           : supply.Upper() < iZone.Upper();
                        if (isValid)
                        {
                            supply = iZone;
                        }
                    }
                    if (supply != NULL && supply.IsValid())
                    {
                        mTestConditions.supplyZone = supply;
                    }

                    //
                    hasSupplyZone = mTestConditions.HasSupplyZone();
                }
            }
            //
            // TODO: Remove ...
            else
            {
                //
                mTestConditions.supplyZone.To(TimeCurrent());
                XCSupplyZoneObject *iObj;
                bool isCreated = mPOIDrawer.CreateSupplyZone(
                    mTestConditions.supplyZone,
                    iObj //
                );
                if (isCreated)
                {
                    //
                    iObj.ZoneWidth(3);

                    //
                    AddObjectIfNotExists(iObj);
                }
            }

            //
            // Demand Zone ...
            bool hasDemandZone = mTestConditions.HasDemandZone();
            int demandZonesCount = selectedState.CountDemandZones();
            if (!hasDemandZone)
            {
                //
                if (IsValidSize(demandZonesCount))
                {
                    //
                    XCDemandZone *demandZones[];
                    for (int i = 0; i < demandZonesCount; i++)
                    {
                        //
                        XCDemandZone *iZone = selectedState.demandZones[i];

                        //
                        bool isValid = iZone.Upper() <= orderBlock.Upper() &&
                                       iZone.Lower() >= orderBlock.Lower();
                        if (isValid)
                        {
                            //
                            Add(
                                iZone,
                                demandZones //
                            );
                        }
                    }

                    //
                    XCDemandZone *demand = NULL;
                    demandZonesCount = ArraySize(demandZones);
                    for (int i = 0; i < demandZonesCount; i++)
                    {
                        //
                        XCDemandZone *iZone = demandZones[i];

                        //
                        bool isValid = demand == NULL
                                           ? true
                                           : demand.Upper() < iZone.Upper();
                        if (isValid)
                        {
                            demand = iZone;
                        }
                    }
                    if (demand != NULL && demand.IsValid())
                    {
                        mTestConditions.demandZone = demand;
                    }

                    //
                    hasDemandZone = mTestConditions.HasDemandZone();
                }
            }
            //
            // TODO: Remove ...
            else
            {
                //
                mTestConditions.demandZone.To(TimeCurrent());
                XCDemandZoneObject *iObj;
                bool isCreated = mPOIDrawer.CreateDemandZone(
                    mTestConditions.demandZone,
                    iObj //
                );
                if (isCreated)
                {
                    //
                    iObj.ZoneWidth(3);

                    //
                    AddObjectIfNotExists(iObj);
                }
            }



    //
    // Supply and Demand Zone ...
    XCSupplyZone *supplyZone;
    XCDemandZone *demandZone;

    //
    supplyZone = NULL;
    demandZone = NULL;

    //
    // Supply and Demand ...

    bool HasSupplyZone()
    {
        //
        bool result = false;

        //
        result =
            //
            supplyZone != NULL &&
            supplyZone.IsValid()
            //
            ;

        //
        return result;
    }

    bool HasDemandZone()
    {
        //
        bool result = false;

        //
        result =
            //
            demandZone != NULL &&
            demandZone.IsValid()
            //
            ;

        //
        return result;
    }

////////////////////////////////////////////////////////////////////////////////////////////////

            // else
            // //
            // // Draw ...
            // {
            //     //
            //     // TODO: Remove this ...

            //     //
            //     bool hasBullishOB = mTestConditions.HasBullishOrderBlock();
            //     if (hasBullishOB)
            //     {
            //         //
            //         mTestConditions.bullishOrderBlock.To(TimeCurrent());
            //         XCBullishOrderBlockObject *iObj;
            //         bool isCreated = mPOIDrawer.CreateBullishOrderBlock(
            //             mTestConditions.bullishOrderBlock,
            //             iObj //
            //         );
            //         if (isCreated)
            //         {
            //             //
            //             iObj.ZoneWidth(4);
            //             iObj.ZoneColor(clrAqua);

            //             //
            //             AddObjectIfNotExists(iObj);
            //         }
            //     }

            //     //
            //     bool hasBearishOB = mTestConditions.HasBearishOrderBlock();
            //     if (hasBearishOB)
            //     {
            //         //
            //         mTestConditions.bearishOrderBlock.To(TimeCurrent());
            //         XCBearishOrderBlockObject *iObj;
            //         bool isCreated = mPOIDrawer.CreateBearishOrderBlock(
            //             mTestConditions.bearishOrderBlock,
            //             iObj //
            //         );
            //         if (isCreated)
            //         {
            //             //
            //             iObj.ZoneWidth(4);
            //             iObj.ZoneColor(clrMagenta);

            //             //
            //             AddObjectIfNotExists(iObj);
            //         }
            //     }
            // }

            //
            // Detect Supply and Demand Zone inside Order Block ...

///////////////////////////////////////////////////////////////////////////////////////////////


    //
    // TODO: Remove this ...
    XSMCStrategySetupConditions mTestConditions;
    bool DetectTestSignal(
        X121SMCStrategyConditions &conditions //
    )
    {
        //
        bool result = false;

        //
        string symbol = GetSymbol();
        ENUM_TIMEFRAMES period = GetPeriod();

        //
        ENUM_X_121_SMC_PROVIDERS provider = X_121_SMC_PROVIDER_SMPV;
        string providerStr = ToString(provider);

        //
        int zIndex = 0;
        int cIndex = zIndex + 1;
        int pIndex = cIndex + 1;
        int ppIndex = pIndex + 1;

        //
        XOHCL zBar;
        result = zBar.Init(
            symbol,
            period,
            zIndex //
        );
        if (!result)
        {
            return result;
        }

        //
        XOHCL cBar;
        result = cBar.Init(
            symbol,
            period,
            cIndex //
        );
        if (!result)
        {
            return result;
        }

        //
        bool isBullish = false;
        bool isBearish = false;

        //
        double ask = GetAsk(symbol);
        double bid = GetBid(symbol);
        datetime cTime = TimeCurrent();

        //
        double selectedSL = 0;

        //
        // Retrieve Peak and Vale ...
        double peak = conditions.triggerConditions.x121Conditions.peaksBuffer[0];
        double vale = conditions.triggerConditions.x121Conditions.valesBuffer[0];

        //
        X121SMCCycleConditions triggerConditions = conditions.triggerConditions;
        X121SMCCycleConditions decisionConditions = conditions.decisionConditions;
        X121SMCCycleConditions analyseConditions = conditions.analyseConditions;
        X121SMCCycleConditions verificationConditions = conditions.verificationConditions;
        X121SMCCycleConditions consolidationConditions = conditions.consolidationConditions;
        X121SMCCycleConditions visionConditions = conditions.visionConditions;

        //
        XPOIState triggerState = triggerConditions.state;
        XPOIState decisionState = decisionConditions.state;
        XPOIState analyseState = analyseConditions.state;
        XPOIState verificationState = verificationConditions.state;
        XPOIState consolidationState = consolidationConditions.state;
        XPOIState visionState = visionConditions.state;

        //
        int zoneValidationDivider = 10;

        //
        // Try to Detect Setup Conditions ...
        result = mTestConditions.IsSetuped();

        //
        // Try to Validate if not Pssed ...
        if (result)
        {
            //
            bool canReset = false;
            bool iBullish = IsBullish(mTestConditions.dir);
            if (isBullish)
            {
                //
                canReset =
                    //
                    bid < mTestConditions.bullishOrderBlock.Lower() &&
                    ask < mTestConditions.bullishOrderBlock.Lower() &&
                    cBar.high < mTestConditions.bullishOrderBlock.Lower()
                    //
                    ;
            }
            else
            {
                //
                canReset =
                    //
                    bid < mTestConditions.bearishOrderBlock.Upper() &&
                    ask < mTestConditions.bearishOrderBlock.Upper() &&
                    cBar.high < mTestConditions.bearishOrderBlock.Upper()
                    //
                    ;
            }

            //
            if (canReset)
            {
                //
                string message = providerStr + " Conditions Resetted ...";
                Alert(message);
                mTestConditions.Clean();
            }

            //
            result = mTestConditions.IsSetuped();
        }

        //
        if (!result)
        {
            //
            // Check has Order Block ...
            bool hasOrderBlock = mTestConditions.HasOrderBlock();
            if (!hasOrderBlock)
            {
                //
                // Detect Order Blocks ...

                //
                // Bullish ...
                bool hasBullishOB = mTestConditions.HasBullishOrderBlock();
                if (!hasBullishOB)
                {
                    //
                    // Bullish ...
                    int bullishOBsCount = visionState.CountBullishOrderBlocks();
                    if (IsValidSize(bullishOBsCount))
                    {
                        //
                        XCOrderBlock *bullishOBs[];
                        for (int i = 0; i < bullishOBsCount; i++)
                        {
                            //
                            XCOrderBlock *iZone = visionState.bullishOrderBlocks[i];

                            //
                            bool isValid = cBar.low > iZone.Upper();
                            if (isValid)
                            {
                                //
                                Add(
                                    iZone,
                                    bullishOBs //
                                );
                            }
                        }

                        //
                        XCOrderBlock *ob = NULL;
                        bullishOBsCount = ArraySize(bullishOBs);
                        if (IsValidSize(bullishOBsCount))
                        {
                            //
                            for (int i = 0; i < bullishOBsCount; i++)
                            {
                                //
                                XCOrderBlock *iZone = bullishOBs[i];

                                //
                                bool isValid = ob == NULL
                                                   ? true
                                                   : ob.Upper() < iZone.Upper();
                                if (isValid)
                                {
                                    ob = iZone;
                                }
                            }
                        }

                        //
                        if (ob != NULL && ob.IsValid())
                        {
                            mTestConditions.bullishOrderBlock = ob;
                        }
                    }
                }

                //
                // Bearish ...
                bool hasBearishOB = mTestConditions.HasBearishOrderBlock();
                if (!hasBearishOB)
                {
                    //
                    // Bearish ...
                    int bearishOBsCount = visionState.CountBearishOrderBlocks();
                    if (IsValidSize(bearishOBsCount))
                    {
                        //
                        XCOrderBlock *bearishOBs[];
                        for (int i = 0; i < bearishOBsCount; i++)
                        {
                            //
                            XCOrderBlock *iZone = visionState.bearishOrderBlocks[i];

                            //
                            bool isValid = cBar.high < iZone.Lower();
                            if (isValid)
                            {
                                //
                                Add(
                                    iZone,
                                    bearishOBs //
                                );
                            }
                        }

                        //
                        XCOrderBlock *ob = NULL;
                        bearishOBsCount = ArraySize(bearishOBs);
                        if (IsValidSize(bearishOBsCount))
                        {
                            //
                            for (int i = 0; i < bearishOBsCount; i++)
                            {
                                //
                                XCOrderBlock *iZone = bearishOBs[i];

                                //
                                bool isValid = ob == NULL
                                                   ? true
                                                   : ob.Lower() > iZone.Lower();
                                if (isValid)
                                {
                                    ob = iZone;
                                }
                            }
                        }

                        //
                        if (ob != NULL && ob.IsValid())
                        {
                            mTestConditions.bearishOrderBlock = ob;
                        }
                    }
                }

                //
                result = mTestConditions.HasOrderBlock();
                if (!result)
                {
                    return result;
                }
            }

            //
            // Wait for new Vale or Peaks ...
            double visionPeak = visionConditions.x121Conditions.peaksBuffer[0];
            double visionVale = visionConditions.x121Conditions.valesBuffer[0];
            bool isNewVisionPeak = visionConditions.x121Conditions.isNewPeak;
            bool isNewVisionVale = visionConditions.x121Conditions.isNewVale;

            //
            bool isNewPeakInsideBearihOrderBlock =
                //
                isNewVisionPeak &&
                visionPeak > mTestConditions.bearishOrderBlock.Lower() &&
                visionPeak < mTestConditions.bearishOrderBlock.Upper()
                //
                ;

            //
            bool isNewValeInsideBullishOrderBlock =
                //
                isNewVisionVale &&
                visionVale > mTestConditions.bullishOrderBlock.Lower() &&
                visionVale < mTestConditions.bullishOrderBlock.Upper()
                //
                ;

            //
            result = isNewPeakInsideBearihOrderBlock ||
                     isNewValeInsideBullishOrderBlock;
            if (!result)
            {
                return result;
            }

            //
            // Lookig for a Valid Peaks and Vales Formes ...
            // Peaks Inside Bearish Order Block ...
            // Vales inside Bullish Order Block ...

            //
            int validPivotRepetition = mTriggerCycleHelper.mX121Helper
                                           .GetDonChainLength();
            double triggerPeak = triggerConditions.x121Conditions.peaksBuffer[0];
            double triggerVale = triggerConditions.x121Conditions.valesBuffer[0];

            //
            // Valid Peaks ...
            XPVPivotPoint validPeak;
            XPVPivotPoint peaksChanges[];
            int peaksChangesCount = mTriggerCycleHelper.FillPeakPivotPoints(peaksChanges);
            if (IsValidSize(peaksChangesCount))
            {
                validPeak = peaksChanges[peaksChangesCount - 1];
            }

            //
            // Valid Vales ...
            XPVPivotPoint validVale;
            XPVPivotPoint valesChanges[];
            int valesChangesCount = mTriggerCycleHelper.FillValePivotPoints(valesChanges);
            if (IsValidSize(valesChangesCount))
            {
                validVale = valesChanges[valesChangesCount - 1];
            }

            //
            bool hasValidPeak = (validPeak.IsValid() &&
                                 validPeak.value < mTestConditions.bearishOrderBlock.Upper() &&
                                 validPeak.value > mTestConditions.bearishOrderBlock.Lower());

            //
            bool hasValidVale = (validVale.IsValid() &&
                                 validVale.value < mTestConditions.bullishOrderBlock.Upper() &&
                                 validVale.value > mTestConditions.bullishOrderBlock.Lower());

            //
            result = hasValidPeak ||
                     hasValidVale;
            if (!result)
            {
                return result;
            }

            //
            if (hasValidPeak)
            {
                mTestConditions.validPeak = validPeak;
            }
            if (hasValidVale)
            {
                mTestConditions.validVale = validVale;
            }

            //
            bool isBullish =
                //
                hasValidVale &&
                isNewValeInsideBullishOrderBlock
                //
                ;

            //
            bool isBearish =
                //
                hasValidPeak &&
                isNewPeakInsideBearihOrderBlock
                //
                ;

            //
            result = isBullish ||
                     isBearish;
            if (!result)
            {
                return result;
            }

            //
            mTestConditions.dir = isBullish
                                      ? X_DIRECTION_BULLISH
                                      : X_DIRECTION_BEARISH;
            mTestConditions.setupTime = TimeCurrent();

            //
            result = mTestConditions.IsSetuped();
            if (!result)
            {
                return result;
            }

            //
            // Alert ...
            string message = providerStr + " Conditions Set Upped: " + ToString(mTestConditions.dir);
            Alert(message);
        }
        else
        {
            //
            // Waits for Sar Change Under Valid Value or Above Valid Peak ...
            double triggerPeak = triggerConditions.x121Conditions.peaksBuffer[1];
            double triggerVale = triggerConditions.x121Conditions.valesBuffer[1];
            double triggerSar = triggerConditions.x121Conditions.sarBuffer[1];
            bool isSarSwitchedToBullish = triggerConditions.x121Conditions.isSarSwitchedToBullish;
            bool isSarSwitchedToBearish = triggerConditions.x121Conditions.isSarSwitchedToBearish;

            //
            bool isBullish =
                //
                isSarSwitchedToBullish &&
                triggerSar == triggerVale &&
                IsBullish(mTestConditions.dir) &&
                mTestConditions.validVale.IsValid() &&
                triggerSar < mTestConditions.validVale.value
                //
                ;

            //
            bool isBearish =
                //
                isSarSwitchedToBearish &&
                triggerSar == triggerPeak &&
                IsBearish(mTestConditions.dir) &&
                mTestConditions.validPeak.IsValid() &&
                triggerSar < mTestConditions.validPeak.value
                //
                ;

            //
            result = isBullish ||
                     isBearish;
            if (!result)
            {
                return result;
            }

            //
            // Try to Detect Trigger Conditions ...

            //
            mTestConditions.symbol = symbol;
            mTestConditions.period = period;

            //
            mTestConditions.Clean();
        }

        //
        // Check Conditions is Prepared for Trigger ...
        result = mTestConditions.CanTrigger();
        if (!result)
        {
            return result;
        }

        //
        conditions.signalDir = mTestConditions.dir;
        conditions.provider = providerStr;
        conditions.sl = mTestConditions.sl;

        //
        mTestConditions.Clean();

        //
        return result;
    }


/////////////////////////////////////////////////////////////////////////////////////////



    //
    // TODO: Remove this ...
    XSMCStrategySetupConditions mTestConditions;
    bool DetectTestSignal(
        X121SMCStrategyConditions &conditions //
    )
    {
        //
        bool result = false;

        //
        string symbol = GetSymbol();
        ENUM_TIMEFRAMES period = GetPeriod();

        //
        ENUM_X_121_SMC_PROVIDERS provider = X_121_SMC_PROVIDER_SMPV;
        string providerStr = ToString(provider);

        //
        int zIndex = 0;
        int cIndex = zIndex + 1;
        int pIndex = cIndex + 1;
        int ppIndex = pIndex + 1;

        //
        XOHCL zBar;
        result = zBar.Init(
            symbol,
            period,
            zIndex //
        );
        if (!result)
        {
            return result;
        }

        //
        XOHCL cBar;
        result = cBar.Init(
            symbol,
            period,
            cIndex //
        );
        if (!result)
        {
            return result;
        }

        //
        bool isBullish = false;
        bool isBearish = false;

        //
        double ask = GetAsk(symbol);
        double bid = GetBid(symbol);
        datetime cTime = TimeCurrent();

        //
        double selectedSL = 0;

        //
        // Retrieve Peak and Vale ...
        double peak = conditions.triggerConditions.x121Conditions.peaksBuffer[0];
        double vale = conditions.triggerConditions.x121Conditions.valesBuffer[0];

        //
        X121SMCCycleConditions triggerConditions = conditions.triggerConditions;
        X121SMCCycleConditions decisionConditions = conditions.decisionConditions;
        X121SMCCycleConditions analyseConditions = conditions.analyseConditions;
        X121SMCCycleConditions verificationConditions = conditions.verificationConditions;
        X121SMCCycleConditions consolidationConditions = conditions.consolidationConditions;
        X121SMCCycleConditions visionConditions = conditions.visionConditions;

        //
        XPOIState triggerState = triggerConditions.state;
        XPOIState decisionState = decisionConditions.state;
        XPOIState analyseState = analyseConditions.state;
        XPOIState verificationState = verificationConditions.state;
        XPOIState consolidationState = consolidationConditions.state;
        XPOIState visionState = visionConditions.state;

        //
        int zoneValidationDivider = 10;

        //
        // Try to Detect Setup Conditions ...
        result = mTestConditions.IsSetuped();

        //
        // Try to Validate if not Pssed ...
        if (result)
        {
            //
            bool canReset = false;
            bool iBullish = IsBullish(mTestConditions.dir);
            if (isBullish)
            {
                //
                canReset =
                    //
                    bid < mTestConditions.bullishOrderBlock.Lower() &&
                    ask < mTestConditions.bullishOrderBlock.Lower() &&
                    cBar.high < mTestConditions.bullishOrderBlock.Lower()
                    //
                    ;
            }
            else
            {
                //
                canReset =
                    //
                    bid < mTestConditions.bearishOrderBlock.Upper() &&
                    ask < mTestConditions.bearishOrderBlock.Upper() &&
                    cBar.high < mTestConditions.bearishOrderBlock.Upper()
                    //
                    ;
            }

            //
            if (canReset)
            {
                //
                string message = providerStr + " Conditions Resetted ...";
                Alert(message);
                mTestConditions.Clean();
            }

            //
            result = mTestConditions.IsSetuped();
        }

        //
        if (!result)
        {
            //
            // Check has Order Block ...
            bool hasOrderBlock = mTestConditions.HasOrderBlock();
            if (!hasOrderBlock)
            {
                //
                // Detect Order Blocks ...

                //
                // Bullish ...
                bool hasBullishOB = mTestConditions.HasBullishOrderBlock();
                if (!hasBullishOB)
                {
                    //
                    // Bullish ...
                    int bullishOBsCount = visionState.CountBullishOrderBlocks();
                    if (IsValidSize(bullishOBsCount))
                    {
                        //
                        XCOrderBlock *bullishOBs[];
                        for (int i = 0; i < bullishOBsCount; i++)
                        {
                            //
                            XCOrderBlock *iZone = visionState.bullishOrderBlocks[i];

                            //
                            bool isValid = cBar.low > iZone.Upper();
                            if (isValid)
                            {
                                //
                                Add(
                                    iZone,
                                    bullishOBs //
                                );
                            }
                        }

                        //
                        XCOrderBlock *ob = NULL;
                        bullishOBsCount = ArraySize(bullishOBs);
                        if (IsValidSize(bullishOBsCount))
                        {
                            //
                            for (int i = 0; i < bullishOBsCount; i++)
                            {
                                //
                                XCOrderBlock *iZone = bullishOBs[i];

                                //
                                bool isValid = ob == NULL
                                                   ? true
                                                   : ob.Upper() < iZone.Upper();
                                if (isValid)
                                {
                                    ob = iZone;
                                }
                            }
                        }

                        //
                        if (ob != NULL && ob.IsValid())
                        {
                            mTestConditions.bullishOrderBlock = ob;
                        }
                    }
                }

                //
                // Bearish ...
                bool hasBearishOB = mTestConditions.HasBearishOrderBlock();
                if (!hasBearishOB)
                {
                    //
                    // Bearish ...
                    int bearishOBsCount = visionState.CountBearishOrderBlocks();
                    if (IsValidSize(bearishOBsCount))
                    {
                        //
                        XCOrderBlock *bearishOBs[];
                        for (int i = 0; i < bearishOBsCount; i++)
                        {
                            //
                            XCOrderBlock *iZone = visionState.bearishOrderBlocks[i];

                            //
                            bool isValid = cBar.high < iZone.Lower();
                            if (isValid)
                            {
                                //
                                Add(
                                    iZone,
                                    bearishOBs //
                                );
                            }
                        }

                        //
                        XCOrderBlock *ob = NULL;
                        bearishOBsCount = ArraySize(bearishOBs);
                        if (IsValidSize(bearishOBsCount))
                        {
                            //
                            for (int i = 0; i < bearishOBsCount; i++)
                            {
                                //
                                XCOrderBlock *iZone = bearishOBs[i];

                                //
                                bool isValid = ob == NULL
                                                   ? true
                                                   : ob.Lower() > iZone.Lower();
                                if (isValid)
                                {
                                    ob = iZone;
                                }
                            }
                        }

                        //
                        if (ob != NULL && ob.IsValid())
                        {
                            mTestConditions.bearishOrderBlock = ob;
                        }
                    }
                }

                //
                result = mTestConditions.HasOrderBlock();
                if (!result)
                {
                    return result;
                }
            }

            //
            // Wait for new Vale or Peaks ...
            double visionPeak = visionConditions.x121Conditions.peaksBuffer[0];
            double visionVale = visionConditions.x121Conditions.valesBuffer[0];
            bool isNewVisionPeak = visionConditions.x121Conditions.isNewPeak;
            bool isNewVisionVale = visionConditions.x121Conditions.isNewVale;

            //
            bool isNewPeakInsideBearihOrderBlock =
                //
                isNewVisionPeak &&
                visionPeak > mTestConditions.bearishOrderBlock.Lower() &&
                visionPeak < mTestConditions.bearishOrderBlock.Upper()
                //
                ;

            //
            bool isNewValeInsideBullishOrderBlock =
                //
                isNewVisionVale &&
                visionVale > mTestConditions.bullishOrderBlock.Lower() &&
                visionVale < mTestConditions.bullishOrderBlock.Upper()
                //
                ;

            //
            result = isNewPeakInsideBearihOrderBlock ||
                     isNewValeInsideBullishOrderBlock;
            if (!result)
            {
                return result;
            }

            //
            // Lookig for a Valid Peaks and Vales Formes ...
            // Peaks Inside Bearish Order Block ...
            // Vales inside Bullish Order Block ...

            //
            int validPivotRepetition = mTriggerCycleHelper.mX121Helper
                                           .GetDonChainLength();
            double triggerPeak = triggerConditions.x121Conditions.peaksBuffer[0];
            double triggerVale = triggerConditions.x121Conditions.valesBuffer[0];

            //
            // Valid Peaks ...
            XPVPivotPoint validPeak;
            XPVPivotPoint peaksChanges[];
            int peaksChangesCount = mTriggerCycleHelper.FillPeakPivotPoints(peaksChanges);
            if (IsValidSize(peaksChangesCount))
            {
                validPeak = peaksChanges[peaksChangesCount - 1];
            }

            //
            // Valid Vales ...
            XPVPivotPoint validVale;
            XPVPivotPoint valesChanges[];
            int valesChangesCount = mTriggerCycleHelper.FillValePivotPoints(valesChanges);
            if (IsValidSize(valesChangesCount))
            {
                validVale = valesChanges[valesChangesCount - 1];
            }

            //
            bool hasValidPeak = (validPeak.IsValid() &&
                                 validPeak.value < mTestConditions.bearishOrderBlock.Upper() &&
                                 validPeak.value > mTestConditions.bearishOrderBlock.Lower());

            //
            bool hasValidVale = (validVale.IsValid() &&
                                 validVale.value < mTestConditions.bullishOrderBlock.Upper() &&
                                 validVale.value > mTestConditions.bullishOrderBlock.Lower());

            //
            result = hasValidPeak ||
                     hasValidVale;
            if (!result)
            {
                return result;
            }

            //
            if (hasValidPeak)
            {
                mTestConditions.validPeak = validPeak;
            }
            if (hasValidVale)
            {
                mTestConditions.validVale = validVale;
            }

            //
            bool isBullish =
                //
                hasValidVale &&
                isNewValeInsideBullishOrderBlock
                //
                ;

            //
            bool isBearish =
                //
                hasValidPeak &&
                isNewPeakInsideBearihOrderBlock
                //
                ;

            //
            result = isBullish ||
                     isBearish;
            if (!result)
            {
                return result;
            }

            //
            mTestConditions.dir = isBullish
                                      ? X_DIRECTION_BULLISH
                                      : X_DIRECTION_BEARISH;
            mTestConditions.setupTime = TimeCurrent();

            //
            result = mTestConditions.IsSetuped();
            if (!result)
            {
                return result;
            }

            //
            // Alert ...
            string message = providerStr + " Conditions Set Upped: " + ToString(mTestConditions.dir);
            Alert(message);
        }
        else
        {
            //
            // Waits for Sar Change Under Valid Value or Above Valid Peak ...
            double triggerPeak = triggerConditions.x121Conditions.peaksBuffer[1];
            double triggerVale = triggerConditions.x121Conditions.valesBuffer[1];
            double triggerSar = triggerConditions.x121Conditions.sarBuffer[1];
            bool isSarSwitchedToBullish = triggerConditions.x121Conditions.isSarSwitchedToBullish;
            bool isSarSwitchedToBearish = triggerConditions.x121Conditions.isSarSwitchedToBearish;

            //
            bool isBullish =
                //
                isSarSwitchedToBullish &&
                triggerSar == triggerVale &&
                IsBullish(mTestConditions.dir) &&
                mTestConditions.validVale.IsValid() &&
                triggerSar < mTestConditions.validVale.value
                //
                ;

            //
            bool isBearish =
                //
                isSarSwitchedToBearish &&
                triggerSar == triggerPeak &&
                IsBearish(mTestConditions.dir) &&
                mTestConditions.validPeak.IsValid() &&
                triggerSar < mTestConditions.validPeak.value
                //
                ;

            //
            result = isBullish ||
                     isBearish;
            if (!result)
            {
                return result;
            }

            //
            // Try to Detect Trigger Conditions ...

            //
            mTestConditions.symbol = symbol;
            mTestConditions.period = period;

            //
            mTestConditions.Clean();
        }

        //
        // Check Conditions is Prepared for Trigger ...
        result = mTestConditions.CanTrigger();
        if (!result)
        {
            return result;
        }

        //
        conditions.signalDir = mTestConditions.dir;
        conditions.provider = providerStr;
        conditions.sl = mTestConditions.sl;

        //
        mTestConditions.Clean();

        //
        return result;
    }


/////////////////////////////////////////////////////////////////////////////


    //
    // TODO: Remove this ...
    XSMCStrategySetupConditions mTestConditions;
    bool DetectTestSignal(
        X121SMCStrategyConditions &conditions //
    )
    {
        //
        bool result = false;

        //
        string symbol = GetSymbol();
        ENUM_TIMEFRAMES period = GetPeriod();

        //
        ENUM_X_121_SMC_PROVIDERS provider = X_121_SMC_PROVIDER_SMPV;
        string providerStr = ToString(provider);

        //
        int zIndex = 0;
        int cIndex = zIndex + 1;
        int pIndex = cIndex + 1;
        int ppIndex = pIndex + 1;

        //
        XOHCL zBar;
        result = zBar.Init(
            symbol,
            period,
            zIndex //
        );
        if (!result)
        {
            return result;
        }

        //
        XOHCL cBar;
        result = cBar.Init(
            symbol,
            period,
            cIndex //
        );
        if (!result)
        {
            return result;
        }

        //
        bool isBullish = false;
        bool isBearish = false;

        //
        double ask = GetAsk(symbol);
        double bid = GetBid(symbol);
        datetime cTime = TimeCurrent();

        //
        double selectedSL = 0;

        //
        // Retrieve Peak and Vale ...
        double triggerPeak = conditions.triggerConditions.x121Conditions.peaksBuffer[0];
        double triggerVale = conditions.triggerConditions.x121Conditions.valesBuffer[0];

        //
        X121SMCCycleConditions triggerConditions = conditions.triggerConditions;
        X121SMCCycleConditions decisionConditions = conditions.decisionConditions;
        X121SMCCycleConditions analyseConditions = conditions.analyseConditions;
        X121SMCCycleConditions verificationConditions = conditions.verificationConditions;
        X121SMCCycleConditions consolidationConditions = conditions.consolidationConditions;
        X121SMCCycleConditions visionConditions = conditions.visionConditions;

        //
        XPOIState triggerState = triggerConditions.state;
        XPOIState decisionState = decisionConditions.state;
        XPOIState analyseState = analyseConditions.state;
        XPOIState verificationState = verificationConditions.state;
        XPOIState consolidationState = consolidationConditions.state;
        XPOIState visionState = visionConditions.state;

        //
        int zoneValidationDivider = 10;
        int validPivotRepetition = mTriggerCycleHelper.mX121Helper
                                       .GetDonChainLength();

        //
        // Check Setting Upped ...
        result = mTestConditions.IsSetuped();

        //
        // Try to Validate if not Pssed ...
        if (result)
        {
            //
            double upper = 0;
            double lower = 0;

            //
            double hh = cBar.FindHighest(9, MODE_HIGH);
            double ll = cBar.FindLowest(9, MODE_LOW);

            //
            bool canReset = false;
            isBullish = IsBullish(mTestConditions.dir);
            if (isBullish)
            {
                //
                upper = mTestConditions.bullishOrderBlock.Upper();
                lower = mTestConditions.bullishOrderBlock.Lower();

                //
                canReset =
                    //
                    (ll > upper &&
                     bid > upper &&
                     ask > upper)
                    //
                    ||
                    //
                    (hh < lower &&
                     bid < lower &&
                     ask < lower)
                    //
                    ;
            }
            else
            {
                //
                upper = mTestConditions.bearishOrderBlock.Upper();
                lower = mTestConditions.bearishOrderBlock.Lower();

                //
                canReset =
                    //
                    (hh < lower &&
                     bid < lower &&
                     ask < lower)
                    //
                    ||
                    //
                    (ll > upper &&
                     bid > upper &&
                     ask > upper)
                    //
                    ;
            }

            //
            if (canReset)
            {
                //
                string message = providerStr + " Conditions Resetted ...";
                Alert(message);

                //
                ClearDraws();
                mTestConditions.Clean();
            }

            //
            result = mTestConditions.IsSetuped();
        }

        //
        // Try to Detect Setting Up Conditions ...
        if (!result)
        {
            //
            // Check has Order Block ...
            bool hasOrderBlock = mTestConditions.HasOrderBlock();
            if (!hasOrderBlock)
            {
                //
                // Detect Order Blocks ...

                //
                // Bullish ...
                bool hasBullishOB = mTestConditions.HasBullishOrderBlock();
                if (!hasBullishOB)
                {
                    //
                    // Bullish ...
                    int bullishOBsCount = visionState.CountBullishOrderBlocks();
                    if (IsValidSize(bullishOBsCount))
                    {
                        //
                        XCOrderBlock *bullishOBs[];
                        for (int i = 0; i < bullishOBsCount; i++)
                        {
                            //
                            XCOrderBlock *iZone = visionState.bullishOrderBlocks[i];

                            //
                            bool isValid = cBar.low > iZone.Upper();
                            if (isValid)
                            {
                                //
                                Add(
                                    iZone,
                                    bullishOBs //
                                );
                            }
                        }

                        //
                        XCOrderBlock *ob = NULL;
                        bullishOBsCount = ArraySize(bullishOBs);
                        if (IsValidSize(bullishOBsCount))
                        {
                            //
                            for (int i = 0; i < bullishOBsCount; i++)
                            {
                                //
                                XCOrderBlock *iZone = bullishOBs[i];

                                //
                                bool isValid = ob == NULL
                                                   ? true
                                                   : ob.Upper() < iZone.Upper();
                                if (isValid)
                                {
                                    ob = iZone;
                                }
                            }
                        }

                        //
                        if (ob != NULL && ob.IsValid())
                        {
                            //
                            mTestConditions.bullishOrderBlock = ob;
                            mTestConditions.bullishOrderBlockTime = TimeCurrent();
                        }
                    }
                }

                //
                // Bearish ...
                bool hasBearishOB = mTestConditions.HasBearishOrderBlock();
                if (!hasBearishOB)
                {
                    //
                    // Bearish ...
                    int bearishOBsCount = visionState.CountBearishOrderBlocks();
                    if (IsValidSize(bearishOBsCount))
                    {
                        //
                        XCOrderBlock *bearishOBs[];
                        for (int i = 0; i < bearishOBsCount; i++)
                        {
                            //
                            XCOrderBlock *iZone = visionState.bearishOrderBlocks[i];

                            //
                            bool isValid = cBar.high < iZone.Lower();
                            if (isValid)
                            {
                                //
                                Add(
                                    iZone,
                                    bearishOBs //
                                );
                            }
                        }

                        //
                        XCOrderBlock *ob = NULL;
                        bearishOBsCount = ArraySize(bearishOBs);
                        if (IsValidSize(bearishOBsCount))
                        {
                            //
                            for (int i = 0; i < bearishOBsCount; i++)
                            {
                                //
                                XCOrderBlock *iZone = bearishOBs[i];

                                //
                                bool isValid = ob == NULL
                                                   ? true
                                                   : ob.Lower() > iZone.Lower();
                                if (isValid)
                                {
                                    ob = iZone;
                                }
                            }
                        }

                        //
                        if (ob != NULL && ob.IsValid())
                        {
                            //
                            mTestConditions.bearishOrderBlock = ob;
                            mTestConditions.bearishOrderBlockTime = TimeCurrent();
                        }
                    }
                }

                //
                hasOrderBlock = mTestConditions.HasOrderBlock();
                result = hasOrderBlock;
                if (!result)
                {
                    return result;
                }
            }
            else
            {
                //
                datetime nearestTime = NULL;

                //
                bool hasBullishOB = mTestConditions.HasBullishOrderBlock();
                if (hasBullishOB)
                {
                    //
                    nearestTime =
                        !IsValid(nearestTime)
                            ? mTestConditions.bullishOrderBlockTime
                        : nearestTime < mTestConditions.bullishOrderBlockTime
                            ? mTestConditions.bullishOrderBlockTime
                            : nearestTime;

                    //
                    mTestConditions.bullishOrderBlock.To(TimeCurrent());
                    XCBullishOrderBlockObject *iObj;
                    bool isCreated = mPOIDrawer.CreateBullishOrderBlock(
                        mTestConditions.bullishOrderBlock,
                        iObj //
                    );
                    if (isCreated)
                    {
                        //
                        iObj.ZoneWidth(4);
                        iObj.ZoneColor(clrAqua);

                        //
                        AddObjectIfNotExists(iObj);
                    }
                }

                //
                bool hasBearishOB = mTestConditions.HasBearishOrderBlock();
                if (hasBearishOB)
                {
                    //
                    nearestTime =
                        !IsValid(nearestTime)
                            ? mTestConditions.bearishOrderBlockTime
                        : nearestTime < mTestConditions.bearishOrderBlockTime
                            ? mTestConditions.bearishOrderBlockTime
                            : nearestTime;

                    //
                    mTestConditions.bearishOrderBlock.To(TimeCurrent());
                    XCBearishOrderBlockObject *iObj;
                    bool isCreated = mPOIDrawer.CreateBearishOrderBlock(
                        mTestConditions.bearishOrderBlock,
                        iObj //
                    );
                    if (isCreated)
                    {
                        //
                        iObj.ZoneWidth(4);
                        iObj.ZoneColor(clrMagenta);

                        //
                        AddObjectIfNotExists(iObj);
                    }
                }

                //
                if (IsValid(nearestTime))
                {
                    //
                    datetime cTime = TimeCurrent();
                    int periodSeconds = PeriodSeconds(period);
                    int passedTime = (int)cTime - (int)nearestTime;

                    //
                    int barsPassed = passedTime / periodSeconds;
                    bool canReset = barsPassed >= validPivotRepetition * 5;
                    if (canReset &&
                        !mTestConditions.isOrderBlockAttacked)
                    {
                        //
                        ClearDraws();
                        mTestConditions.Clean();
                        result = false;

                        //
                        return result;
                    }
                }
            }

            //
            // Check Order Block Attacks ...
            if (!mTestConditions.isOrderBlockAttacked)
            {
                //
                bool isBullishOrderBlockAttacked =
                    //
                    (mTestConditions.HasBullishOrderBlock() &&
                     cBar.high < mTestConditions.bullishOrderBlock.Upper() &&
                     cBar.low > mTestConditions.bullishOrderBlock.Lower())
                    //
                    ;
                bool isBearishOrderBlockAttacked =
                    //
                    (mTestConditions.HasBearishOrderBlock() &&
                     cBar.high < mTestConditions.bearishOrderBlock.Upper() &&
                     cBar.low > mTestConditions.bearishOrderBlock.Lower())
                    //
                    ;
                bool isOrderBlockAttacked = isBullishOrderBlockAttacked ||
                                            isBearishOrderBlockAttacked;
                result = isOrderBlockAttacked;
                if (!result)
                {
                    return result;
                }

                //
                mTestConditions.isOrderBlockAttacked = isOrderBlockAttacked;
            }

            //
            // Other Conditions ...
            bool isNewTriggerPeak = triggerConditions.x121Conditions.isNewPeak;
            bool isNewTriggerVale = triggerConditions.x121Conditions.isNewVale;

            //
            bool isNewPeakInsideBearihOrderBlock =
                //
                isNewTriggerPeak &&
                triggerPeak > mTestConditions.bearishOrderBlock.Lower() &&
                triggerPeak < mTestConditions.bearishOrderBlock.Upper()
                //
                ;

            //
            bool isNewValeInsideBullishOrderBlock =
                //
                isNewTriggerVale &&
                triggerVale > mTestConditions.bullishOrderBlock.Lower() &&
                triggerVale < mTestConditions.bullishOrderBlock.Upper()
                //
                ;

            //
            result = isNewPeakInsideBearihOrderBlock ||
                     isNewValeInsideBullishOrderBlock;
            if (!result)
            {
                return result;
            }

            //
            // Lookig for a Valid Peaks and Vales Formes ...
            // Peaks Inside Bearish Order Block ...
            // Vales inside Bullish Order Block ...

            //
            double triggerPeak = triggerConditions.x121Conditions.peaksBuffer[0];
            double triggerVale = triggerConditions.x121Conditions.valesBuffer[0];

            //
            // Valid Peaks ...
            XPVPivotPoint validPeak;
            XPVPivotPoint peaksChanges[];
            int peaksChangesCount = mTriggerCycleHelper.FillPeakPivotPoints(peaksChanges);
            if (IsValidSize(peaksChangesCount))
            {
                validPeak = peaksChanges[peaksChangesCount - 1];
            }

            //
            // Valid Vales ...
            XPVPivotPoint validVale;
            XPVPivotPoint valesChanges[];
            int valesChangesCount = mTriggerCycleHelper.FillValePivotPoints(valesChanges);
            if (IsValidSize(valesChangesCount))
            {
                validVale = valesChanges[valesChangesCount - 1];
            }

            //
            bool hasValidPeak = (validPeak.IsValid() &&
                                 validPeak.value < mTestConditions.bearishOrderBlock.Upper() &&
                                 validPeak.value > mTestConditions.bearishOrderBlock.Lower());

            //
            bool hasValidVale = (validVale.IsValid() &&
                                 validVale.value < mTestConditions.bullishOrderBlock.Upper() &&
                                 validVale.value > mTestConditions.bullishOrderBlock.Lower());

            //
            result = hasValidPeak ||
                     hasValidVale;
            if (!result)
            {
                return result;
            }

            //
            if (hasValidPeak)
            {
                mTestConditions.validPeak = validPeak;
            }
            if (hasValidVale)
            {
                mTestConditions.validVale = validVale;
            }

            //
            isBullish =
                //
                hasValidVale &&
                isNewValeInsideBullishOrderBlock
                //
                ;

            //
            isBearish =
                //
                hasValidPeak &&
                isNewPeakInsideBearihOrderBlock
                //
                ;

            //
            result = isBullish ||
                     isBearish;
            if (!result)
            {
                return result;
            }

            //
            ENUM_X_DIRECTION setupDir =
                isBullish
                    ? X_DIRECTION_BULLISH
                    : X_DIRECTION_BEARISH;

            //
            mTestConditions.dir = setupDir;
            mTestConditions.setupTime = TimeCurrent();

            //
            // Alert ...
            string message = providerStr + " Conditions Set Upped: " + ToString(mTestConditions.dir);
            Alert(message);
        }

        //
        // Try To Detect Trigger Conditions ...

        //
        // Check Conditions is Prepared for Trigger ...
        result = mTestConditions.CanTrigger();
        if (!result)
        {
            return result;
        }

        //
        // Issues Signal on Conditions ...
        conditions.signalDir = mTestConditions.dir;
        conditions.provider = providerStr;
        conditions.sl = mTestConditions.sl;

        //
        // mTestConditions.Clean();

        //
        return result;
    }


//////////////////////////////////////////////////////////////////////////////////


    /**
     * Detect and Parse Market Conditions for Signalling ...
     *
     * @param  conditions: X121SMCStrategyConditions instance Reference ...
     *
     * @return ( bool )
     */
    bool DetectSamePeaksAndValesSignal(
        X121SMCStrategyConditions &conditions //
    )
    {
        //
        bool result = false;

        //
        string symbol = GetSymbol();
        ENUM_TIMEFRAMES period = GetPeriod();

        //
        ENUM_X_121_SMC_PROVIDERS provider = X_121_SMC_PROVIDER_SMPV;
        string providerStr = ToString(provider);

        //
        int zIndex = 0;
        int cIndex = zIndex + 1;
        int pIndex = cIndex + 1;
        int ppIndex = pIndex + 1;

        //
        XOHCL zBar;
        result = zBar.Init(
            symbol,
            period,
            zIndex //
        );
        if (!result)
        {
            return result;
        }

        //
        XOHCL cBar;
        result = cBar.Init(
            symbol,
            period,
            cIndex //
        );
        if (!result)
        {
            return result;
        }

        //
        string msg = NULL;

        //
        double bid = GetBid(symbol);
        datetime cTime = TimeCurrent();

        //
        double selectedSL = 0;

        //
        // Here We Select Cycles For Conditions Check ...
        ENUM_X_CYCLES cycles[5] = {
            X_CYCLE_TRIGGER,
            X_CYCLE_DECISION,
            X_CYCLE_ANALYSE,
            X_CYCLE_VERIFICATION,
            X_CYCLE_CONSOLIDATION //
        };
        bool hasSamePeaks = DetectSamePeaks(
            cycles,
            conditions //
        );
        bool hasSameVales = DetectSameVales(
            cycles,
            conditions //
        );
        result =
            hasSamePeaks ||
            hasSameVales;
        if (!result)
        {
            return result;
        }

        //
        // Check Peaks And Vales Order ...
        bool hasPeakBreak = false;
        bool hasValeBreak = false;

        //
        // Retrieve Last Sar Change ...
        XOHCL cSarChangeBar;
        XOHCL pSarChangeBar;
        XValueChange cSarChange; // Current Sar Change (IsDirect) ...
        XValueChange pSarChange; // Prev Sar Change (Direct) ...
        XValueChange sarChanges[];
        int sarChangesCount = mTriggerCycleHelper
                                  .FillSarChanges(sarChanges);
        if (IsValidSize(sarChangesCount) &&
            sarChangesCount > 2)
        {
            //
            cSarChange = sarChanges[sarChangesCount - 1];
            pSarChange = sarChanges[sarChangesCount - 2];

            //
            result = cSarChange.FillBar(
                cSarChangeBar,
                symbol,
                period //
            );
            if (!result)
            {
                return result;
            }

            //
            result = pSarChange.FillBar(
                pSarChangeBar,
                symbol,
                period //
            );
            if (!result)
            {
                return result;
            }

            //
            int start = cSarChangeBar.Index();
            int end = pSarChangeBar.Index();
            for (int i = start; i < end; i++)
            {
                //
                ENUM_X_CYCLE_EVENTS iEvents[];
                X121SMCCycleConditions iConditions;
                result = mTriggerCycleHelper.GetConditions(
                    iEvents,
                    iConditions,
                    i //
                );
                if (!result)
                {
                    continue;
                }

                //
                hasPeakBreak =
                    iConditions.x121Conditions.isNewPeakOverLast;
                hasValeBreak =
                    iConditions.x121Conditions.isNewValeUnderLast;
                result = hasPeakBreak ||
                         hasValeBreak;
                if (result)
                {
                    break;
                }
            }
        }
        if (!result)
        {
            return result;
        }

        //
        // Check Sar State ...
        ENUM_X_DIRECTION sarDir;
        result = DetectSarState(
            provider,
            sarDir,
            conditions //
        );
        if (!result)
        {
            return result;
        }

        //
        // Check VWAP State ...
        ENUM_X_DIRECTION vwapDir;
        result = DetectVWapState(
            provider,
            vwapDir,
            conditions //
        );
        if (!result)
        {
            return result;
        }

        //
        // Detect a Valid Peaks Break ...

        //
        // Find Supply and Demand Zones ...
        // XPOIState state = conditions.visionConditions.state;
        // int supplyZonesCount =

        //
        bool isBullish =
            //
            hasSamePeaks &&
            hasPeakBreak &&
            IsBullish(sarDir) &&
            IsBullish(vwapDir)
            //
            ;

        //
        bool isBearish =
            //
            hasSameVales &&
            hasValeBreak &&
            IsBearish(sarDir) &&
            IsBearish(vwapDir)
            //
            ;

        //
        result =
            isBullish ||
            isBearish;
        if (!result)
        {
            return result;
        }

        //
        CustomStateDrawing(
            conditions.visionConditions.state,
            false, //
            X_DIRECTION_NONE,
            false, // ignoreSwingHighs
            false, // ignoreSwingLows
            true,  // ignoreSupportZones
            true,  // ignoreResistanceZones
            false, // ignoreSupplyZones
            false, // ignoreDemandZones
            true,  // ignoreBullishOrderBlocks
            true,  // ignoreBearishOrderBlocks
            true,  // ignoreBullishFairValueGaps
            true,  // ignoreBearishFairValueGaps
            true,  // ignoreBullishRejectionBars
            true,  // ignoreBearishRejectionBars
            true,  // ignoreBullishMomentumBars
            true   // ignoreBearishMomentumBars
        );

        //
        // Set SL, Provider and Direction ...
        conditions.signalDir =
            isBullish
                ? X_DIRECTION_BULLISH
                : X_DIRECTION_BEARISH;
        conditions.provider = providerStr;

        //
        // Selectiong SL ...
        double selectedSLRJ = SelectSL(
            conditions,
            conditions.signalDir,
            X_121_SMC_SL_TYPE_REJECTION //
        );
        double selectedSLMN = SelectSL(
            conditions,
            conditions.signalDir,
            X_121_SMC_SL_TYPE_MOMENTUM //
        );
        double selectedSLSW = SelectSL(
            conditions,
            conditions.signalDir,
            X_121_SMC_SL_TYPE_SWING //
        );
        double selectedSLSR = SelectSL(
            conditions,
            conditions.signalDir,
            X_121_SMC_SL_TYPE_CURRENT_SAR //
        );

        //
        double slCandidates[4] = {
            selectedSLRJ,
            selectedSLMN,
            selectedSLSW,
            selectedSLSR //
        };
        selectedSL = isBullish
                         ? GetMin(slCandidates)
                         : GetMax(slCandidates);

        //
        // Normalizing SL ...
        double entry = GetEntry(
            symbol,
            conditions.signalDir //
        );
        double pip = GetPipPrice(symbol);
        double spread = GetSpread(symbol);
        double points = GetPoints(symbol);

        //
        if (isBullish && selectedSL <= entry)
        {
            selectedSL -= (points * 30) - spread;
        }
        else if (isBearish && selectedSL >= entry)
        {
            selectedSL += (points * 30) + spread;
        }

        //
        // Detect SL and TP ...
        conditions.sl = selectedSL;

        //
        return result;
    }

    /**
     * Detect and Parse Market Conditions for Signalling ...
     *
     * @param  conditions: X121SMCStrategyConditions instance Reference ...
     *
     * @return ( bool )
     */
    bool DetectRJBPVSignal(
        X121SMCStrategyConditions &conditions //
    )
    {
        //
        bool result = false;

        //
        string symbol = GetSymbol();
        ENUM_TIMEFRAMES period = GetPeriod();

        //
        int zIndex = 0;
        int cIndex = zIndex + 1;
        int pIndex = cIndex + 1;
        int ppIndex = pIndex + 1;

        //
        XOHCL zBar;
        result = zBar.Init(
            symbol,
            period,
            zIndex //
        );
        if (!result)
        {
            return result;
        }

        //
        XOHCL cBar;
        result = cBar.Init(
            symbol,
            period,
            cIndex //
        );
        if (!result)
        {
            return result;
        }

        //
        XOHCL pBar;
        result = pBar.Init(
            symbol,
            period,
            pIndex //
        );
        if (!result)
        {
            return result;
        }

        //
        string msg = NULL;

        //
        double bid = GetBid(symbol);
        datetime cTime = TimeCurrent();

        //
        ENUM_X_121_SMC_PROVIDERS provider = X_121_SMC_PROVIDER_RJBPV;
        string providerStr = ToString(provider);

        //
        // Bar High Eqauls to Peaks or Vale ...
        double peak = conditions.triggerConditions.x121Conditions.peaksBuffer[2];
        double vale = conditions.triggerConditions.x121Conditions.valesBuffer[2];
        bool isNewPeak = conditions.triggerConditions.x121Conditions.peaksBuffer[2] != conditions.triggerConditions.x121Conditions.peaksBuffer[3];
        bool isNewVale = conditions.triggerConditions.x121Conditions.valesBuffer[2] != conditions.triggerConditions.x121Conditions.valesBuffer[3];
        bool isClosedUnderDonCloseUpper = cBar.close <
                                          conditions.triggerConditions.x121Conditions.donCloseUpperBuffer[1];
        bool isClosedOverDonCloseLower = cBar.close >
                                         conditions.triggerConditions.x121Conditions.donCloseLowerBuffer[1];
        bool isSarBullish =
            zBar.low > conditions.triggerConditions.x121Conditions.sarBuffer[0];
        bool isSarBearish =
            zBar.high < conditions.triggerConditions.x121Conditions.sarBuffer[0];

        //
        // XPVPivot orderFlow[];
        // ENUM_X_DIRECTION orderFlowDir;
        // mTriggerCycleHelper
        //     .DetectOrderFlow(
        //         zIndex,
        //         orderFlow,
        //         orderFlowDir //
        //     );
        // int pivotsCount = ArraySize(orderFlow);
        // result = IsValidSize(pivotsCount);
        // if (!result)
        // {
        //     return result;
        // }
        // XPVPivot lastPivot = orderFlow[pivotsCount - 1];

        //
        double zoneVerificationDivider = 10;
        bool isPeakInsideSupplyZone = false;
        bool isValeInsideDemandZone = false;

        //
        XPOIState state = conditions.verificationConditions.state;

        // //
        // // Detect Order Block ...
        // XCOrderBlock *orderBlock = NULL;

        // //
        // int bullishOBCount = state.CountBullishOrderBlocks();
        // if (IsValidSize(bullishOBCount))
        // {
        //     //
        //     for (int i = 0; i < bullishOBCount; i++)
        //     {
        //         //
        //         XCOrderBlock *iZone = state.bullishOrderBlocks[i];

        //         //
        //         bool isInside = vale >= iZone.Lower() &&
        //                         vale <= iZone.Upper() &&
        //                         bid <= iZone.Lower() + ((iZone.Upper() - iZone.Lower()) / zoneVerificationDivider);
        //         if (isInside)
        //         {
        //             //
        //             orderBlock = iZone;
        //             break;
        //         }
        //     }
        // }

        // //
        // int bearishOBCount = state.CountBearishOrderBlocks();
        // if (IsValidSize(bearishOBCount))
        // {
        //     //
        //     for (int i = 0; i < bearishOBCount; i++)
        //     {
        //         //
        //         XCOrderBlock *iZone = state.bearishOrderBlocks[i];

        //         //
        //         bool isInside = peak >= iZone.Lower() &&
        //                         peak <= iZone.Upper() &&
        //                         bid >= iZone.Upper() - ((iZone.Upper() - iZone.Lower()) / zoneVerificationDivider);
        //         if (isInside)
        //         {
        //             //
        //             orderBlock = iZone;
        //             break;
        //         }
        //     }
        // }

        // //
        // result = orderBlock != NULL &&
        //          orderBlock.IsValid();
        // if (!result)
        // {
        //     return result;
        // }

        // //
        // // Draw Order Block ...
        // orderBlock.To(TimeCurrent());
        // if (orderBlock.IsBullish())
        // {
        //     //
        //     XCBullishOrderBlockObject *iObj;
        //     bool isCreated = mPOIDrawer.CreateBullishOrderBlock(
        //         orderBlock,
        //         iObj //
        //     );
        //     if (isCreated)
        //     {
        //         AddObjectIfNotExists(iObj);
        //     }
        // }
        // else
        // {
        //     //
        //     XCBearishOrderBlockObject *iObj;
        //     bool isCreated = mPOIDrawer.CreateBearishOrderBlock(
        //         orderBlock,
        //         iObj //
        //     );
        //     if (isCreated)
        //     {
        //         AddObjectIfNotExists(iObj);
        //     }
        // }

        //
        XCSupplyZone *supplyZone;
        int supplyCount = state.CountSupplyZones();
        if (IsValidSize(supplyCount))
        {
            //
            for (int i = 0; i < supplyCount; i++)
            {
                //
                XCSupplyZone *iZone = state.supplyZones[i];
                isPeakInsideSupplyZone = peak >= iZone.Lower() &&
                                         peak <= iZone.Upper() &&
                                         bid >= iZone.Lower() + ((iZone.Upper() - iZone.Lower()) / zoneVerificationDivider);
                if (isPeakInsideSupplyZone)
                {
                    //
                    supplyZone = iZone;
                    break;
                }
            }
        }

        //
        XCDemandZone *demandZone;
        int demandCount = state.CountDemandZones();
        if (IsValidSize(demandCount))
        {
            //
            for (int i = 0; i < demandCount; i++)
            {
                //
                XCDemandZone *iZone = state.demandZones[i];
                isValeInsideDemandZone = vale >= iZone.Lower() &&
                                         vale <= iZone.Upper() &&
                                         bid <= iZone.Lower() + ((iZone.Upper() - iZone.Lower()) / zoneVerificationDivider);
                if (isValeInsideDemandZone)
                {
                    //
                    demandZone = iZone;
                    break;
                }
            }
        }

        //
        bool isPeakAttacked =
            isNewPeak &&
            isSarBearish &&
            pBar.high == peak &&
            isPeakInsideSupplyZone &&
            isClosedUnderDonCloseUpper;

        //
        bool isValeAttacked =
            isNewVale &&
            isSarBullish &&
            pBar.low == vale &&
            isValeInsideDemandZone &&
            isClosedOverDonCloseLower;

        //
        result = isPeakAttacked ||
                 isValeAttacked;
        if (!result)
        {
            return result;
        }

        //
        if (isPeakAttacked)
        {
            //
            supplyZone.To(TimeCurrent());
            XCSupplyZoneObject *iObj;
            bool isCreated = mPOIDrawer.CreateSupplyZone(
                supplyZone,
                iObj //
            );
            if (isCreated)
            {
                AddObjectIfNotExists(iObj);
            }
        }
        else
        {
            //
            demandZone.To(TimeCurrent());
            XCDemandZoneObject *iObj;
            bool isCreated = mPOIDrawer.CreateDemandZone(
                demandZone,
                iObj //
            );
            if (isCreated)
            {
                AddObjectIfNotExists(iObj);
            }
        }

        //
        bool isBullish =
            //
            isValeAttacked
            //
            ;

        //
        bool isBearish =
            //
            isPeakAttacked
            //
            ;

        //
        result =
            //
            isBullish ||
            isBearish
            //
            ;
        if (!result)
        {
            return result;
        }

        //
        // Set SL, Provider and Direction ...
        conditions.signalDir =
            isBullish
                ? X_DIRECTION_BULLISH
                : X_DIRECTION_BEARISH;
        conditions.provider = providerStr;

        //
        conditions.sl =
            isBullish
                ? demandZone.Lower()
                : supplyZone.Upper();

        //
        return result;
    }

    /**
     * Detect and Parse Market Conditions for Signalling ...
     *
     * @param  conditions: X121SMCStrategyConditions instance Reference ...
     *
     * @return ( bool )
     */
    // TODO: Required Calibrate ...
    bool DetectVWAPCSignal(
        X121SMCStrategyConditions &conditions //
    )
    {
        //
        bool result = false;
        return false;

        //
        string symbol = GetSymbol();
        ENUM_TIMEFRAMES period = GetPeriod();

        //
        int zIndex = 0;
        int cIndex = zIndex + 1;
        int pIndex = cIndex + 1;
        int ppIndex = pIndex + 1;

        //
        XOHCL zBar;
        result = zBar.Init(
            symbol,
            period,
            zIndex //
        );
        if (!result)
        {
            return result;
        }

        //
        XOHCL cBar;
        result = cBar.Init(
            symbol,
            period,
            cIndex //
        );
        if (!result)
        {
            return result;
        }

        //
        string msg = NULL;

        //
        double bid = GetBid(symbol);
        datetime cTime = TimeCurrent();

        //
        ENUM_X_121_SMC_PROVIDERS provider = X_121_SMC_PROVIDER_VWAPC;
        string providerStr = ToString(provider);

        //
        // Check Candlestic State ...
        ENUM_X_DIRECTION candlesticDir;
        result = DetectCandlestic(
            provider,
            candlesticDir,
            conditions //
        );
        if (!result)
        {
            return result;
        }

        //
        // Check Sar State ...
        ENUM_X_DIRECTION sarDir;
        result = DetectSarState(
            provider,
            sarDir,
            conditions //
        );
        if (!result)
        {
            return result;
        }

        //
        // Check VWAP State ...
        ENUM_X_DIRECTION vwapDir;
        result = DetectVWapState(
            provider,
            vwapDir,
            conditions //
        );
        if (!result)
        {
            return result;
        }

        //
        bool isBullish =
            //
            IsBullish(sarDir) &&
            IsBullish(vwapDir) &&
            IsBullish(candlesticDir)
            //
            ;

        //
        bool isBearish =
            //
            IsBearish(sarDir) &&
            IsBearish(vwapDir) &&
            IsBearish(candlesticDir)
            //
            ;

        //
        result =
            //
            isBullish ||
            isBearish
            //
            ;

        //
        Print("VWap Signal ...");

        //
        if (!result)
        {
            return result;
        }

        //
        return result;
    }



    /**
     * Detect Where Cycles has Same Peaks ...
     *
     * @param  cycles: ENUM_X_CYCLES members, Array ...
     * @param  conditions: X121SMCStrategyConditions instance, Reference ...
     *
     * @return ( bool )
     */
    bool DetectSamePeaks(
        ENUM_X_CYCLES &cycles[],
        X121SMCStrategyConditions &conditions //
    )
    {
        //
        bool result = false;

        //
        int count = ArraySize(cycles);
        result = IsValidSize(count);
        if (!result)
        {
            return result;
        }

        //
        double value = -1;
        for (int i = 0; i < count; i++)
        {
            //
            ENUM_X_CYCLES iCycle = cycles[i];

            //
            double iValue = -1;
            switch (iCycle)
            {
            //
            case X_CYCLE_TRIGGER:
                iValue = conditions.triggerConditions.x121Conditions.peaksBuffer[0];
                break;

            //
            case X_CYCLE_DECISION:
                iValue = conditions.decisionConditions.x121Conditions.peaksBuffer[0];
                break;

            //
            case X_CYCLE_ANALYSE:
                iValue = conditions.analyseConditions.x121Conditions.peaksBuffer[0];
                break;

            //
            case X_CYCLE_VERIFICATION:
                iValue = conditions.verificationConditions.x121Conditions.peaksBuffer[0];
                break;

            //
            case X_CYCLE_CONSOLIDATION:
                iValue = conditions.consolidationConditions.x121Conditions.peaksBuffer[0];
                break;

            //
            case X_CYCLE_VISION:
                iValue = conditions.visionConditions.x121Conditions.peaksBuffer[0];
                break;
            }

            //
            if (iValue > 0)
            {
                //
                if (value <= 0)
                {
                    value = iValue;
                }

                //
                result = value == iValue;
                if (!result)
                {
                    break;
                }
            }
        }

        //
        return result;
    }

    /**
     * Detect Where Cycles has Same Vales ...
     *
     * @param  cycles: ENUM_X_CYCLES members, Array ...
     * @param  conditions: X121SMCStrategyConditions instance, Reference ...
     *
     * @return ( bool )
     */
    bool DetectSameVales(
        ENUM_X_CYCLES &cycles[],
        X121SMCStrategyConditions &conditions //
    )
    {
        //
        bool result = false;

        //
        int count = ArraySize(cycles);
        result = IsValidSize(count);
        if (!result)
        {
            return result;
        }

        //
        double value = -1;
        for (int i = 0; i < count; i++)
        {
            //
            ENUM_X_CYCLES iCycle = cycles[i];

            //
            double iValue = -1;
            switch (iCycle)
            {
            //
            case X_CYCLE_TRIGGER:
                iValue = conditions.triggerConditions.x121Conditions.valesBuffer[0];
                break;

            //
            case X_CYCLE_DECISION:
                iValue = conditions.decisionConditions.x121Conditions.valesBuffer[0];
                break;

            //
            case X_CYCLE_ANALYSE:
                iValue = conditions.analyseConditions.x121Conditions.valesBuffer[0];
                break;

            //
            case X_CYCLE_VERIFICATION:
                iValue = conditions.verificationConditions.x121Conditions.valesBuffer[0];
                break;

            //
            case X_CYCLE_CONSOLIDATION:
                iValue = conditions.consolidationConditions.x121Conditions.valesBuffer[0];
                break;

            //
            case X_CYCLE_VISION:
                iValue = conditions.visionConditions.x121Conditions.valesBuffer[0];
                break;
            }

            //
            if (iValue > 0)
            {
                //
                if (value <= 0)
                {
                    value = iValue;
                }

                //
                result = value == iValue;
                if (!result)
                {
                    break;
                }
            }
        }

        //
        return result;
    }

    /**
     * Detect Sar State for Signalling ...
     *
     * @param  forProvider: ENUM_X_121_SMC_PROVIDERS member ...
     * @param  dir: ENUM_X_DIRECTION member Reference ...
     * @param  conditions: X121SMCStrategyConditions instance, Reference ...
     *
     * @return ( bool )
     */
    bool DetectSarState(
        ENUM_X_121_SMC_PROVIDERS forProvider,
        ENUM_X_DIRECTION &dir,
        X121SMCStrategyConditions &conditions //
    )
    {
        //
        bool result = false;

        //
        dir = X_DIRECTION_NONE;

        //
        bool isBullish = false;
        bool isBearish = false;

        //
        if (forProvider == X_121_SMC_PROVIDER_SMPV)
        {
            //
            isBullish =
                //
                // Check One of Verification or Consolidation Cycles Must be Sar Bullish ...
                (conditions.verificationConditions.x121Conditions.isSarBullish ||
                 conditions.consolidationConditions.x121Conditions.isSarBullish)
                //
                &&
                //
                // Decision and Analyse Cycles Must be Bullish ...
                (conditions.decisionConditions.x121Conditions.isSarBullish &&
                 conditions.analyseConditions.x121Conditions.isSarBullish)
                //
                &&
                //
                // Trigger State Must be Bearish ...
                conditions.triggerConditions.x121Conditions.isSarBearish
                //
                ;

            //
            isBearish =
                //
                // Check One of Verification or Consolidation Cycles Must be Sar Bearish ...
                (conditions.verificationConditions.x121Conditions.isSarBearish ||
                 conditions.consolidationConditions.x121Conditions.isSarBearish)
                //
                &&
                //
                // Decision and Analyse Cycles Must be Bearish ...
                (conditions.decisionConditions.x121Conditions.isSarBearish &&
                 conditions.analyseConditions.x121Conditions.isSarBearish)
                //
                &&
                //
                // Trigger State Must be Bullish ...
                conditions.triggerConditions.x121Conditions.isSarBullish
                //
                ;
        }

        //
        if (forProvider == X_121_SMC_PROVIDER_RJBPV)
        {
            //
            isBullish =
                //
                // Trigger, Decision and Analyse must be Directional ...
                conditions.triggerConditions.x121Conditions.isSarBullish &&
                conditions.decisionConditions.x121Conditions.isSarBullish &&
                conditions.analyseConditions.x121Conditions.isSarBullish
                //
                ;

            //
            isBearish =
                //
                // Trigger, Decision and Analyse must be Directional ...
                conditions.triggerConditions.x121Conditions.isSarBearish &&
                conditions.decisionConditions.x121Conditions.isSarBearish &&
                conditions.analyseConditions.x121Conditions.isSarBearish
                //
                ;
        }

        //
        if (forProvider == X_121_SMC_PROVIDER_VWAPC)
        {
            //
            isBullish =
                //
                // All Cycles Sars Must be Directional exept Vision ...
                conditions.triggerConditions.x121Conditions.isSarBullish &&
                conditions.decisionConditions.x121Conditions.isSarBullish &&
                conditions.analyseConditions.x121Conditions.isSarBullish &&
                conditions.verificationConditions.x121Conditions.isSarBullish &&
                conditions.consolidationConditions.x121Conditions.isSarBullish
                //
                ;

            //
            isBearish =
                //
                // All Cycles Sars Must be Directional exept Vision ...
                conditions.triggerConditions.x121Conditions.isSarBearish &&
                conditions.decisionConditions.x121Conditions.isSarBearish &&
                conditions.analyseConditions.x121Conditions.isSarBearish &&
                conditions.verificationConditions.x121Conditions.isSarBearish &&
                conditions.consolidationConditions.x121Conditions.isSarBearish
                //
                ;
        }

        //
        result = isBullish ||
                 isBearish;
        if (!result)
        {
            return result;
        }

        //
        dir =
            isBullish
                ? X_DIRECTION_BULLISH
                : X_DIRECTION_BEARISH;

        //
        return result;
    }

    /**
     * Detect Sar State for Signalling ...
     *
     * @param  forProvider: ENUM_X_121_SMC_PROVIDERS member ...
     * @param  dir: ENUM_X_DIRECTION member Reference ...
     * @param  conditions: X121SMCStrategyConditions instance, Reference ...
     *
     * @return ( bool )
     */
    bool DetectVWapState(
        ENUM_X_121_SMC_PROVIDERS forProvider,
        ENUM_X_DIRECTION &dir,
        X121SMCStrategyConditions &conditions //
    )
    {
        //
        bool result = false;

        //
        dir = X_DIRECTION_NONE;

        //
        bool isBullish = false;
        bool isBearish = false;

        //
        if (forProvider == X_121_SMC_PROVIDER_SMPV)
        {
            //
            isBullish =
                //
                // Trigger, Decision and Analyse Cycles Must be in Direction Order and State ...
                //
                // Orders ...
                (conditions.triggerConditions.x121Conditions.isVWapBullishOrdered &&
                 conditions.decisionConditions.x121Conditions.isVWapBullishOrdered &&
                 conditions.analyseConditions.x121Conditions.isVWapBullishOrdered)
                //
                &&
                //
                // State ...
                (conditions.triggerConditions.x121Conditions.isVWapBullishState &&
                 conditions.decisionConditions.x121Conditions.isVWapBullishState &&
                 conditions.analyseConditions.x121Conditions.isVWapBullishState)
                //
                &&
                //
                // One of Verification and Consolidation must Be in Direction State ...
                (conditions.verificationConditions.x121Conditions.isVWapBullishState ||
                 conditions.consolidationConditions.x121Conditions.isVWapBullishState)
                //
                ;

            //
            isBearish =
                //
                // Trigger, Decision and Analyse Cycles Must be in Direction Order and State ...
                //
                // Orders ...
                (conditions.triggerConditions.x121Conditions.isVWapBearishOrdered &&
                 conditions.decisionConditions.x121Conditions.isVWapBearishOrdered &&
                 conditions.analyseConditions.x121Conditions.isVWapBearishOrdered)
                //
                &&
                //
                // State ...
                (conditions.triggerConditions.x121Conditions.isVWapBearishState &&
                 conditions.decisionConditions.x121Conditions.isVWapBearishState &&
                 conditions.analyseConditions.x121Conditions.isVWapBearishState)
                //
                &&
                //
                // One of Verification and Consolidation must Be in Direction State ...
                (conditions.verificationConditions.x121Conditions.isVWapBearishState ||
                 conditions.consolidationConditions.x121Conditions.isVWapBearishState)
                //
                ;
        }

        //
        if (forProvider == X_121_SMC_PROVIDER_VWAPC)
        {
            //
            isBullish =
                //
                // All Cycles Must be State and Ordered Directional Except Vision ...
                // State ...
                conditions.triggerConditions.x121Conditions.isVWapBullishState &&
                conditions.decisionConditions.x121Conditions.isVWapBullishState &&
                conditions.analyseConditions.x121Conditions.isVWapBullishState &&
                conditions.verificationConditions.x121Conditions.isVWapBullishState &&
                conditions.consolidationConditions.x121Conditions.isVWapBullishState
                //
                &&
                // Order ...
                conditions.triggerConditions.x121Conditions.isVWapBullishOrdered &&
                conditions.decisionConditions.x121Conditions.isVWapBullishOrdered &&
                conditions.analyseConditions.x121Conditions.isVWapBullishOrdered &&
                conditions.verificationConditions.x121Conditions.isVWapBullishOrdered &&
                conditions.consolidationConditions.x121Conditions.isVWapBullishOrdered
                //
                ;

            //
            isBearish =
                //
                // All Cycles Must be State and Ordered Directional Except Vision ...
                // State ...
                conditions.triggerConditions.x121Conditions.isVWapBearishState &&
                conditions.decisionConditions.x121Conditions.isVWapBearishState &&
                conditions.analyseConditions.x121Conditions.isVWapBearishState &&
                conditions.verificationConditions.x121Conditions.isVWapBearishState &&
                conditions.consolidationConditions.x121Conditions.isVWapBearishState
                //
                &&
                // Order ...
                conditions.triggerConditions.x121Conditions.isVWapBearishOrdered &&
                conditions.decisionConditions.x121Conditions.isVWapBearishOrdered &&
                conditions.analyseConditions.x121Conditions.isVWapBearishOrdered &&
                conditions.verificationConditions.x121Conditions.isVWapBearishOrdered &&
                conditions.consolidationConditions.x121Conditions.isVWapBearishOrdered
                //
                ;
        }

        //
        result = isBullish ||
                 isBearish;
        if (!result)
        {
            return result;
        }

        //
        dir =
            isBullish
                ? X_DIRECTION_BULLISH
                : X_DIRECTION_BEARISH;

        //
        return result;
    }

    /**
     * Detect Candlestic Patters for Signalling ...
     *
     * @param  forProvider: ENUM_X_121_SMC_PROVIDERS member ...
     * @param  dir: ENUM_X_DIRECTION member Reference ...
     * @param  conditions: X121SMCStrategyConditions instance, Reference ...
     *
     * @return ( bool )
     */
    bool DetectCandlestic(
        ENUM_X_121_SMC_PROVIDERS forProvider,
        ENUM_X_DIRECTION &dir,
        X121SMCStrategyConditions &conditions //
    )
    {
        //
        bool result = false;

        //
        dir = X_DIRECTION_NONE;

        //
        int cIndex = 1;
        int pIndex = cIndex + 1;

        //
        // Select Specified Cycle Helper ...
        XC121SMCCycleHelper *cycleHelper = mTriggerCycleHelper;

        //
        string symbol = GetSymbol();
        ENUM_TIMEFRAMES period = cycleHelper.GetPeriod();

        //
        XOHCL cBar;
        result = cBar.Init(
            symbol,
            period,
            cIndex //
        );
        if (!result)
        {
            return result;
        }

        //
        // Momentum Bar ...
        ENUM_X_DIRECTION cBarMomentumDir;
        bool isCBarMomentum = cycleHelper.mBarAnalyser.IsMomentumBar(
            cBar,
            cBarMomentumDir //
        );

        //
        // Rejection Bar ...
        ENUM_X_DIRECTION cBarRejectionDir;
        bool isCBarRejection = cycleHelper.mBarAnalyser.IsRejectionBar(
            cBar,
            cBarRejectionDir //
        );

        //
        // Engulf Bar ...
        ENUM_X_DIRECTION cBarEngulfDir;
        bool isCBarEngulf = cycleHelper.mBarAnalyser.IsEngulfBar(
            cBar,
            cBarEngulfDir //
        );

        //
        // Pin Bar ...
        ENUM_X_DIRECTION cBarPinDir;
        bool isCBarPin = cycleHelper.mBarAnalyser.IsPinBar(
            cBar,
            cBarPinDir //
        );

        //
        XOHCL pBar;
        result = pBar.Init(
            symbol,
            period,
            pIndex //
        );
        if (!result)
        {
            return result;
        }

        //
        // Momentum Bar ...
        ENUM_X_DIRECTION pBarMomentumDir;
        bool isPBarMomentum = cycleHelper.mBarAnalyser.IsMomentumBar(
            pBar,
            pBarMomentumDir //
        );

        //
        // Rejection Bar ...
        ENUM_X_DIRECTION pBarRejectionDir;
        bool isPBarRejection = cycleHelper.mBarAnalyser.IsRejectionBar(
            pBar,
            pBarRejectionDir //
        );

        //
        // Engulf Bar ...
        ENUM_X_DIRECTION pBarEngulfDir;
        bool isPBarEngulf = cycleHelper.mBarAnalyser.IsEngulfBar(
            pBar,
            pBarEngulfDir //
        );

        //
        // Pin Bar ...
        ENUM_X_DIRECTION pBarPinDir;
        bool isPBarPin = cycleHelper.mBarAnalyser.IsPinBar(
            pBar,
            pBarPinDir //
        );

        //
        bool isBullish = false;
        bool isBearish = false;

        //
        if (forProvider == X_121_SMC_PROVIDER_VWAPC)
        {
            //
            isBullish =
                //
                // pBar is Pin and cBar is Momentum or Rejection or Engulf
                (
                    //
                    (isPBarPin &&
                     IsBullish(pBarPinDir) &&
                     (
                         //
                         (isCBarMomentum &&
                          IsBullish(cBarMomentumDir))
                         //
                         ||
                         //
                         (isCBarRejection &&
                          IsBullish(cBarRejectionDir))
                         //
                         ||
                         //
                         (isCBarEngulf &&
                          IsBullish(cBarEngulfDir))
                         //
                         )
                     //
                     )
                    //
                    ||
                    //
                    // pBar is Engulf and cBar is Momentum or Rejection or Pin ...
                    (isPBarEngulf &&
                     IsBullish(pBarEngulfDir) &&
                     (
                         //
                         (isCBarMomentum &&
                          IsBullish(cBarMomentumDir))
                         //
                         ||
                         //
                         (isCBarRejection &&
                          IsBullish(cBarRejectionDir))
                         //
                         ||
                         //
                         (isCBarPin &&
                          IsBullish(cBarPinDir))
                         //
                         )
                     //
                     )
                    //
                    ||
                    //
                    // pBar is Rejection and cBar is Momentum or Engulf or Pin ...
                    (isPBarRejection &&
                     IsBullish(pBarRejectionDir) &&
                     (
                         //
                         (isCBarMomentum &&
                          IsBullish(cBarMomentumDir))
                         //
                         ||
                         //
                         (isCBarEngulf &&
                          IsBullish(cBarEngulfDir))
                         //
                         ||
                         //
                         (isCBarPin &&
                          IsBullish(cBarPinDir))
                         //
                         )
                     //
                     )
                    //
                    ||
                    //
                    // pBar is Momentum and cBar is Rejection or Engulf or Pin ...
                    (isPBarMomentum &&
                     IsBullish(pBarMomentumDir) &&
                     (
                         //
                         (isCBarRejection &&
                          IsBullish(cBarRejectionDir))
                         //
                         ||
                         //
                         (isCBarEngulf &&
                          IsBullish(cBarEngulfDir))
                         //
                         ||
                         //
                         (isCBarPin &&
                          IsBullish(cBarPinDir))
                         //
                         )
                     //
                     )
                    //
                    ||
                    //
                    // cBar is Pin and Momentum and Rejection and Engulf ...
                    (
                        //
                        (isCBarPin &&
                         IsBullish(cBarPinDir))
                        //
                        &&
                        //
                        (isCBarMomentum &&
                         IsBullish(cBarMomentumDir))
                        //
                        &&
                        //
                        (isCBarRejection &&
                         IsBullish(cBarRejectionDir))
                        //
                        &&
                        //
                        (isCBarEngulf &&
                         IsBullish(cBarEngulfDir))
                        //
                        )
                    //
                    )
                //
                ;

            //
            isBearish =
                //
                // pBar is Pin and cBar is Momentum or Rejection or Engulf
                (
                    //
                    (isPBarPin &&
                     IsBearish(pBarPinDir) &&
                     (
                         //
                         (isCBarMomentum &&
                          IsBearish(cBarMomentumDir))
                         //
                         ||
                         //
                         (isCBarRejection &&
                          IsBearish(cBarRejectionDir))
                         //
                         ||
                         //
                         (isCBarEngulf &&
                          IsBearish(cBarEngulfDir))
                         //
                         )
                     //
                     )
                    //
                    ||
                    //
                    // pBar is Engulf and cBar is Momentum or Rejection or Pin ...
                    (isPBarEngulf &&
                     IsBearish(pBarEngulfDir) &&
                     (
                         //
                         (isCBarMomentum &&
                          IsBearish(cBarMomentumDir))
                         //
                         ||
                         //
                         (isCBarRejection &&
                          IsBearish(cBarRejectionDir))
                         //
                         ||
                         //
                         (isCBarPin &&
                          IsBearish(cBarPinDir))
                         //
                         )
                     //
                     )
                    //
                    ||
                    //
                    // pBar is Rejection and cBar is Momentum or Engulf or Pin ...
                    (isPBarRejection &&
                     IsBearish(pBarRejectionDir) &&
                     (
                         //
                         (isCBarMomentum &&
                          IsBearish(cBarMomentumDir))
                         //
                         ||
                         //
                         (isCBarEngulf &&
                          IsBearish(cBarEngulfDir))
                         //
                         ||
                         //
                         (isCBarPin &&
                          IsBearish(cBarPinDir))
                         //
                         )
                     //
                     )
                    //
                    ||
                    //
                    // pBar is Momentum and cBar is Rejection or Engulf or Pin ...
                    (isPBarMomentum &&
                     IsBearish(pBarMomentumDir) &&
                     (
                         //
                         (isCBarRejection &&
                          IsBearish(cBarRejectionDir))
                         //
                         ||
                         //
                         (isCBarEngulf &&
                          IsBearish(cBarEngulfDir))
                         //
                         ||
                         //
                         (isCBarPin &&
                          IsBearish(cBarPinDir))
                         //
                         )
                     //
                     )
                    //
                    ||
                    //
                    // cBar is Pin and Momentum and Rejection and Engulf ...
                    (
                        //
                        (isCBarPin &&
                         IsBearish(cBarPinDir))
                        //
                        &&
                        //
                        (isCBarMomentum &&
                         IsBearish(cBarMomentumDir))
                        //
                        &&
                        //
                        (isCBarRejection &&
                         IsBearish(cBarRejectionDir))
                        //
                        &&
                        //
                        (isCBarEngulf &&
                         IsBearish(cBarEngulfDir))
                        //
                        )
                    //
                    )
                //
                ;
        }

        //
        if (forProvider == X_121_SMC_PROVIDER_RJBPV)
        {
            //
            isBullish =
                //
                // CBar is Pin, Engulf, Momentum or Rejection ...
                (
                    // //
                    // (isCBarMomentum &&
                    //  IsBullish(cBarMomentumDir))
                    // //
                    // ||
                    // //
                    (isCBarRejection &&
                     IsBullish(cBarRejectionDir))
                    // //
                    // ||
                    // //
                    // (isCBarEngulf &&
                    //  IsBullish(cBarEngulfDir))
                    //
                    ||
                    //
                    (isCBarPin &&
                     IsBullish(cBarPinDir))
                    //
                    )
                //
                ;

            //
            isBearish =
                //
                // CBar is Pin, Engulf, Momentum or Rejection ...
                (
                    //
                    // (isCBarMomentum &&
                    //  IsBearish(cBarMomentumDir))
                    // //
                    // ||
                    // //
                    (isCBarRejection &&
                     IsBearish(cBarRejectionDir))
                    // //
                    // ||
                    // //
                    // (isCBarEngulf &&
                    //  IsBearish(cBarEngulfDir))
                    //
                    ||
                    //
                    (isCBarPin &&
                     IsBearish(cBarPinDir))
                    //
                    )
                //
                ;
        }

        //
        result = isBullish ||
                 isBearish;
        if (!result)
        {
            return result;
        }

        //
        dir =
            isBullish
                ? X_DIRECTION_BULLISH
                : X_DIRECTION_BEARISH;

        //
        return result;
    }

////////////////////////////////////////////////////////////////////////////////////

    //
    // TODO: Remove this ...
    XSMCStrategySetupConditions mTestConditions;
    bool DetectTestSignal(
        X121SMCStrategyConditions &conditions //
    )
    {
        //
        bool result = false;

        //
        string symbol = GetSymbol();
        ENUM_TIMEFRAMES period = GetPeriod();

        //
        ENUM_X_121_SMC_PROVIDERS provider = X_121_SMC_PROVIDER_SMPV;
        string providerStr = ToString(provider);

        //
        int zIndex = 0;
        int cIndex = zIndex + 1;
        int pIndex = cIndex + 1;
        int ppIndex = pIndex + 1;

        //
        XOHCL zBar;
        result = zBar.Init(
            symbol,
            period,
            zIndex //
        );
        if (!result)
        {
            return result;
        }

        //
        XOHCL cBar;
        result = cBar.Init(
            symbol,
            period,
            cIndex //
        );
        if (!result)
        {
            return result;
        }

        //
        bool isBullish = false;
        bool isBearish = false;

        //
        double ask = GetAsk(symbol);
        double bid = GetBid(symbol);
        datetime cTime = TimeCurrent();

        //
        double ll = cBar.FindLowest(9, MODE_LOW);
        double hh = cBar.FindHighest(9, MODE_HIGH);

        //
        double selectedSL = 0;

        //
        // Retrieve Peak and Vale ...
        double triggerPeak = conditions.triggerConditions.x121Conditions.peaksBuffer[0];
        double triggerVale = conditions.triggerConditions.x121Conditions.valesBuffer[0];

        //
        X121SMCCycleConditions triggerConditions = conditions.triggerConditions;
        X121SMCCycleConditions decisionConditions = conditions.decisionConditions;
        X121SMCCycleConditions analyseConditions = conditions.analyseConditions;
        X121SMCCycleConditions verificationConditions = conditions.verificationConditions;
        X121SMCCycleConditions consolidationConditions = conditions.consolidationConditions;
        X121SMCCycleConditions visionConditions = conditions.visionConditions;

        //
        XPOIState triggerState = triggerConditions.state;
        XPOIState decisionState = decisionConditions.state;
        XPOIState analyseState = analyseConditions.state;
        XPOIState verificationState = verificationConditions.state;
        XPOIState consolidationState = consolidationConditions.state;
        XPOIState visionState = visionConditions.state;

        //
        int zoneValidationDivider = 10;
        int validPivotRepetition = mTriggerCycleHelper.mX121Helper
                                       .GetDonChainLength();

        //
        // Waits For Bullish Or Bearish Order Block Forms ...
        bool hasBullishOB = mTestConditions.HasBullishOrderBlock();
        bool hasBearishOB = mTestConditions.HasBearishOrderBlock();
        result = mTestConditions.HasOrderBlock();
        if (!result)
        {
            //
            // Try to Detect Order Blocks ...
            XPOIState state = consolidationState;

            //
            // Bullish ...
            if (!hasBullishOB)
            {
                //
                // Bullish ...
                int bullishOBsCount = state.CountBullishOrderBlocks();
                if (IsValidSize(bullishOBsCount))
                {
                    //
                    XCFVG *fvg = NULL;
                    XCOrderBlock *ob = NULL;
                    XCOrderBlock *bullishOBs[];
                    for (int i = 0; i < bullishOBsCount; i++)
                    {
                        //
                        XCOrderBlock *iZone = state.bullishOrderBlocks[i];

                        //
                        bool isValid = cBar.low > iZone.Upper() &&
                                       HasValidBullishFVG(
                                           analyseState,
                                           iZone,
                                           fvg,
                                           cBar //
                                       );
                        if (isValid)
                        {
                            //
                            Add(
                                iZone,
                                bullishOBs //
                            );
                        }
                    }

                    //
                    bullishOBsCount = ArraySize(bullishOBs);
                    if (IsValidSize(bullishOBsCount))
                    {
                        //
                        for (int i = 0; i < bullishOBsCount; i++)
                        {
                            //
                            XCOrderBlock *iZone = bullishOBs[i];

                            //
                            bool isValid = ob == NULL
                                               ? true
                                               : ob.Upper() < iZone.Upper();
                            if (isValid)
                            {
                                ob = iZone;
                            }
                        }
                    }

                    //
                    if (
                        ob != NULL &&
                        fvg != NULL &&
                        ob.IsValid() &&
                        fvg.IsValid())
                    {
                        //
                        mTestConditions.bullishFVG = fvg;
                        mTestConditions.bullishFVGTime = cTime;
                        mTestConditions.bullishOrderBlock = ob;
                        mTestConditions.bullishOrderBlockTime = cTime;
                    }
                }
            }

            //
            // Bearish ...
            if (!hasBearishOB)
            {
                //
                // Bearish ...
                int bearishOBsCount = state.CountBearishOrderBlocks();
                if (IsValidSize(bearishOBsCount))
                {
                    //
                    XCFVG *fvg = NULL;
                    XCOrderBlock *ob = NULL;
                    XCOrderBlock *bearishOBs[];
                    for (int i = 0; i < bearishOBsCount; i++)
                    {
                        //
                        XCOrderBlock *iZone = state.bearishOrderBlocks[i];

                        //
                        bool isValid = cBar.high < iZone.Lower() &&
                                       HasValidBearishFVG(
                                           analyseState,
                                           iZone,
                                           fvg,
                                           cBar //
                                       );
                        if (isValid)
                        {
                            //
                            Add(
                                iZone,
                                bearishOBs //
                            );
                        }
                    }

                    //
                    bearishOBsCount = ArraySize(bearishOBs);
                    if (IsValidSize(bearishOBsCount))
                    {
                        //
                        for (int i = 0; i < bearishOBsCount; i++)
                        {
                            //
                            XCOrderBlock *iZone = bearishOBs[i];

                            //
                            bool isValid = ob == NULL
                                               ? true
                                               : ob.Lower() > iZone.Lower();
                            if (isValid)
                            {
                                ob = iZone;
                            }
                        }
                    }

                    //
                    if (
                        ob != NULL &&
                        fvg != NULL &&
                        ob.IsValid() &&
                        fvg.IsValid())
                    {
                        //
                        mTestConditions.bearishFVG = fvg;
                        mTestConditions.bearishFVGTime = cTime;
                        mTestConditions.bearishOrderBlock = ob;
                        mTestConditions.bearishOrderBlockTime = cTime;
                    }
                }
            }

            //
            hasBullishOB = mTestConditions.HasBullishOrderBlock();
            hasBearishOB = mTestConditions.HasBearishOrderBlock();
            result = mTestConditions.HasOrderBlock();
            if (!result)
            {
                return result;
            }
        }

        //
        // Renew and Draw Order Blocks ...

        //
        if (hasBullishOB)
        {
            //
            mTestConditions.bullishFVG.To(cTime);
            mTestConditions.bullishOrderBlock.To(cTime);

            //
            XCBullishOrderBlockObject *iOBObj;
            bool isCreated = mPOIDrawer.CreateBullishOrderBlock(
                mTestConditions.bullishOrderBlock,
                iOBObj //
            );
            if (isCreated)
            {
                //
                iOBObj.ZoneWidth(4);
                iOBObj.ZoneColor(clrAqua);

                //
                AddObjectIfNotExists(iOBObj);
            }

            //
            XCBullishFairValueGapObject *iFVGObj;
            isCreated = mPOIDrawer.CreateBullishFairValueGap(
                mTestConditions.bullishFVG,
                iFVGObj //
            );
            if (isCreated)
            {
                //
                iFVGObj.ZoneWidth(4);

                //
                AddObjectIfNotExists(iFVGObj);
            }
        }

        //
        if (hasBearishOB)
        {
            //
            mTestConditions.bearishFVG.To(cTime);
            mTestConditions.bearishOrderBlock.To(cTime);

            //
            XCBearishOrderBlockObject *iObj;
            bool isCreated = mPOIDrawer.CreateBearishOrderBlock(
                mTestConditions.bearishOrderBlock,
                iObj //
            );
            if (isCreated)
            {
                //
                iObj.ZoneWidth(4);
                iObj.ZoneColor(clrMagenta);

                //
                AddObjectIfNotExists(iObj);
            }

            //
            XCBearishFairValueGapObject *iFVGObj;
            isCreated = mPOIDrawer.CreateBearishFairValueGap(
                mTestConditions.bearishFVG,
                iFVGObj //
            );
            if (isCreated)
            {
                //
                iFVGObj.ZoneWidth(4);

                //
                AddObjectIfNotExists(iFVGObj);
            }
        }

        //
        // Here we Make Sure we Have Valid Order Blocks ...
        // we have to Validate Order Block Attacks ...
        bool isBullishOBAttacked = mTestConditions.isBullishOrderBlockAttacked;
        bool isBearishOBAttacked = mTestConditions.isBearishOrderBlockAttacked;
        result = mTestConditions.IsOrderBlockAttacked();
        if (!result)
        {
            //
            // Detect Order Blocks Attack ...

            //
            // Bullish Order Block ...
            XCOrderBlock *bullishOb = mTestConditions.bullishOrderBlock;
            isBullishOBAttacked =
                //
                bullishOb.IsValid() &&
                cBar.high <= bullishOb.Upper() &&
                cBar.low >= bullishOb.Lower()
                //
                ;
            if (!isBullishOBAttacked)
            {
                //
                // Try to Reset Bullish Ob if Needed ...
                int timePassed = (int)cTime - (int)mTestConditions.bullishOrderBlockTime;
                int barsPassed = timePassed / PeriodSeconds(period);
                bool canReset = barsPassed >= validPivotRepetition * 10;
                if (canReset)
                {
                    //
                    ClearDraws();
                    mTestConditions.ResetBullishOrderBlock();
                }
            }

            //
            // Bearish Order Block ...
            XCOrderBlock *bearishOb = mTestConditions.bearishOrderBlock;
            isBearishOBAttacked =
                //
                bearishOb.IsValid() &&
                cBar.high <= bearishOb.Upper() &&
                cBar.low >= bearishOb.Lower()
                //
                ;
            if (!isBearishOBAttacked)
            {
                //
                // Try to Reset Bullish Ob if Needed ...
                int timePassed = (int)cTime - (int)mTestConditions.bearishOrderBlockTime;
                int barsPassed = timePassed / PeriodSeconds(period);
                bool canReset = barsPassed >= validPivotRepetition * 10;
                if (canReset)
                {
                    //
                    ClearDraws();
                    mTestConditions.ResetBearishOrderBlock();
                }
            }

            //
            bool isOrderBlockAttacked = isBullishOBAttacked ||
                                        isBearishOBAttacked;
            if (isOrderBlockAttacked)
            {
                //
                if (isBullishOBAttacked)
                {
                    mTestConditions.isBullishOrderBlockAttacked = isBullishOBAttacked;
                }

                //
                if (isBearishOBAttacked)
                {
                    mTestConditions.isBearishOrderBlockAttacked = isBearishOBAttacked;
                }
            }

            //
            result = mTestConditions.IsOrderBlockAttacked();
            if (!result)
            {
                return result;
            }
        }

        //
        // Detect Analyse State FVG ...

        //
        // here We Make Sure Order Block is ttacked Before ...
        // Loockup For Zone Break ...
        bool isBullishOrderBlockBreaked = false;
        bool isBearishOrderBlockBreaked = false;
        if (isBullishOBAttacked)
        {
            //
            isBullishOrderBlockBreaked =
                //
                mTestConditions.HasBullishOrderBlock()
                //
                &&
                //
                (
                    //
                    // Break From Bottom to Top ...
                    (ll < mTestConditions.bullishOrderBlock.Upper() &&
                     hh > mTestConditions.bullishOrderBlock.Upper())
                    //
                    ||
                    //
                    // Break From Top to Bottom ...
                    (hh > mTestConditions.bullishOrderBlock.Lower() &&
                     ll < mTestConditions.bullishOrderBlock.Lower())
                    //
                    )
                //
                ;
        }
        if (isBearishOBAttacked)
        {
            //
            isBearishOrderBlockBreaked =
                //
                mTestConditions.HasBearishOrderBlock()
                //
                &&
                //
                (
                    //
                    // Break From Bottom to Top ...
                    (ll < mTestConditions.bearishOrderBlock.Upper() &&
                     hh > mTestConditions.bearishOrderBlock.Upper())
                    //
                    ||
                    //
                    // Break From Top to Bottom ...
                    (hh > mTestConditions.bearishOrderBlock.Lower() &&
                     ll < mTestConditions.bearishOrderBlock.Lower())
                    //
                    )
                //
                ;
        }

        //
        bool isOrderBlockBreaked = isBullishOrderBlockBreaked ||
                                   isBearishOrderBlockBreaked;
        if (isOrderBlockBreaked)
        {
            //
            // Clean Order Block ...

            //
            if (isBullishOrderBlockBreaked)
            {
                //
                ClearDraws();
                mTestConditions.ResetBullishOrderBlock();
            }

            //
            if (isBearishOrderBlockBreaked)
            {
                //
                ClearDraws();
                mTestConditions.ResetBearishOrderBlock();
            }
        }
        result = !isOrderBlockBreaked;
        if (!result)
        {
            return result;
        }

        //
        // Try to Getting Setup Conditions ...

        //
        // Check Setting Upped ...
        result = mTestConditions.IsSetuped();
        if (!result)
        {
            return result;
        }

        //
        // Try To Detect Trigger Conditions ...

        //
        // Check Conditions is Prepared for Trigger ...
        result = mTestConditions.CanTrigger();
        if (!result)
        {
            return result;
        }

        //
        // Issues Signal on Conditions ...
        conditions.signalDir = mTestConditions.dir;
        conditions.provider = providerStr;
        conditions.sl = mTestConditions.sl;

        //
        mTestConditions.Clean();

        //
        return result;
    }

    //
    // Helper Functions ...

    /**
     * Detect Valid Order Block's FVG ...
     *
     * @return ( bool )
     */
    bool HasValidBullishFVG(
        XPOIState &state,
        XCOrderBlock *ob,
        XCFVG *&fvg,
        XOHCL &bar //
    )
    {
        //
        bool result = false;

        //
        fvg = NULL;

        //
        // Validate ...
        result =
            //
            ob != NULL &&
            bar.IsValid() &&
            state.IsValid() &&
            ob.IsBullish() &&
            state.HasChild()
            //
            ;
        if (!result)
        {
            return result;
        }

        //
        // Counting FVGs ...
        int count = state.CountBullishFairValueGaps();
        result = IsValidSize(count);
        if (!result)
        {
            return result;
        }

        //
        for (int i = 0; i < count; i++)
        {
            //
            XCFVG *iFVG = state.bullishFairValueGaps[i];

            //
            bool isValid =
                //
                // Must be Happens After Order Block ...
                iFVG.From() > ob.From()
                //
                &&
                //
                // Must Happens Inside or Boundary of Order Blocks ...
                iFVG.Lower() > ob.Lower() &&
                iFVG.Lower() < ob.Upper()
                //
                // &&
                //
                // Must Not Touched till bar ...
                //
                ;
            if (isValid)
            {
                //
                bool canSet = fvg == NULL;
                if (canSet)
                {
                    //
                    fvg = iFVG;
                    break;
                }
            }
        }

        //
        return result;
    }

    /**
     * Detect Valid Order Block's FVG ...
     *
     * @return ( bool )
     */
    bool HasValidBearishFVG(
        XPOIState &state,
        XCOrderBlock *ob,
        XCFVG *&fvg,
        XOHCL &bar //
    )
    {
        //
        bool result = false;

        //
        fvg = NULL;

        //
        // Validate ...
        result =
            //
            ob != NULL &&
            bar.IsValid() &&
            state.IsValid() &&
            ob.IsBearish() &&
            state.HasChild()
            //
            ;
        if (!result)
        {
            return result;
        }

        //
        // Counting FVGs ...
        int count = state.CountBearishFairValueGaps();
        result = IsValidSize(count);
        if (!result)
        {
            return result;
        }

        //
        for (int i = 0; i < count; i++)
        {
            //
            XCFVG *iFVG = state.bearishFairValueGaps[i];

            //
            bool isValid =
                //
                // Must be Happens After Order Block ...
                iFVG.From() > ob.From()
                //
                &&
                //
                // Must Happens Inside or Boundary of Order Blocks ...
                iFVG.Upper() < ob.Upper() &&
                iFVG.Upper() > ob.Lower()
                //
                // &&
                //
                // Must Not Touched till bar ...
                //
                ;
            if (isValid)
            {
                //
                bool canSet = fvg == NULL;
                if (canSet)
                {
                    //
                    fvg = iFVG;
                    break;
                }
            }
        }

        //
        return result;
    }

struct XSMCStrategySetupConditions
{
    //
    // Props ...

    //
    string symbol;
    ENUM_TIMEFRAMES period;

    //
    double sl;
    ENUM_X_DIRECTION dir;
    ENUM_X_POSITION_TYPES type;

    //
    // Setup Props ...

    //
    datetime setupTime;
    datetime triggerTime;

    //
    datetime bullishOrderBlockTime;
    XCOrderBlock *bullishOrderBlock;
    bool isBullishOrderBlockAttacked;

    //
    datetime bearishOrderBlockTime;
    XCOrderBlock *bearishOrderBlock;
    bool isBearishOrderBlockAttacked;

    //
    datetime bullishFVGTime;
    XCFVG *bullishFVG;
    bool isBullishFVGRejected;

    //
    datetime bearishFVGTime;
    XCFVG *bearishFVG;
    bool isBearishFVGRejected;

    //
    XPVPivotPoint validPeak;
    XPVPivotPoint validVale;

    //
    // Trigger Props ...

    //
    // Constructor ...
    XSMCStrategySetupConditions()
    {
        Clean();
    }

    //
    // Tools ...

    /**
     * Cleaning Up ...
     */
    void Clean()
    {
        //
        sl = 0;

        //
        dir = X_DIRECTION_NONE;
        type = X_POSITION_TYPE_NONE;

        //
        symbol = NULL;
        period = NULL;
        setupTime = NULL;
        triggerTime = NULL;

        //
        validPeak.Clean();
        validVale.Clean();

        //
        bullishOrderBlock = NULL;
        bearishOrderBlock = NULL;
        bullishOrderBlockTime = NULL;
        bearishOrderBlockTime = NULL;

        //
        bullishFVG = NULL;
        bullishFVGTime = NULL;
        isBullishFVGRejected = false;

        //
        bearishFVG = NULL;
        bearishFVGTime = NULL;
        isBearishFVGRejected = false;

        //
        isBullishOrderBlockAttacked = false;
        isBearishOrderBlockAttacked = false;
    }

    /**
     * Check Condition is Setting Up ...
     *
     * @param  dir: ENUM_X_DIRECTION member, Setting Up Direction ...
     *
     * @return ( bool )
     */
    bool IsSetuped()
    {
        //
        bool result = false;

        //
        result = IsValid(setupTime) &&
                 HasDirection(dir);
        if (!result)
        {
            return result;
        }

        //
        return result;
    }

    /**
     * Detect How we Can Trigger Signal ...
     *
     * @return ( bool )
     */
    bool CanTrigger()
    {
        //
        bool result = false;

        //
        result =
            //
            sl > 0 &&
            IsValid(symbol) &&
            IsValid(period) &&
            IsValid(triggerTime) &&
            type != X_POSITION_TYPE_ALL &&
            type != X_POSITION_TYPE_NONE
            //
            ;

        //
        return result;
    }

    //
    // Helpers ...

    //
    // Order Block ...

    /**
     * Check has Order Block ...
     *
     * @return ( bool )
     */
    bool HasOrderBlock()
    {
        //
        bool result = false;

        //
        result = HasBullishOrderBlock() &&
                 HasBearishOrderBlock();

        //
        return result;
    }

    bool HasBullishOrderBlock()
    {
        //
        bool result = false;

        //
        result =
            //
            (bullishOrderBlock != NULL &&
             bullishOrderBlock.IsValid())
            //
            ;

        //
        return result;
    }

    bool HasBearishOrderBlock()
    {
        //
        bool result = false;

        //
        result =
            //
            (bearishOrderBlock != NULL &&
             bearishOrderBlock.IsValid())
            //
            ;

        //
        return result;
    }

    bool IsOrderBlockAttacked()
    {
        //
        bool result = isBullishOrderBlockAttacked ||
                      isBearishOrderBlockAttacked;

        //
        return result;
    }

    void ResetBullishOrderBlock()
    {
        //
        bullishOrderBlock = NULL;
        bullishOrderBlockTime = NULL;
        isBullishOrderBlockAttacked = false;
    }

    void ResetBearishOrderBlock()
    {
        //
        bearishOrderBlock = NULL;
        bearishOrderBlockTime = NULL;
        isBearishOrderBlockAttacked = false;
    }

    bool HasFVG()
    {
        //
        bool result = false;

        //
        result = HasBullishFVG() ||
                 HasBearishFVG();

        //
        return result;
    }

    bool HasBullishFVG()
    {
        //
        bool result = false;

        //
        result = IsValid(bullishFVGTime) &&
                 bullishFVG != NULL &&
                 bullishFVG.IsValid();

        //
        return result;
    }

    bool HasBearishFVG()
    {
        //
        bool result = false;

        //
        result = IsValid(bearishFVGTime) &&
                 bearishFVG != NULL &&
                 bearishFVG.IsValid();

        //
        return result;
    }

    //
};

//////////////////////////////////////////////////////////////////////////////////