//////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 Indicator
// ---------------------------------------------
// Name: XSTR
// Description: Super Trend Indicator ...
//
//
// Maintainer:
// ------------
// Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com)
//
//////////////////////////////////////////////////////
//
// Global Properties ...
#property copyright "Copyright 2023, SaherElm IT Center"
#property link "https://saherelm.ir"
#property version "1.00"
#property description "SaherElm X121_XAMA Indicator"
#property strict

//
// START Constants ...
//

#define ShortName "XSTR"

//
// END Constants ...
//

//
// START Inputs ...
//

//
// Market ...
input group "ATR";
input int atrLength = 14;                             // Length
input double atrMultiplier = 3.0;                     // Multiplier
input ENUM_APPLIED_PRICE atrAppliedTo = PRICE_MEDIAN; // Applied To

//
// Presentation ...
input group "Presentation";
input bool showTrends = true; // Show Trends
input bool fillTrends = true; // Fill Trends

//
// END Inputs ...
//

//
// Includes Common Library ...
#include "../Libraries/x-saherelm.common.lib.mq5"

//
// START Buffers ...
//

//
#property indicator_chart_window

//
#property indicator_buffers 9
#property indicator_plots 2

//
#define fillUpBufferIndex 0
double fillUpBuffer[];

#define fillDownBufferIndex 1
double fillDownBuffer[];

//
#define fillingPlotBufferIndex 0

//
#property indicator_label1 "XSTR Filling"
#property indicator_type1 DRAW_FILLING
#property indicator_color1 clrBisque, clrPaleGreen

//
#define mainBufferIndex 2
#define mainPlotBufferIndex 1
double mainBuffer[];

//
#define mainColorBufferIndex 3
double mainColorBuffer[];

//
#property indicator_label2 "XSTR"
#property indicator_type2 DRAW_COLOR_LINE
#property indicator_color2 CLR_NONE, clrGreen, clrDarkRed
#property indicator_style2 STYLE_DOT

//
// DATA Buffers ...

//
#define atrBufferIndex 4
double atrBuffer[];

//
#define trendBufferIndex 5
double trendBuffer[];

//
#define upBufferIndex 6
double upBuffer[];

//
#define downBufferIndex 7
double downBuffer[];

//
#define priceBufferIndex 8
double priceBuffer[];

//
// END Buffers ...
//

//
// START Global Definitions: Variables, Properties and etc ...
//

//
int maxLength;

//
int atrHandler = INVALID_HANDLE;

//
int changeOfTrend;
int startBearishTrend;
int startBullishTrend;

//
// END Global Definitions: Variables, Properties and etc ...
//

//
// START Event Handlers ...
//

//
// Initialization ...
int OnInit()
{
    //
    // Validate Inputs ...
    if (!ValidateInputs())
    {
        return INIT_PARAMETERS_INCORRECT;
    }

    //
    // because in some cases we may have more than one input for
    // calculation and we must prevent any calculation
    // untill we pass the biggest input length, here we get max Input length
    // and then wait until pass it ...
    maxLength = ExtractMaxLengthOfInputs();

    //
    atrHandler = iATR(
        _Symbol,
        _Period,
        atrLength);
    if (atrHandler == INVALID_HANDLE)
    {
        return INIT_FAILED;
    }

    //
    // Define Index Buffers ...
    DefineBuffers();

    //
    // Set Indicator ShortName ...
    SetIndicatorName();

    //
    // Init Succeed ...
    return INIT_SUCCEEDED;
}

//
// DeInitialization ...
void OnDeinit(const int reason)
{
    //
    // REASON_PROGRAM 0 The EA has stopped working calling the ExpertRemove() function
    // REASON_REMOVE 1 Program removed from a chart
    // REASON_RECOMPILE 2 Program recompiled
    // REASON_CHARTCHANGE 3 A symbol or a chart period is changed
    // REASON_CHARTCLOSE 4 Chart closed
    // REASON_PARAMETERS 5 Inputs changed by a user
    // REASON_ACCOUNT 6 Another account has been activated or reconnection to the trade server has occurred due to changes in the account settings
    // REASON_TEMPLATE 7 Another chart template applied
    // REASON_INITFAILED 8 The OnInit() handler returned a non-zero value
    // REASON_CLOSE 9 Terminal closed

    //
    // Here we can handle De Initialization Reasons ...
    IndicatorRelease(atrHandler);
}

//
// Calculating what we want ...
int OnCalculate(
    const int rates_total,     // Total Bars on Chart ...
    const int prev_calculated, // Total Calculated Bars on Charts ...
    const datetime &time[],    // History of Open Time ...
    const double &open[],      // History of Open Price ...
    const double &high[],      // History of High Price ...
    const double &low[],       // History of Low Price ...
    const double &close[],     // History of Close Price ...
    const long &tick_volume[], // History of Tick Volumes on Bar ...
    const long &volume[],      // History of Trade Volumes ...
    const int &spread[]        // History of Spread Price ...
)
{
    //
    int numOfRequiredAtrs;
    if (prev_calculated > rates_total || prev_calculated < 0)
    {
        numOfRequiredAtrs = rates_total;
    }
    else
    {
        //
        numOfRequiredAtrs = rates_total - prev_calculated;
        if (prev_calculated > 0)
        {
            numOfRequiredAtrs++;
        }
    }

    //
    // Checking for stop ...
    if (IsStopped())
    {
        return 0;
    }

    //
    // Check Number of items Copy or not ...
    int copiedATRs = CopyBuffer(atrHandler, 0, 0, numOfRequiredAtrs, atrBuffer);
    if (copiedATRs <= 0)
    {
        return 0;
    }

    //
    int limit;

    //
    // checking for the limit start of calculation of an indicator ...
    if (prev_calculated > rates_total || prev_calculated <= 0)
    {
        //
        // starting index for calculation of all bars ...
        limit = maxLength;
    }
    else
    {
        //
        // starting number for calculation of new bars
        limit = prev_calculated - 1;
    }

    //
    // Main Loop ...
    for (int i = limit; i < rates_total && !IsStopped(); i++)
    {
        //
        // Calculated Price ...
        double price = getPrice(
            atrAppliedTo,
            open,
            high,
            low,
            close,
            i);
        // price = (high[i] + low[i]) / 2;
        priceBuffer[i] = price;

        //
        double atr = atrBuffer[i];

        //
        // Up ...
        upBuffer[i] = price + (atrMultiplier * atr);

        //
        // Down ...
        downBuffer[i] = price - (atrMultiplier * atr);

        //
        if (close[i] > upBuffer[i - 1])
        {
            //
            trendBuffer[i] = 1;
            if (trendBuffer[i - 1] == -1)
            {
                changeOfTrend = 1;
            }
        }
        else if (close[i] < downBuffer[i - 1])
        {
            //
            trendBuffer[i] = -1;
            if (trendBuffer[i - 1] == 1)
            {
                changeOfTrend = 1;
            }
        }
        else if (trendBuffer[i - 1] == 1)
        {
            //
            trendBuffer[i] = 1;
            changeOfTrend = 0;
        }
        else if (trendBuffer[i - 1] == -1)
        {
            //
            trendBuffer[i] = -1;
            changeOfTrend = 0;
        }

        //
        // Down Trend Starting ...
        if (trendBuffer[i] < 0 && trendBuffer[i - 1] > 0)
        {
            startBearishTrend = 1;
        }
        else
        {
            startBearishTrend = 0;
        }

        //
        // Up Trend Starting ...
        if (trendBuffer[i] > 0 && trendBuffer[i - 1] < 0)
        {
            startBullishTrend = 1;
        }
        else
        {
            startBullishTrend = 0;
        }

        //
        if (trendBuffer[i] > 0 && downBuffer[i] < downBuffer[i - 1])
        {
            downBuffer[i] = downBuffer[i - 1];
        }

        //
        if (trendBuffer[i] < 0 && upBuffer[i] > upBuffer[i - 1])
        {
            upBuffer[i] = upBuffer[i - 1];
        }

        //
        if (startBearishTrend == 1)
        {
            upBuffer[i] = priceBuffer[i] + (atrMultiplier * atr);
        }

        //
        if (startBullishTrend == 1)
        {
            downBuffer[i] = priceBuffer[i] - (atrMultiplier * atr);
        }

        //
        // Draw the indicator ...

        //
        double colorIDX = 0;
        mainColorBuffer[i] = colorIDX;

        //
        if (trendBuffer[i] == 1)
        {
            //
            mainBuffer[i] = downBuffer[i];
            if (changeOfTrend == 1)
            {
                mainBuffer[i - 1] = mainBuffer[i - 2];
                changeOfTrend = 0;
            }

            //
            colorIDX = 1;
        }
        else if (trendBuffer[i] == -1)
        {
            //
            mainBuffer[i] = upBuffer[i];
            if (changeOfTrend == 1)
            {
                //
                mainBuffer[i - 1] = mainBuffer[i - 2];
                changeOfTrend = 0;
            }

            //
            colorIDX = 2;
        }

        //
        if (showTrends)
        {
            mainColorBuffer[i] = colorIDX;
        }

        //
        // Filling ...
        if (fillTrends)
        {
            //
            fillUpBuffer[i] = mainBuffer[i];
            fillDownBuffer[i] = close[i];
        }
        else
        {
            //
            fillUpBuffer[i] = EMPTY_VALUE;
            fillDownBuffer[i] = EMPTY_VALUE;
        }
    }

    //
    return rates_total;
}

//
// END Event Handlers ...
//

//
// START Functions ...
//

//
// Validate Input Args for Initialization ...
bool ValidateInputs()
{
    //
    bool result = false;

    //
    // Validate Args ...
    result =
        //
        atrLength >= 2
        //
        ;

    //
    return result;
}

//
// Retrieve all Exists Input Max Length ...
// use for Start Of Drawing ...
int ExtractMaxLengthOfInputs()
{
    //
    int result = 0;

    //
    result = atrLength;

    //
    return result;
}

//
// Set Indicator Short Name and also we can define Buffers Labels ...
void SetIndicatorName()
{
    IndicatorSetString(INDICATOR_SHORTNAME, ShortName);
}

//
// Define Indexes and Styles ...
void DefineBuffers()
{
    //
    // PLOT Buffers ...

    //
    // FILLINGS ...
    SetIndexBuffer(fillUpBufferIndex, fillUpBuffer, INDICATOR_DATA);
    SetIndexBuffer(fillDownBufferIndex, fillDownBuffer, INDICATOR_DATA);
    PlotIndexSetInteger(fillingPlotBufferIndex, PLOT_SHOW_DATA, false);

    //
    // MAIN ...
    SetIndexBuffer(mainBufferIndex, mainBuffer, INDICATOR_DATA);
    PlotIndexSetInteger(mainPlotBufferIndex, PLOT_SHOW_DATA, showTrends);
    SetIndexBuffer(mainColorBufferIndex, mainColorBuffer, INDICATOR_COLOR_INDEX);

    //
    // DATA Buffers ...

    //
    // ATR ...
    SetIndexBuffer(atrBufferIndex, atrBuffer, INDICATOR_CALCULATIONS);

    //
    // TREND ...
    SetIndexBuffer(trendBufferIndex, trendBuffer, INDICATOR_CALCULATIONS);

    //
    // UP ...
    SetIndexBuffer(upBufferIndex, upBuffer, INDICATOR_CALCULATIONS);

    //
    // DOWN ...
    SetIndexBuffer(downBufferIndex, downBuffer, INDICATOR_CALCULATIONS);

    //
    // PRICE ...
    SetIndexBuffer(priceBufferIndex, priceBuffer, INDICATOR_CALCULATIONS);
}

//
// END Functions ...
//

//
// TEMPLATE Function ...

template <typename T>
double getPrice(ENUM_APPLIED_PRICE tprice, T &open[], T &high[], T &low[], T &close[], int i)
{
    switch (tprice)
    {
    case PRICE_CLOSE:
        return (close[i]);
    case PRICE_OPEN:
        return (open[i]);
    case PRICE_HIGH:
        return (high[i]);
    case PRICE_LOW:
        return (low[i]);
    case PRICE_MEDIAN:
        return ((high[i] + low[i]) / 2.0);
    case PRICE_TYPICAL:
        return ((high[i] + low[i] + close[i]) / 3.0);
    case PRICE_WEIGHTED:
        return ((high[i] + low[i] + close[i] + close[i]) / 4.0);
    }
    return (0);
}