/**
     * Check Bar Has Signal Based on Strategy 1 ...
     * POI ...
     *
     * @param  bar: XOHCL, reference to Bar ...
     * @param  zone: XBoxZone, reference to holds affected zone ...
     * @param  targets: XTarget, reference to detected Signal's Targets collections ...
     * @param  dir: ENUM_X_DIRECTION, detected Signal's direction ...
     *
     * @return ( bool )
     */
    bool Strategy1HasSignal(
        XOHCL &bar,
        XBoxZone &zone,
        XTarget &targets[],
        ENUM_X_DIRECTION &dir //
    )
    {
        //
        bool result = false;

        //
        zone.Clean();
        XClean(targets);
        dir = X_DIRECTION_NONE;

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

        //
        int scoreBullish = 0;
        int scoreBearish = 0;
        bool isBullish = false;
        bool isBearish = false;
        int barIndex = bar.Index() + 1;

        //
        // Initialize Indexed Bar ...
        XOHCL iBar;
        result = iBar.Init(bar.symbol, bar.period, barIndex);
        if (!result)
        {
            return result;
        }

        // #region Market Structure ...
        XBoxZone supports[];
        XBoxZone resistances[];
        XBoxZone minorSupport;
        XBoxZone majorSupport;
        XBoxZone minorResistance;
        XBoxZone majorResistance;
        poiDetector.GetCurrentStructure(
            supports,
            resistances,
            minorSupport,
            majorSupport,
            minorResistance,
            majorResistance,
            barIndex,
            bar.symbol,
            iBar.period, // Minor ...
            PERIOD_H1,   // Major ...
            50,
            14,
            21,
            0 //
        );

        //
        // Refining Zones ...
        int refineLoopback = 500;
        double refineBreakThreshold = 10;
        ENUM_X_PRICE refineBreakBy = X_PRICE_CLOSE;
        poiDetector.RefineStructure(
            supports,
            resistances,
            minorSupport,
            majorSupport,
            minorResistance,
            majorResistance,
            refineLoopback,
            refineBreakThreshold,
            refineBreakBy //
        );
        // #endregion

        // #region Reading Conditions and Scoring ...
        //
        //  ATR ...
        bool isATRUp = kiParser.IsVolatilityHigh(barIndex) ||
                       kiParser.IsVolatilitySwitchdToHigh(barIndex);

        // #region KI ...
        //
        bool isKIBullish = (kiParser.IsKIFastBullish(barIndex) ||
                            kiParser.IsKIFastSwitchedToBullish(barIndex)) &&
                           (kiParser.IsKISlowBullish(barIndex) ||
                            kiParser.IsKISlowSwitchedToBullish(barIndex));
        if (isKIBullish)
        {
            scoreBullish++;
        }

        //
        bool isKIBearish = (kiParser.IsKIFastBearish(barIndex) ||
                            kiParser.IsKIFastSwitchedToBearish(barIndex)) &&
                           (kiParser.IsKISlowBearish(barIndex) ||
                            kiParser.IsKISlowSwitchedToBearish(barIndex));
        if (isKIBearish)
        {
            scoreBearish++;
        }
        // #endregion

        // #region KI Wave ...
        //
        bool isKIWaveBullish = kiParser.IsKIWaveBullish(barIndex) ||
                               kiParser.IsKIWaveSwitchedToBullish(barIndex);
        if (isKIWaveBullish)
        {
            scoreBullish++;
        }

        //
        bool isKIWaveBearish = kiParser.IsKIWaveBearish(barIndex) ||
                               kiParser.IsKIWaveSwitchedToBearish(barIndex);
        if (isKIWaveBearish)
        {
            scoreBearish++;
        }
        // #endregion

        // #region MA ...
        //
        bool isMaBullish = kiParser.IsMACrossoverBullish(barIndex) ||
                           kiParser.IsMACrossoverSwitchedToBullish(barIndex);
        if (isMaBullish)
        {
            scoreBullish++;
        }

        //
        bool isMaBearish = kiParser.IsMACrossoverBearish(barIndex) ||
                           kiParser.IsMACrossoverSwitchedToBearish(barIndex);
        if (isMaBearish)
        {
            scoreBearish++;
        }
        // #endregion

        // #region LowerTF Candlstick ...
        //
        bool isLowerTFBullish = IsTFBullishPattern(barIndex, PERIOD_M5);
        if (isLowerTFBullish)
        {
            scoreBullish++;
        }

        //
        bool isLowerTFBearish = IsTFBearishPattern(barIndex, PERIOD_M5);
        if (isLowerTFBearish)
        {
            scoreBearish++;
        }
        // #endregion

        // #region Candlestick ...
        //
        bool isCandlestickBullish = poiDetector.HasCandlestickDirection(
            iBar,
            X_DIRECTION_BULLISH //
        );
        if (isCandlestickBullish)
        {
            scoreBullish++;
        }

        //
        bool isCandlestickBearish = poiDetector.HasCandlestickDirection(
            iBar,
            X_DIRECTION_BEARISH //
        );
        if (isCandlestickBearish)
        {
            scoreBearish++;
        }
        // #endregion

        // #region NearInside Support/Resistance ...
        //
        int tmpSupportIDX = -1;
        bool isNearSupport = poiDetector.HasNearZone(tmpSupportIDX, iBar.close, 5, supports);
        if (isNearSupport)
        {
            scoreBullish++;
        }

        //
        int tmpResistanceIDX = -1;
        bool isNearResistance = poiDetector.HasNearZone(tmpResistanceIDX, iBar.close, 5, resistances);
        if (isNearResistance)
        {
            scoreBearish++;
        }
        // #endregion
        // #endregion

        // #region Summarize Directional Conditions ...
        //
        isBullish =
            isATRUp &&
            scoreBullish >= 4 &&
            (isMaBullish ||
             isNearSupport ||
             isKIWaveBullish ||
             isLowerTFBullish ||
             isCandlestickBullish);

        //
        isBearish =
            isATRUp &&
            scoreBearish >= 4 &&
            (isMaBearish ||
             isNearResistance ||
             isKIWaveBearish ||
             isLowerTFBearish ||
             isCandlestickBearish);
        // #endregion

        //
        // Validate Conditions ...
        result = isBullish || isBearish;
        if (!result)
        {
            //
            iBar.Clean();
            XClean(supports);
            XClean(resistances);
            minorSupport.Clean();
            majorSupport.Clean();
            minorResistance.Clean();
            majorResistance.Clean();

            //
            return result;
        }

        //
        // Select Operational Zone ...
        if (isBullish)
        {
            //
            // Nearest Support ...
            if (IsValidIndex(tmpSupportIDX))
            {
                zone = supports[tmpSupportIDX];
            }

            //
            // Make Sure Zone Exists ...
            if (!zone.IsValid())
            {
                //
                // Looking Bar Patterns to Detect Zone ...
                poiDetector.HasRecentPatternTouched(zone, iBar.close, barIndex, 5, 5, iBar.period, X_DIRECTION_BULLISH);
            }
        }
        else if (isBearish)
        {
            //
            // Nearest Resistance ...
            if (IsValidIndex(tmpResistanceIDX))
            {
                zone = resistances[tmpResistanceIDX];
            }

            //
            // Make Sure Zone Exists ...
            if (!zone.IsValid())
            {
                //
                // Looking Bar Patterns to Detect Zone ...
                poiDetector.HasRecentPatternTouched(zone, iBar.close, barIndex, 5, 5, iBar.period, X_DIRECTION_BEARISH);
            }
        }

        //
        // Refactor Result ...
        result = result &&
                 zone.IsValid();
        if (result)
        {
            //
            // Refine Zone ...
            poiDetector.RefineZone(zone);

            //
            // SL Refactoring ...

            //
            XOHCL toBar;
            if (zone.ToBar(toBar))
            {
                //
                int to = zone.ToIndex();
                int from = zone.FromIndex();
                int length = from - to;
                double iValue =
                    isBullish
                        ? toBar.FindLowest(length, MODE_LOW)
                    : isBearish
                        ? toBar.FindHighest(length, MODE_HIGH)
                        : EMPTY_VALUE;
                if (NotEmptyZero(iValue))
                {
                    //
                    if (isBullish)
                    {
                        zone.lower = MathMin(zone.lower, iValue);
                    }

                    //
                    if (isBearish)
                    {
                        zone.upper = MathMax(zone.upper, iValue);
                    }
                }
            }
            toBar.Clean();
        }

        //
        // Do Directional Validation ...
        if (result)
        {
            //
            // Bullish ...
            if (isBullish)
            {
                //
                isBullish =
                    isBullish &&
                    isLowerTFBullish &&
                    isCandlestickBullish;
            }

            //
            // Bearish ...
            if (isBearish)
            {
                //
                isBearish =
                    isBearish &&
                    isLowerTFBearish &&
                    isCandlestickBearish;
            }

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

        //
        // Validate Result ...
        if (!result)
        {
            //
            iBar.Clean();
            XClean(supports);
            XClean(resistances);
            minorSupport.Clean();
            majorSupport.Clean();
            minorResistance.Clean();
            majorResistance.Clean();

            //
            return result;
        }

        //
        // Draws ...
        bool draw = true;
        if (draw && result)
        {
            //
            int drawn = 0;

            //
            XPOIDrawConfig config;
            config.Default();

            //
            if (zone.IsValid())
            {
                //
                drawn++;

                //
                config.zonesWidth = 3;
                config.bullishColor = clrYellow;
                config.bearishColor = clrOrange;

                //
                poiDrawer.DrawZone(zone, config);

                //
                config.Default();
            }

            //
            // Minors ...
            if (minorSupport.IsValid())
            {
                //
                drawn++;
                poiDrawer.DrawZone(minorSupport, config);
            }
            if (minorResistance.IsValid())
            {
                //
                drawn++;
                poiDrawer.DrawZone(minorResistance, config);
            }

            //
            // Majors ...
            config.bullishColor = clrLime;
            config.bearishColor = clrRed;
            config.zonesWidth = 4;

            //
            if (majorSupport.IsValid())
            {
                //
                drawn++;
                poiDrawer.DrawZone(majorSupport, config);
            }
            if (majorResistance.IsValid())
            {
                //
                drawn++;
                poiDrawer.DrawZone(majorResistance, config);
            }

            //
            config.Clean();

            //
            if (drawn > 0)
            {
                DebugBreak();
            }
        }

        //
        // Check and Prepare Direction ...
        dir =
            isBullish
                ? X_DIRECTION_BULLISH
            : isBearish ? X_DIRECTION_BEARISH
                        : X_DIRECTION_NONE;
        result = result &&
                 HasDirection(dir);
        if (!result)
        {
            //
            iBar.Clean();
            XClean(supports);
            XClean(resistances);
            minorSupport.Clean();
            majorSupport.Clean();
            minorResistance.Clean();
            majorResistance.Clean();

            //
            return result;
        }

        //
        // Prepare Zone ...
        double entry = GetEntry(iBar.symbol, dir);
        if (result)
        {
            //
            double upper = isBullish
                               ? entry
                               : zone.upper;
            double lower = isBullish
                               ? zone.lower
                               : entry;
            datetime to = bar.time;
            datetime from = isBullish
                                ? zone.from
                                : zone.from;
            result = zone.Init(
                iBar.symbol,
                iBar.period,
                upper,
                lower,
                from,
                to,
                dir,
                "XS1" //
            );
        }

        //
        // Cleanup Resources ...
        iBar.Clean();
        XClean(supports);
        XClean(resistances);
        minorSupport.Clean();
        majorSupport.Clean();
        minorResistance.Clean();
        majorResistance.Clean();

        //
        result =
            result &&
            zone.IsValid() &&
            HasDirection(dir);

        //
        return result;
    }