///////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 Models Library
// ---------------------------------------
// Name: XModels
// Description: provides all required models ...
//
//
// 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

//
// START Inputs ...
//
//
// END Inputs ...
//

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

//
// START Provided Functions ...
//

//
// How To Calculate Static Volume ...
enum ENUM_STATIC_VOLUME_METHODS
{
    //
    // Based On Deposit ...
    X_STATIC_VOLUME_BASED_ON_DEPOSIT,
    //
    // Based On Balance ...
    X_STATIC_VOLUME_BASED_ON_BALANCE,
};

//
// START Model Definitions ...
//
//
// OHCL Candel Model ...
enum ENUM_X_PRICE
{
    X_PRICE_HIGH,
    X_PRICE_OPEN,
    X_PRICE_CLOSE,
    X_PRICE_LOW
};

//
// Swing Types Enum ...
enum ENUM_X_SWING_TYPE
{
    X_NO_SWING = 0,
    X_SWING_HIGH = 1,
    X_SWING_LOW = -1,
};

//
// Select Positions Type ...
enum ENUM_X_POSITION_SELECT_METHODS
{
    X_POSITION_SELECT_NONE, // None
    X_POSITION_SELECT_MAX,  // Max
    X_POSITION_SELECT_MIN,  // Min
    X_POSITION_SELECT_ALL,  // Min
};

//
// Available Guard Action ...
enum ENUM_X_GUARD_ACTIONS
{
    X_GUARD_ACTION_NOTHING,               // Nothing
    X_GUARD_ACTION_HEDGE,                 // Hedge
    X_GUARD_PARTIAL_CLOSE,                // Partial Close
    X_GUARD_ACTION_TRAIL_STOP,            // Trail StopLoss
    X_GUARD_ACTION_FORCE_CLOSE,           // Force Close
    X_GUARD_ACTION_ADD_SUPPORT_SIGNAL,    // Add Support Signal
    X_GUARD_ACTION_CANCEL_PENDING_ORDERS, // Cancel Pending Orders
};

//
// Model Guard Info ...
struct XGuard
{
    string symbol;
    string provider;
    ENUM_TIMEFRAMES period;
    ENUM_POSITION_TYPE type;
    ENUM_X_GUARD_ACTIONS action;

    //
    double dblPayLoad;
    string strPayload;
};

//
// Describe an Specific Candle ...
struct XOHCL
{
    double high;
    double open;
    double close;
    double low;
};

//
// Model Support and Resistance
// for Specific Bar ...
struct XOHCLSupRes
{
    //
    double res[];

    //
    double sup[];
};

//
// Available Order Modes ...
enum ENUM_X_ORDER_MODES
{
    X_ORDER_MODE_MARKET = 0,     // Market Order
    X_ORDER_MODE_STOP = 1,       // Pending Stop Order
    X_ORDER_MODE_LIMIT = 2,      // Pending Limit Order
    X_ORDER_MODE_STOP_LIMIT = 3, // Pending Stop Limit Order
};

//
// Model a Signal ...
struct XSignal
{
    //
    string providers[];

    //
    string symbol;

    //
    ENUM_TIMEFRAMES period;

    //
    ENUM_POSITION_TYPE type;

    //
    ENUM_X_ORDER_MODES mode;

    //
    double entry;

    //
    double riskAmount;

    //
    double tp;

    //
    double sl;

    //
    double r2r;

    //
    double volume;

    //
    bool calculateTP;

    //
    bool ignoreSL;
    bool ignoreTP;

    //
    bool useSupportAndResistance;

    //
    bool useRiskAmountAsVolume;

    //
    // Support Signals ...
    XSignal supports[];

    //
    XOHCLSupRes supportAndResistance;
};
//
// EXTENSION Methods ...

//
// Clear an Specific Signal Item ...
void Clean(XSignal &item)
{
    //
    Clean(item.providers);

    //
    Clean(item.supports);

    //
    Clean(item.supportAndResistance);

    //
    item.symbol = "";
    item.type = NULL;
    item.mode = NULL;
    item.period = NULL;

    //
    item.tp = 0;
    item.sl = 0;
    item.r2r = 0;
    item.entry = 0;
    item.volume = 0;
    item.riskAmount = 0;

    //
    item.ignoreSL = false;
    item.ignoreTP = false;
    item.calculateTP = false;
    item.useRiskAmountAsVolume = false;
    item.useSupportAndResistance = false;
}

//
void Clean(XOHCLSupRes &item)
{
    Clean(item.sup);
    Clean(item.res);
}

template <typename T>
void Add(
    T &item,
    T &buffer[])
{
    //
    ArrayResize(
        buffer,
        ArraySize(buffer) + 1);

    //
    buffer[ArraySize(buffer) - 1] = item;
}

template <typename T>
void Clean(T &buffer[])
{
    //
    ArrayFree(buffer);
    ArrayResize(buffer, 0);
}

template <typename T>
void Copy(
    T &source[],          // Source Buffer ...
    T &dest[],            // Dest Buffer ...
    bool cleanDest = true // Force Clen Dest Buffer ...
)
{
    //
    if (cleanDest)
    {
        Clean(dest);
    }

    //
    int sourceCount = ArraySize(source);
    if (sourceCount <= 0)
    {
        return;
    }

    //
    for (int i = 0; i < sourceCount; i++)
    {
        //
        T iSource = source[i];

        //
        Add(
            iSource,
            dest);
    }
}

//
// END Provided Functions ...
//