///////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 Class Library
// --------------------------------------
// Name: XCX121SMCTestStrategy
// Description: provides all based classes for use ...
//
//
// Maintainer:
// ------------
// Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com)
//
//////////////////////////////////////////////////////
//
// Global Properties ...
#property library
#property copyright "Copyright 2023, SaherElm IT Center"
#property link "https://www.saherelm.ir"
#property version "1.00"
#property strict

//
// Imports ...

//
#include "../../Helpers/x-saherelm.x3ma.helper.mq5"
#include "../../Helpers/x-saherelm.x3vwap.helper.mq5"
#include "../../Helpers/x-saherelm.xpv.helper.mq5"
#include "../Classes/x-121.smc.base.strategy.class.mq5"

//
// Helper(s) ...

//
// XStrategy Class Implementation(s) ...
class XCX121SMCTestStrategy : public XCX121SMCBaseStrategy
{
    //
    // Public ...
  public:
    //

    //
    // Constructor(s) ...
    void XCX121SMCTestStrategy(
        //
        // Base ...
        string _symbol,         // Trading Symbol
        ENUM_TIMEFRAMES _period // Trading TimeFrame
        )
        : XCX121SMCBaseStrategy(_symbol, _period)
    {
        InitialHelpers();
    }

    //
    // Deconstructur ...
    void ~XCX121SMCTestStrategy()
    {
    }

    //
    // Overrides Actions ...

    /**
     * Destroy All Class Implementations ...
     */
    void Destroy() override
    {
        //
        delete xpvHelper;
        delete x3maHelper;
        delete x3vwapHelper;
    }

    /**
     * Check Conditions For Signal ...
     */
    bool HasSignal(
        XSignal &signal,
        X121SMCStrategyConditions &conditions //
        ) override
    {
        //
        bool result = false;

        //
        signal.Clean();
        conditions.Clean();

        //
        int pushers = 0;

        //
        double sl = 0;
        double tp = 0;
        double risk = 0;
        double entry = 0;
        double reward = 0;
        double r2r = R2R();
        double volume = Volume();
        ENUM_POSITION_TYPE type = POSITION_TYPE_BUY;
        ENUM_X_ORDER_MODES mode = X_ORDER_MODE_MARKET;

        //
        bool hasLong = false;
        bool hasShort = false;

        //
        // Start Calculations ...

        //
        string _symbol = GetSymbol();
        ENUM_TIMEFRAMES _period = GetPeriod();

        //
        double points = GetPoints(_symbol);
        double pip = GetPipPrice(_symbol);
        double pip2 = 2 * pip;

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

        //
        // Retrieve Bars ...

        //
        // Zero Bar ...
        XOHCL zBar;
        result = zBar.Init(
            _symbol,
            _period,
            zIndex //
        );
        if (!result)
        {
            return result;
        }

        //
        // Last Bar ...
        XOHCL cBar;
        result = cBar.Init(
            _symbol,
            _period,
            cIndex //
        );
        if (!result)
        {
            return result;
        }

        //
        // Previous Bar ...
        XOHCL pBar;
        result = pBar.Init(
            _symbol,
            _period,
            pIndex //
        );
        if (!result)
        {
            return result;
        }

        //
        bool isSpreadPassed = IsSpreadPass();
        result = isSpreadPassed;
        if (!result)
        {
            return result;
        }

        //
        // Try to Implement SMC Based Conditions ...

        //
        result = hasLong ||
                 hasShort;

        //
        // Rmove Signal Condition ...
        if (result)
        {
            //
            // TYPE ...
            type =
                hasLong
                    ? POSITION_TYPE_BUY
                    : POSITION_TYPE_SELL;
            ENUM_X_POSITION_TYPES xType =
                hasLong
                    ? X_POSITION_TYPE_LONG
                    : X_POSITION_TYPE_SHORT;

            //
            entry = GetEntry(
                conditions.symbol,
                type //
            );

            //
            double candidates[];
            DetectSLCandidates(
                candidates,
                entry,
                conditions,
                xType //
            );
            double selectedSL =
                hasLong
                    ? GetMax(candidates)
                    : GetMin(candidates);
            sl =
                hasLong
                    ? selectedSL - pip2
                    : selectedSL + pip2;

            //
            // RISK Reward ...
            risk =
                hasLong
                    ? entry - sl
                    : sl - entry;
            reward = risk * r2r;
            tp =
                hasLong
                    ? entry + reward
                    : entry - reward;

            //
            ClearDraws();

            //
            signal.sl = sl;
            signal.tp = tp;
            signal.type = type;
            signal.mode = mode;
            signal.entry = entry;
            signal.volume = volume;
            signal.symbol = _symbol;
            signal.pushers = pushers;
            signal.provider = GetTag();
            signal.time = TimeCurrent();
            signal.period = _5MState.period;

            //
            result = PrepareSignal(signal);

            //
            hasLong = false;
            hasShort = false;
        }

        //
        return result;
    }

    /**
     * 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
    {
    }

    /**
     * Customize Strategy Identifier ...
     */
    string GetTag() override
    {
        return X121SMCStrategyToken;
    }

    //
    // Protected ...
  protected:
    //

    //
    // Props ...

    //
    // XPV ...
    XPVInputs xpvInputs;
    XCXPVHelper *xpvHelper;

    //
    // X3MA ...
    X3MAInputs x3maInputs;
    XCX3MAHelper *x3maHelper;

    //
    // X3VWAP ...
    X3VWAPInputs x3vwapInputs;
    XCX3VWAPHelper *x3vwapHelper;

    //
    // Private ...
  private:
    //
    // Props ...

    /**
     * Initial Required Indicators Helper ...
     */
    void InitialHelpers()
    {
        //
        string symbol = GetSymbol();
        ENUM_TIMEFRAMES period = GetPeriod();

        //
        // Short ...
        ENUM_X_PERIOD_METHOD scMethod = X_PERIOD_AUTO; // How to Find Period
        ENUM_TIMEFRAMES scPeriod = NULL;               // Time Period

        //
        // Medium ...
        ENUM_X_PERIOD_METHOD mcMethod = X_PERIOD_AUTO; // How to Find Period
        ENUM_TIMEFRAMES mcPeriod = NULL;               // Time Period

        //
        // Long ...
        ENUM_X_PERIOD_METHOD lcMethod = X_PERIOD_AUTO; // How to Find Period
        ENUM_TIMEFRAMES lcPeriod = NULL;               // Time Period

        //
        // Hind ...
        ENUM_X_PERIOD_METHOD hcMethod = X_PERIOD_AUTO; // How to Find Period
        ENUM_TIMEFRAMES hcPeriod = NULL;               // Time Period

        //
        // XPV ...

        //
        xpvInputs.Default();

        //
        xpvInputs.scMethod = scMethod;
        xpvInputs.scPeriod = scPeriod;
        xpvInputs.mcMethod = mcMethod;
        xpvInputs.mcPeriod = mcPeriod;
        xpvInputs.lcMethod = lcMethod;
        xpvInputs.lcPeriod = lcPeriod;
        xpvInputs.hcMethod = hcMethod;
        xpvInputs.hcPeriod = hcPeriod;

        //
        xpvInputs.showPeaksAndVales = true;
        xpvInputs.showLevels = false;
        xpvInputs.showConsolidations = false;
        xpvInputs.showFibo1Levels = false;
        xpvInputs.showFibo2Levels = false;
        xpvInputs.showFibo3Levels = false;
        xpvInputs.showFibo4Levels = false;
        xpvInputs.showFibo5Levels = false;

        //
        xpvHelper = new XCXPVHelper();
        xpvHelper.Init(
            symbol,
            period,
            xpvInputs //
        );

        //
        // X3MA ...

        //
        x3maInputs.Default();

        //
        x3maInputs.showFast = false;
        x3maInputs.showMid = false;
        x3maInputs.showSlow = false;

        //
        x3maHelper = new XCX3MAHelper();
        x3maHelper.Init(
            symbol,
            period,
            x3maInputs //
        );

        //
        // X3VWAP ...

        //
        x3vwapInputs.Default();

        //
        x3vwapInputs.showFast = false;
        x3vwapInputs.showMid = false;
        x3vwapInputs.showSlow = false;

        //
        x3vwapHelper = new XCX3VWAPHelper();
        x3vwapHelper.Init(
            symbol,
            period,
            x3vwapInputs //
        );
    }

    //
};

//