///////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 Helper Class Library
// ----------------------------------------------
// Name: XSCXMCHelper
// Description: provides all Indicator
// Helper requirements ...
//
//
// 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

//
#include "../Classes/x-saherelm.xhelper.class.mq5"

//
// Definitions ...

//
enum ENUM_XMC_BUFFERS
{
    XMC_FAST_LINE = 0,
    XMC_SLOW_LINE = 1,
    XMC_VERIFIER_LINE = 2,
    XMC_SAR_LINE = 3,
};

//
// Input Models ...
struct XMCInputs
{
    //
    // Props ...

    //
    // Market ...

    //
    // Fast ...
    int fastLength;                   // Length
    int fastShift;                    // Shift
    ENUM_MA_METHOD fastMethod;        // Method
    ENUM_APPLIED_PRICE fastAppliedTo; // Applied To

    //
    // Slow ...
    int slowLength;                   // Length
    int slowShift;                    // Shift
    ENUM_MA_METHOD slowMethod;        // Method
    ENUM_APPLIED_PRICE slowAppliedTo; // Applied To

    //
    // Verifier ...
    int verifierLength;                   // Length
    int verifierShift;                    // Shift
    ENUM_MA_METHOD verifierMethod;        // Method
    ENUM_APPLIED_PRICE verifierAppliedTo; // Applied To

    //
    double step;    // Sar Step
    double maximum; // Sar Maximum

    //
    // Presentation ...
    bool showFastMa;     // Show Fast
    bool showSlowMa;     // Show Slow
    bool showVerifierMa; // Show Verifier
    bool showSar;        // Show Sar

    //
    // Constructor(s) ...
    XMCInputs()
    {
        //
        Clean();
    }

    //
    // Tools ...

    //
    // Clean ...
    void Clean()
    {
        //
        fastLength = 0;
        fastShift = 0;
        fastMethod = 0;
        fastAppliedTo = PRICE_CLOSE;

        //
        slowLength = 0;
        slowShift = 0;
        slowMethod = 0;
        slowAppliedTo = PRICE_CLOSE;

        //
        verifierLength = 0;
        verifierShift = 0;
        verifierMethod = 0;
        verifierAppliedTo = PRICE_CLOSE;

        //
        step = 0;
        maximum = 0;

        //
        showSar = false;
        showFastMa = false;
        showSlowMa = false;
        showVerifierMa = false;
    }

    //
    // Default ...
    void Default()
    {
        //
        fastLength = 21;
        fastShift = 0;
        fastMethod = MODE_EMA;
        fastAppliedTo = PRICE_CLOSE;

        //
        slowLength = 50;
        slowShift = 0;
        slowMethod = MODE_EMA;
        slowAppliedTo = PRICE_CLOSE;

        //
        verifierLength = 200;
        verifierShift = 0;
        verifierMethod = MODE_EMA;
        verifierAppliedTo = PRICE_CLOSE;

        //
        step = 0.02;
        maximum = 0.2;

        //
        showSar = true;
        showFastMa = true;
        showSlowMa = true;
        showVerifierMa = true;
    }

    //
    // Validate ...
    bool IsValid()
    {
        //
        bool result = false;

        //
        result =
            //
            fastLength > 1 &&
            slowLength > fastLength &&
            verifierLength > slowLength &&
            //
            step > 0 &&
            maximum > step
            //
            ;

        //
        return result;
    }

    //
    // Retrieve MAx Length ...
    int Max()
    {
        //
        int result = 0;

        //
        result = MathMax(fastLength, slowLength);
        result = MathMax(result, verifierLength);

        //
        return result;
    }
};

//
// Define Conditions ...
struct XMCConditions
{
    //
    // Common ...
    string symbol;
    ENUM_TIMEFRAMES period;
    datetime time;

    //
    // Buffers ...
    double fast[];
    double slow[];
    double verifier[];

    //
    double psar[];

    //
    // Conditions ...

    //
    // Trend ...
    bool isBullish;
    bool isBearish;
    bool isSwitchedToBullish;
    bool isSwitchedToBearish;

    //
    // Fast Slow ...
    bool isFastOverSlow;
    bool isFastUnderSlow;
    bool isFastCrossedOverSlow;
    bool isFastCrossedUnderSlow;

    //
    // Fast Verifier ...
    bool isFastOverVerifier;
    bool isFastUnderVerifier;
    bool isFastCrossedOverVerifier;
    bool isFastCrossedUnderVerifier;

    //
    // Slow Verifier ...
    bool isSlowOverVerifier;
    bool isSlowUnderVerifier;
    bool isSlowCrossedOverVerifier;
    bool isSlowCrossedUnderVerifier;

    //
    bool isSARBullish;
    bool isSARBearish;
    bool isSARSwitchedToBullish;
    bool isSARSwitchedToBearish;

    //
    void Clean()
    {
        //
        Clean(fast);
        Clean(slow);
        Clean(verifier);

        //
        ArraySetAsSeries(fast, true);
        ArraySetAsSeries(slow, true);
        ArraySetAsSeries(verifier, true);

        //
        // Trend ...
        isBullish = false;
        isBearish = false;
        isSwitchedToBullish = false;
        isSwitchedToBearish = false;

        //
        // Fast Slow ...
        isFastOverSlow = false;
        isFastUnderSlow = false;
        isFastCrossedOverSlow = false;
        isFastCrossedUnderSlow = false;

        //
        // Fast Verifier ...
        isFastOverVerifier = false;
        isFastUnderVerifier = false;
        isFastCrossedOverVerifier = false;
        isFastCrossedUnderVerifier = false;

        //
        // Slow Verifier ...
        isSlowOverVerifier = false;
        isSlowUnderVerifier = false;
        isSlowCrossedOverVerifier = false;
        isSlowCrossedUnderVerifier = false;

        //
        isSARBullish = false;
        isSARBearish = false;
        isSARSwitchedToBullish = false;
        isSARSwitchedToBearish = false;
    }

    //
    void GenerateScore(
        double &bullishScore,
        double &bearishScore //
    )
    {
        //
        bullishScore = 0;
        bearishScore = 0;

        //
        // Trend ...

        //
        if (isBullish)
        {
            bullishScore++;
        }
        if (isSwitchedToBullish)
        {
            bullishScore++;
        }

        //
        if (isBearish)
        {
            bearishScore++;
        }
        if (isSwitchedToBearish)
        {
            bearishScore++;
        }

        //
        // Fast Slow ...

        //
        if (isFastOverSlow)
        {
            bullishScore++;
        }
        if (isFastCrossedOverSlow)
        {
            bullishScore++;
        }

        //
        if (isFastUnderSlow)
        {
            bearishScore++;
        }
        if (isFastCrossedUnderSlow)
        {
            bearishScore++;
        }

        //
        // Fast Verifier ...

        //
        if (isFastOverVerifier)
        {
            bullishScore++;
        }
        if (isFastCrossedOverVerifier)
        {
            bullishScore++;
        }

        //
        if (isFastUnderVerifier)
        {
            bearishScore++;
        }
        if (isFastCrossedUnderVerifier)
        {
            bearishScore++;
        }

        //
        // Slow Verifier ...

        //
        if (isSlowOverVerifier)
        {
            bullishScore++;
        }
        if (isSlowCrossedOverVerifier)
        {
            bullishScore++;
        }

        //
        if (isSlowUnderVerifier)
        {
            bearishScore++;
        }
        if (isSlowCrossedUnderVerifier)
        {
            bearishScore++;
        }

        //
        if (isSARBullish)
        {
            bullishScore++;
        }
        if (isSARSwitchedToBullish)
        {
            bullishScore++;
        }

        //
        if (isSARBearish)
        {
            bearishScore++;
        }
        if (isSARSwitchedToBearish)
        {
            bearishScore++;
        }
    }

    //
    string GenerateSummary(
        bool onlyCommons = false,
        bool onlyConditions = false,
        bool includeScores = true,
        bool ignoreFalseConditions = true,
        string separator = "\n" //
    )
    {
        //
        string result = NULL;

        //
        double bullishScore = 0;
        double bearishScore = 0;
        GenerateScore(
            bullishScore,
            bearishScore //
        );

        //
        string scoresStr =
            //
            "Scores: " + separator +
            "---------------" + separator +
            "Bullish: " + ToString(bullishScore) + separator +
            "Bearish: " + ToString(bearishScore) + separator +
            ""
            //
            ;

        //
        string commonStr = GenerateSpecifiedCommonSummary(
            this,
            separator,
            includeScores //
        );

        //
        string conditionsStr =
            //
            // Trend ...
            ToString("isBullish", isBullish, ignoreFalseConditions, separator) +
            ToString("isBearish", isBearish, ignoreFalseConditions, separator) +
            ToString("isSwitchedToBullish", isSwitchedToBullish, ignoreFalseConditions, separator) +
            ToString("isSwitchedToBearish", isSwitchedToBearish, ignoreFalseConditions, separator) +
            //
            // Fast Slow ...
            ToString("isFastOverSlow", isFastOverSlow, ignoreFalseConditions, separator) +
            ToString("isFastUnderSlow", isFastUnderSlow, ignoreFalseConditions, separator) +
            ToString("isFastCrossedOverSlow", isFastCrossedOverSlow, ignoreFalseConditions, separator) +
            ToString("isFastCrossedUnderSlow", isFastCrossedUnderSlow, ignoreFalseConditions, separator) +
            //
            // Fast Verifier ...
            ToString("isFastOverVerifier", isFastOverVerifier, ignoreFalseConditions, separator) +
            ToString("isFastUnderVerifier", isFastUnderVerifier, ignoreFalseConditions, separator) +
            ToString("isFastCrossedOverVerifier", isFastCrossedOverVerifier, ignoreFalseConditions, separator) +
            ToString("isFastCrossedUnderVerifier", isFastCrossedUnderVerifier, ignoreFalseConditions, separator) +
            //
            // Slow Verifier ...
            ToString("isSlowOverVerifier", isSlowOverVerifier, ignoreFalseConditions, separator) +
            ToString("isSlowUnderVerifier", isSlowUnderVerifier, ignoreFalseConditions, separator) +
            ToString("isSlowCrossedOverVerifier", isSlowCrossedOverVerifier, ignoreFalseConditions, separator) +
            ToString("isSlowCrossedUnderVerifier", isSlowCrossedUnderVerifier, ignoreFalseConditions, separator) +
            //
            // Psar ...
            ToString("isSARBullish", isSARBullish, ignoreFalseConditions, separator) +
            ToString("isSARBearish", isSARBearish, ignoreFalseConditions, separator) +
            ToString("isSARSwitchedToBullish", isSARSwitchedToBullish, ignoreFalseConditions, separator) +
            ToString("isSARSwitchedToBearish", isSARSwitchedToBearish, ignoreFalseConditions, separator) +
            //
            ""
            //
            ;

        //
        result =
            //
            "[" + GetTag() + "]" + separator +
            (onlyConditions
                 ? ""
                 : commonStr) +
            (!includeScores
                 ? ""
                 : scoresStr) +
            " " + separator +
            (onlyCommons
                 ? ""
                 : conditionsStr) +
            ""
            //
            ;

        //
        return result;
    }

    //
    string GetTag()
    {
        return "XMATD";
    }
};

//
// Class ...
class XSCXMCHelper : public XSCBaseHelper
{
    //
    // Public ...
public:
    //
    // Props ...

    //
    // Constructors ...
    XSCXMCHelper() : XSCBaseHelper(_Symbol, _Period)
    {
    }

    //
    // Deconstructor ...
    ~XSCXMCHelper() {}

    //
    // Tools ...
    bool Init(
        string symbol,          // Trading Symbol
        ENUM_TIMEFRAMES period, // Trading Period
        XMCInputs &inputs       // Inputs
    )
    {
        //
        bool result = false;

        //
        mSymbol = symbol;
        mPeriod = period;

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

        //
        mInputs = inputs;

        //
        ArraySetAsSeries(fastBuffer, true);
        ArraySetAsSeries(slowBuffer, true);
        ArraySetAsSeries(verifierBuffer, true);
        mHandler = iCustom(
            mSymbol,
            mPeriod,
            "x-saherelm.xmc",
            //
            // Inputs ...
            //
            // Fast ...
            "",
            mInputs.fastLength,
            mInputs.fastShift,
            mInputs.fastMethod,
            mInputs.fastAppliedTo,
            //
            // Slow ...
            "",
            mInputs.slowLength,
            mInputs.slowShift,
            mInputs.slowMethod,
            mInputs.slowAppliedTo,
            //
            // Verifier ...
            "",
            mInputs.verifierLength,
            mInputs.verifierShift,
            mInputs.verifierMethod,
            mInputs.verifierAppliedTo,
            //
            // Psar ...
            "",
            mInputs.step,
            mInputs.maximum,
            //
            // Presentation ...
            "",
            mInputs.showSar,       // Show Sar ...
            mInputs.showFastMa,    // Show Fast
            mInputs.showSlowMa,    // Show Slow
            mInputs.showVerifierMa // Show Verifier
            //
        );
        result = mHandler != INVALID_HANDLE;
        if (!result)
        {
            return result;
        }

        //
        return result;
    }

    //
    // Inputs ...

    //
    XMCInputs GetInputs()
    {
        return mInputs;
    }

    //
    bool SetInputs(
        XMCInputs &inputs // Configs
    )
    {
        //
        return Init(
            mSymbol,
            mPeriod,
            inputs);
    }

    //
    // Buffers ...

    //
    // Fast ...

    //
    double GetFast(
        int barIndex // Bar Index
    )
    {
        //
        if (barIndex < 0)
        {
            barIndex = 0;
        }

        //
        Calculate();

        //
        return fastBuffer[barIndex];
    }

    //
    // Copy Required Buffer ...
    int CopyFast(
        int start,             // Start
        int count,             // Number of Items for read
        double &buffer[],      // Dest Buffer
        bool forceClean = true // Force To Clean buffer
    )
    {
        //
        // Update Calculations ...
        Calculate();

        //
        // Copy Items ...
        return Copy(
            start,
            count,
            fastBuffer,
            buffer,
            forceClean
            //
        );
    }

    //
    // Slow ...

    //
    double GetSlow(
        int barIndex // Bar Index
    )
    {
        //
        if (barIndex < 0)
        {
            barIndex = 0;
        }

        //
        Calculate();

        //
        return slowBuffer[barIndex];
    }

    //
    // Copy Required Buffer ...
    int CopySlow(
        int start,             // Start
        int count,             // Number of Items for read
        double &buffer[],      // Dest Buffer
        bool forceClean = true // Force To Clean buffer
    )
    {
        //
        // Update Calculations ...
        Calculate();

        //
        // Copy Items ...
        return Copy(
            start,
            count,
            slowBuffer,
            buffer,
            forceClean
            //
        );
    }

    //
    // Verifier ...

    //
    double GetVerifier(
        int barIndex // Bar Index
    )
    {
        //
        if (barIndex < 0)
        {
            barIndex = 0;
        }

        //
        Calculate();

        //
        return verifierBuffer[barIndex];
    }

    //
    // Copy Required Buffer ...
    int CopyVerifier(
        int start,             // Start
        int count,             // Number of Items for read
        double &buffer[],      // Dest Buffer
        bool forceClean = true // Force To Clean buffer
    )
    {
        //
        // Update Calculations ...
        Calculate();

        //
        // Copy Items ...
        return Copy(
            start,
            count,
            verifierBuffer,
            buffer,
            forceClean
            //
        );
    }

    //
    // Sar ...

    //
    double GetSar(
        int barIndex // Bar Index
    )
    {
        //
        if (barIndex < 0)
        {
            barIndex = 0;
        }

        //
        Calculate();

        //
        return sarBuffer[barIndex];
    }

    //
    // Copy Required Buffer ...
    int CopySar(
        int start,             // Start
        int count,             // Number of Items for read
        double &buffer[],      // Dest Buffer
        bool forceClean = true // Force To Clean buffer
    )
    {
        //
        // Update Calculations ...
        Calculate();

        //
        // Copy Items ...
        return Copy(
            start,
            count,
            sarBuffer,
            buffer,
            forceClean
            //
        );
    }

    //
    bool GetConditions(
        XMCConditions &conditions, //
        int barIndex = 0,          //
        int loopback = 3           //
    )
    {
        //
        bool result = true;

        //
        if (loopback < 3)
        {
            loopback = 3;
        }

        //
        conditions.Clean();

        //
        conditions.symbol = mSymbol;
        conditions.period = mPeriod;
        conditions.time = TimeCurrent();

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

        //
        CopyFast(
            zIndex,
            loopback,
            conditions.fast //
        );

        //
        CopySlow(
            zIndex,
            loopback,
            conditions.slow //
        );

        //
        CopyVerifier(
            zIndex,
            loopback,
            conditions.verifier //
        );

        //
        CopySar(
            zIndex,
            loopback,
            conditions.psar //
        );

        //
        // Calculate Conditions ...

        //
        // Trend ...

        //
        bool isBullish = conditions.fast[cIndex] > conditions.slow[cIndex] &&
                         conditions.slow[cIndex] > conditions.verifier[cIndex];
        bool isBearish = conditions.fast[cIndex] < conditions.slow[cIndex] &&
                         conditions.slow[cIndex] < conditions.verifier[cIndex];

        //
        bool isBullishPrev = conditions.fast[pIndex] > conditions.slow[pIndex] &&
                             conditions.slow[pIndex] > conditions.verifier[pIndex];
        bool isBearishPrev = conditions.fast[pIndex] < conditions.slow[pIndex] &&
                             conditions.slow[pIndex] < conditions.verifier[pIndex];

        //
        bool isSwitchedToBullish = isBullish &&
                                   !isBullishPrev;
        bool isSwitchedToBearish = isBearish &&
                                   !isBearishPrev;

        //
        // Set Conditions to Structure ...
        conditions.isBullish = isBullish;
        conditions.isBearish = isBearish;
        conditions.isSwitchedToBullish = isSwitchedToBullish;
        conditions.isSwitchedToBearish = isSwitchedToBearish;

        //
        // Fast Slow ...

        //
        bool isFastOverSlow = conditions.fast[cIndex] > conditions.slow[cIndex];
        bool isFastUnderSlow = conditions.fast[cIndex] < conditions.slow[cIndex];

        //
        bool isFastOverSlowPrev = conditions.fast[pIndex] > conditions.slow[pIndex];
        bool isFastUnderSlowPrev = conditions.fast[pIndex] < conditions.slow[pIndex];

        //
        bool isFastCrossedOverSlow = isFastOverSlow &&
                                     !isFastOverSlowPrev;
        bool isFastCrossedUnderSlow = isFastUnderSlow &&
                                      !isFastUnderSlowPrev;

        //
        conditions.isFastOverSlow = isFastOverSlow;
        conditions.isFastUnderSlow = isFastUnderSlow;
        conditions.isFastCrossedOverSlow = isFastCrossedOverSlow;
        conditions.isFastCrossedUnderSlow = isFastCrossedUnderSlow;

        //
        // Fast Verifier ...

        //
        bool isFastOverVerifier = conditions.fast[cIndex] > conditions.verifier[cIndex];
        bool isFastUnderVerifier = conditions.fast[cIndex] < conditions.verifier[cIndex];

        //
        bool isFastOverVerifierPrev = conditions.fast[pIndex] > conditions.verifier[pIndex];
        bool isFastUnderVerifierPrev = conditions.fast[pIndex] < conditions.verifier[pIndex];

        //
        bool isFastCrossedOverVerifier = isFastOverVerifier &&
                                         !isFastOverVerifierPrev;
        bool isFastCrossedUnderVerifier = isFastUnderVerifier &&
                                          !isFastUnderVerifierPrev;

        //
        conditions.isFastOverVerifier = isFastOverVerifier;
        conditions.isFastUnderVerifier = isFastUnderVerifier;
        conditions.isFastCrossedOverVerifier = isFastCrossedOverVerifier;
        conditions.isFastCrossedUnderVerifier = isFastCrossedUnderVerifier;

        //
        // Slow Verifier ...

        //
        bool isSlowOverVerifier = conditions.slow[cIndex] > conditions.verifier[cIndex];
        bool isSlowUnderVerifier = conditions.slow[cIndex] < conditions.verifier[cIndex];

        //
        bool isSlowOverVerifierPrev = conditions.slow[pIndex] > conditions.verifier[pIndex];
        bool isSlowUnderVerifierPrev = conditions.slow[pIndex] < conditions.verifier[pIndex];

        //
        bool isSlowCrossedOverVerifier = isSlowOverVerifier &&
                                         !isSlowOverVerifierPrev;
        bool isSlowCrossedUnderVerifier = isSlowUnderVerifier &&
                                          !isSlowUnderVerifierPrev;

        //
        conditions.isSlowOverVerifier = isSlowOverVerifier;
        conditions.isSlowUnderVerifier = isSlowUnderVerifier;
        conditions.isSlowCrossedOverVerifier = isSlowCrossedOverVerifier;
        conditions.isSlowCrossedUnderVerifier = isSlowCrossedUnderVerifier;

        //
        XOHCL cBar;
        cBar.Init(
            mSymbol,
            mPeriod,
            cIndex //
        );

        //
        XOHCL pBar;
        pBar.Init(
            mSymbol,
            mPeriod,
            pIndex //
        );

        //
        bool isSARBullish = conditions.psar[cIndex] < cBar.low;
        bool isSARBearish = conditions.psar[cIndex] > cBar.high;

        //
        bool isSARBullishPrev = conditions.psar[pIndex] < pBar.low;
        bool isSARBearishPrev = conditions.psar[pIndex] > pBar.high;

        //
        bool isSARSwitchedToBullish = isSARBullish &&
                                      !isSARBullishPrev;
        bool isSARSwitchedToBearish = isSARBearish &&
                                      !isSARBearishPrev;

        //
        conditions.isSARBullish = isSARBullish;
        conditions.isSARBearish = isSARBearish;
        conditions.isSARSwitchedToBullish = isSARSwitchedToBullish;
        conditions.isSARSwitchedToBearish = isSARSwitchedToBearish;

        //
        return result;
    }

    //
    // Protected ...
protected:
    //
    // Private ...
private:
    //
    // Props ...
    XMCInputs mInputs; // Inputs ...

    //
    // Buffers ...
    //
    double sarBuffer[];
    double fastBuffer[];
    double slowBuffer[];
    double verifierBuffer[];

    //
    // Tools ...

    //
    // Calculate Values Until Now ...
    void Calculate()
    {
        //
        int totalBars = CountBars();
        if (totalBars > 1000) {
            totalBars = 1000;
        }

        //
        // Sar ...
        CopyBuffer(
            mHandler,
            XMC_SAR_LINE,
            0,
            totalBars,
            sarBuffer
            //
        );

        //
        // Fast ...
        CopyBuffer(
            mHandler,
            XMC_FAST_LINE,
            0,
            totalBars,
            fastBuffer
            //
        );

        //
        // Slow ...
        CopyBuffer(
            mHandler,
            XMC_SLOW_LINE,
            0,
            totalBars,
            slowBuffer
            //
        );

        //
        // Verifier ...
        CopyBuffer(
            mHandler,
            XMC_VERIFIER_LINE,
            0,
            totalBars,
            verifierBuffer
            //
        );
    }
};

//
// Tools ...