//
// Fix Signal TP Based On Working Zone ...
// double maxAllowedTP =
//     hasLong
//         ? mXWZConditions.workingZone.upper
//         : mXWZConditions.workingZone.lower;
// bool canApplyMaxAlowedTP = (hasLong &&
//                             signal.tp > maxAllowedTP) ||
//                            (!hasLong && signal.tp < maxAllowedTP);
// if (canApplyMaxAlowedTP)
// {
//     signal.tp = maxAllowedTP;
// }

//
// Configuring Global Protector ...
// signal.trailSL = true;
// signal.trailSLStartOnReachTPLevel = 3;
// signal.fullTPLevel = signal.GetRiskRewardRatio();

// //
// mXSupDemOBSSignalDetector.RemoveDraws();
// mXSupDemOBSSignalDetector.DrawConditions(
//     mXSupDemOBSConditions,
//     mVisionCycleHelper.mPOIDrawer //
// );

// //
// mXSupDemOBSSignalDetector.RemoveWorkingZoneDraws();
// mXSupDemOBSSignalDetector.DrawWorkingZone(
//     mXSupDemOBSConditions,
//     mVisionCycleHelper.mPOIDrawer //
// );

//
// bool canReplaceTarget =
//     signal.target > 0 &&
//     (hasLong
//          ? signal.target > signal.tp
//          : signal.target < signal.tp);
// if (canReplaceTarget)
// {
//     //
//     signal.tp = conditions.target;
//     signal.target = tp;
// }


        //
        // consolidationState.UpdateTo(cTime);
        // XPOIState filtered;
        // consolidationState.Filter(
        //     filtered,
        //     NULL,
        //     XZONE_STATE_PASSED,
        //     false,
        //     XZONE_STATE_FAILED,
        //     false,
        //     XZONE_STATE_FAILED,
        //     false,
        //     XZONE_STATE_IGNORED,
        //     false //
        // );
        // XCBaseObject *objects[];
        // int objectsCount = drawer.DrawState(
        //     filtered,
        //     objects //
        // );
        // if (IsValidSize(objectsCount))
        // {
        //     //
        //     Print("");
        // }

        // //
        // XOBFVG activeObfvgs[];
        // int activeObfvgsCount = ExtractOBFVGs(
        //     activeObfvgs,
        //     consolidationState,
        //     analyseState //
        // );
        // bool hasActiveOBFVGs = IsValidSize(activeObfvgsCount);
        // if (hasActiveOBFVGs)
        // {
        //     //
        //     SpecifiedUpdateTo(activeObfvgs);
        //     for (int i = 0; i < activeObfvgsCount; i++)
        //     {
        //         //
        //         XCBaseObject *objects[];
        //         int objectsCount = drawer.DrawOBFVG(
        //             activeObfvgs[i],
        //             objects //
        //         );
        //     }
        // }


        
            // //
            // // Swings ...
            // bool lookupSwings = ArraySize(mSwingLows) < mMaxRequiredPOIs ||
            //                     ArraySize(mSwingHighs) < mMaxRequiredPOIs;
            // lookupSwings =
            //     ignoreMaxAllowed
            //         ? true
            //         : lookupSwings;
            // if (has &&
            //     lookupSwings)
            // {
            // }

            // //
            // // Momentum Bar ...
            // bool lookupMomentums = ArraySize(mBullishMomentumBars) < mMaxRequiredPOIs ||
            //                        ArraySize(mBearishMomentumBars) < mMaxRequiredPOIs;
            // lookupMomentums =
            //     ignoreMaxAllowed
            //         ? true
            //         : lookupMomentums;
            // if (has &&
            //     lookupMomentums)
            // {
            // }

            // //
            // // Rejection Bar ...
            // bool lookupRejections = ArraySize(mBullishRejectionBars) < mMaxRequiredPOIs ||
            //                         ArraySize(mBearishRejectionBars) < mMaxRequiredPOIs;
            // lookupRejections =
            //     ignoreMaxAllowed
            //         ? true
            //         : lookupRejections;
            // if (has &&
            //     lookupRejections)
            // {
            // }

            // //
            // // Support ...
            // bool lookupSupports = ArraySize(mSupportZones) < mMaxRequiredPOIs;
            // lookupSupports =
            //     ignoreMaxAllowed
            //         ? true
            //         : lookupSupports;
            // if (has &&
            //     lookupSupports)
            // {
            // }

            // //
            // // Demand ...
            // bool lookupDemands = ArraySize(mDemandZones) < mMaxRequiredPOIs;
            // lookupDemands =
            //     ignoreMaxAllowed
            //         ? true
            //         : lookupDemands;
            // if (has &&
            //     lookupDemands)
            // {
            // }

            // //
            // // Resistance ...
            // bool lookupResistance = ArraySize(mResistanceZones) < mMaxRequiredPOIs;
            // lookupResistance =
            //     ignoreMaxAllowed
            //         ? true
            //         : lookupResistance;
            // if (has &&
            //     lookupResistance)
            // {
            // }

            // //
            // // Supply ...
            // bool lookupSupplies = ArraySize(mSupplyZones) < mMaxRequiredPOIs;
            // lookupSupplies =
            //     ignoreMaxAllowed
            //         ? true
            //         : lookupSupplies;
            // if (has &&
            //     lookupSupplies)
            // {
            // }

            // //
            // // OrderBlock ...
            // bool lookupOrderBlocks = ArraySize(mBullishOrderBlocks) < mMaxRequiredPOIs ||
            //                          ArraySize(mBearishOrderBlocks) < mMaxRequiredPOIs;
            // lookupOrderBlocks =
            //     ignoreMaxAllowed
            //         ? true
            //         : lookupOrderBlocks;
            // if (has &&
            //     lookupOrderBlocks)
            // {
            // }

            // //
            // // FairValueGap ...
            // bool lookupFairValeGaps = ArraySize(mBullishFairValueGaps) < mMaxRequiredPOIs ||
            //                           ArraySize(mBearishFairValueGaps) < mMaxRequiredPOIs;
            // lookupFairValeGaps =
            //     ignoreMaxAllowed
            //         ? true
            //         : lookupFairValeGaps;
            // if (has &&
            //     (lookupFairValeGaps))
            // {
            // }