MQLArticles/RM/RiskManagement.mqh

<EFBFBD><EFBFBD>//+------------------------------------------------------------------+

//|                                               RiskManagement.mqh |

//|                                  Copyright 2025, Niquel Mendoza. |

//|                     https://www.mql5.com/es/users/nique_372/news |

//+------------------------------------------------------------------+

#property copyright "Copyright 2025, Niquel Mendoza."

#property link      "https://www.mql5.com/es/users/nique_372/news"

#property strict



#ifndef MQLARTICLES_RM_RISKMANAGEMENT_MQH

#define MQLARTICLES_RM_RISKMANAGEMENT_MQH



#include "RM_Hooks.mqh"



/*

ADVERTENCIA al momeneto de a<EFBFBD>adir items a esta clase, esta si son dinamicos las eliminara cuidado, como un modificador.

WARNING when adding items to this class, if they are dynamic, it will remove them carefully, as a modifier.

*/



//open_positions

//+-----------------------------------------------------------------+

//| Clase Base CRiskManagement                                       |

//+------------------------------------------------------------------+

class CRiskManagemet : public CRiskManagemetBase

 {

protected:

  //---

  CGetLote*          get_lote;



  //---

  double             chosen_balance;



  //--- Extra Variables

  ENUM_GET_LOT       type_get_lot;



  //-- main variables

  long               StopLoss; //StopLoss

  double             lote; //Last recorded lot



  //--- variables to store the values of the maximum losses

  double             nmlpo; //last expected loss

  bool               is_init; //flag indicating if it is init



  //--- variables that store percentages and enumeration, which will be used for the subsequent calculation of losses

  CLossProfitManager* loss_profits_manager;



  //--- Modifiers

  CRiskManagemeHookManager* m_hooks;

  bool               isCachedModifier[LOSS_PROFIT_COUNT];



  //--- general function to assign values to loss variables

  virtual double     GetValorWithApplied(double percentage_, ENUM_TYPE_LOSS_PROFIT type, ENUM_APPLIED_PERCENTAGES applied) const override;



  //--- Update profits function

  void               UpdateProfit(const double &profit, const double& acc_total_profit);

  virtual void       OnOpenTrade() { }

  virtual void       OnCloseTrade() { }



  //---

  virtual FuncionLossProfitSuperate SuperateModeToFunctionProfit(ENUM_TYPE_LOSS_PROFIT type) const;

  virtual FuncionLossProfitSuperate SuperateModeToFunctionLoss(ENUM_TYPE_LOSS_PROFIT type) const;



  //---

  virtual void*      GetPtrLossProfits() { return &this; }





public:

  //--- Constructor and Destructor

                     CRiskManagemet(ulong _magic, ENUM_GET_LOT type_get_lot_);

                    ~CRiskManagemet();



  //--- Set

  void               EndAddProfitLoss();

  virtual void       SetGeneralParameters(MqlParam &params[]) = 0;

  void               SetLote(CGetLote* lote_ptr);

  inline void        SetStopLoss(double dist_open_sl) { this.StopLoss = (long)ConvertPriceToPoints(_Symbol, dist_open_sl);  }

  inline void        SetStopLoss(long _sl_point_)     { this.StopLoss = _sl_point_;                                         }



  //--- Get losses and profits

  const CLossProfit* const GetLossOrProfit(const ENUM_TYPE_LOSS_PROFIT _type) const { return loss_profits_manager[_type]; }



  //--- Superated funcionts

  const CLossProfitManager* GetLossProfitManager() const { return loss_profits_manager; }



  //--- Add

  // Modificators

  bool               AddModificator(CExtraModifications* modificator); // Modificator pointer

  __forceinline bool AddModificator(CExtraModifications  &modificator) { return AddModificator(&modificator); }



  // Hook

  bool               AddRmHook(IRiskManagementHook* hook);

  __forceinline bool AddRmHook(IRiskManagementHook& hook) { return AddRmHook(&hook); }



  // Loss



  bool               AddLoss(double _percentage, ENUM_APPLIED_PERCENTAGES _applied, ENUM_RISK_CALCULATION_MODE _mode, ENUM_TYPE_LOSS_PROFIT type, bool strict,

                             bool is_dynamic = false, string percentages_to_activate = NULL, string risks_to_be_applied = NULL); // Loss



  // Profit

  bool               AddProfit(double _percentage, ENUM_APPLIED_PERCENTAGES _applied, ENUM_RISK_CALCULATION_MODE _mode, ENUM_TYPE_LOSS_PROFIT type, bool is_strict_,

                               bool is_dynamic = false, string percentages_to_activate = NULL, string risks_to_be_applied = NULL); // Profit



  //--- Functions inherited from CAccountGestor

  void               OnNewProfit(const ROnOpenClosePosition &profit) override;

  virtual void       OnOpenClosePosition(const ROnOpenClosePosition &pos) override;

  void               OnNewDay(const datetime& init_time, const datetime& curr_time) override;

  void               OnNewWeek(const datetime& init_time, const datetime& curr_time) override;

  void               OnNewMonth(const datetime& init_time, const datetime& curr_time) override;

  void               OnWithdrawalDeposit(double value) override;

  void               OnLossProfit(const double& p) override;



  //--- Get the lot using GMPLO and type_get_lot

  double             GetLote(ENUM_ORDER_TYPE type, double entry_price, ulong deviation, ulong stop_limit);



  //--- Obtain the SL by risk per operation

  long               GetSL(ENUM_ORDER_TYPE type, double entry_price, ulong deviation, ulong stop_limit);



  //--- Functions for working with the get lot size mod

  void                TypeGetLot(ENUM_GET_LOT new_get_mode) { this.type_get_lot = new_get_mode; }

  inline ENUM_GET_LOT TypeGetLot() const  { return this.type_get_lot; }



  //--- Magic number

  inline ulong       MagicNumber() const { return this.magic_number; }





  //--- Risk management type

  virtual inline ENUM_MODE_RISK_MANAGEMENT ModeRiskManagement() const = 0;

 };





//+------------------------------------------------------------------+

//| Constructor                                                      |

//+------------------------------------------------------------------+

CRiskManagemet::CRiskManagemet(ulong _magic, ENUM_GET_LOT type_get_lot_)

  :                CRiskManagemetBase(_magic)

 {



//---

  this.chosen_balance = AccountInfoDouble(ACCOUNT_BALANCE);

  for(int i = 0 ; i < LOSS_PROFIT_COUNT; i++)

   {

    isCachedModifier[i] = false;

   }





//---

  this.type_get_lot = type_get_lot_;

  loss_profits_manager = new CLossProfitManager();

  m_hooks = new CRiskManagemeHookManager();



//---

  AddLogger(loss_profits_manager);

  AddLogger(m_hooks);



//---

  for(int i = PositionsTotal() - 1; i >= 0; i--)

   {

    ulong position_ticket = PositionGetTicket(i);

    if(!PositionSelectByTicket(position_ticket))

      continue;



    ulong position_magic = PositionGetInteger(POSITION_MAGIC);

    ENUM_POSITION_TYPE type = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);



    if(position_magic == _magic || _magic == NOT_MAGIC_NUMBER)

     {

      Position new_pos;

      new_pos.type = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);

      new_pos.ticket = position_ticket;

      new_pos.profit = GetTotalPositionProfitNoCurrent(new_pos.ticket);

      new_pos.magic = _magic;

      AddArrayNoVerification2(open_positions, new_pos, RISK_MANAGEMENT_RESERVE_POS)

     }

   }

 }



//+------------------------------------------------------------------+

//| Destructor                                                       |

//+------------------------------------------------------------------+

CRiskManagemet::~CRiskManagemet()

 {

  CleanItems("RiskManagement");

 }



//+------------------------------------------------------------------+

//| Function to check if the maximum profit per day was exceeded     |

//+------------------------------------------------------------------+

__forceinline bool RiskMNormal_IsSuperatedProfit(const double& value, const double& saved_value, void* ptr)

 {

  return (account_status_curr_profit > value);

 }



//+------------------------------------------------------------------+

//| Boolean function to check if a loss was overcome                 |

//+------------------------------------------------------------------+

__forceinline bool RiskMNormal_IsSuperatedLoss(const double& value, const double& saved_value, void* ptr)

 {

  return (-account_status_curr_profit) > value;

 }



//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

FuncionLossProfitSuperate CRiskManagemet::SuperateModeToFunctionProfit(ENUM_TYPE_LOSS_PROFIT type) const

 {

  return RiskMNormal_IsSuperatedProfit;

 }



//+------------------------------------------------------------------+

FuncionLossProfitSuperate CRiskManagemet::SuperateModeToFunctionLoss(ENUM_TYPE_LOSS_PROFIT type) const

 {

  return RiskMNormal_IsSuperatedLoss;

 }







//+------------------------------------------------------------------+

//| SetLote function                                                 |

//+------------------------------------------------------------------+

void CRiskManagemet::SetLote(CGetLote *lote_ptr)

 {

  if(CheckPointer(lote_ptr) == POINTER_INVALID)

   {

    LogError("El puntero a CGetlote* es invalido", FUNCION_ACTUAL);

    return;

   }



//---

  if(CheckPointer(get_lote)) // is not equal to 0 (POINTER_INVALID)

   {

    if(CheckPointer(get_lote) == POINTER_DYNAMIC)

      delete get_lote;



    RemoveLogger(get_lote);

    AddLogger(lote_ptr);

    this.get_lote = lote_ptr;

    return;

   }

  else //Si es null

   {

    AddLogger(lote_ptr);

    this.get_lote = lote_ptr;

   }

 }



//+------------------------------------------------------------------+

//| Function that will be executed once all the                      |

//| Maximum profit and loss have been added                          |

//+------------------------------------------------------------------+

void               CRiskManagemet::EndAddProfitLoss()

 {

  if(is_init)

    return;

  LogInfo(StringFormat("The total size between maximum profit and loss is: %d", loss_profits_manager.SizeValids()), FUNCION_ACTUAL);

  loss_profits_manager.SetValues();

  this.is_init = true;

 }



//+------------------------------------------------------------------+

//| Function to add a maximum loss                                   |

//+------------------------------------------------------------------+

bool CRiskManagemet::AddLoss(double _percentage, ENUM_APPLIED_PERCENTAGES _applied, ENUM_RISK_CALCULATION_MODE _mode, ENUM_TYPE_LOSS_PROFIT type, bool strict,

                             bool is_dynamic = false, string percentages_to_activate = NULL, string risks_to_be_applied = NULL)

 {

//---

  if(_percentage <= 0.00)

   {

    LogWarning(StringFormat("Invalid percentage %.2f for lost profit %s, will not be added to the main array", _percentage, EnumToString(type)), FUNCION_ACTUAL);

    return false;

   }



//---

  if(_percentage > 100.00 && _mode == percentage)

   {

    LogWarning(StringFormat("Percentage %.2f for %s exceeds 100%%, limiting to 100%%", _percentage, EnumToString(type)), FUNCION_ACTUAL);

    _percentage = 100.00;

   }



//---

  const int index = int(type);

  if(index < 3)

   {

    LogError(StringFormat("Invalid maximum loss type: %s (index: %d)", EnumToString(type), index), FUNCION_ACTUAL);

    return false;

   }





//--- Creamos

  CLossProfit* new_loss = NULL;

  if(_mode == money)

    new_loss = new CLossProfitMoney(false, dynamic_cast<CRiskManagemetBase*>(&this));

  else

    new_loss = new CLossProfitPercentage(false, dynamic_cast<CRiskManagemetBase*>(&this));



//---

  new_loss.SetProperties(_percentage, _applied, type, SuperateModeToFunctionLoss(type), strict);



//---

  if(!loss_profits_manager.Add(new_loss))

   {

    delete new_loss;

    return false;

   }



//---

  new_loss.SetPtrSuperated(GetPtrLossProfits());



//---

  if(is_dynamic == true && percentages_to_activate != NULL && risks_to_be_applied != NULL)

   {

    if(!isCachedModifier[index])

     {

      new_loss.SetDynamic(percentages_to_activate, risks_to_be_applied, this.chosen_balance);

      LogInfo(StringFormat("Dynamic maximum loss %s successfully configured", EnumToString(type)), FUNCION_ACTUAL);

     }

    else

     {

      LogError(StringFormat("Maximum loss %s already has an active modifier", EnumToString(type)), FUNCION_ACTUAL);

     }

   }

  else

   {

    LogInfo(StringFormat("Maximum loss %s added: %.2f%%", EnumToString(type), _percentage), FUNCION_ACTUAL);

   }

  return true;

 }



//+------------------------------------------------------------------+

//| Function to add a maximum gain                                   |

//+------------------------------------------------------------------+

bool CRiskManagemet::AddProfit(double _percentage, ENUM_APPLIED_PERCENTAGES _applied, ENUM_RISK_CALCULATION_MODE _mode, ENUM_TYPE_LOSS_PROFIT type, bool is_strict_,

                               bool is_dynamic = false, string percentages_to_activate = NULL, string risks_to_be_applied = NULL)

 {

//---

  if(_percentage <= 0.00)

   {

    LogWarning(StringFormat("Invalid percentage %.2f for maximum gain %s, will not be added to the main array", _percentage, EnumToString(type)), FUNCION_ACTUAL);

    return false;

   }



//---

  if(_percentage > 100.00 && _mode == percentage)

   {

    LogWarning(StringFormat("Percentage %.2f for %s exceeds 100%%, limiting to 100%%", _percentage, EnumToString(type)), FUNCION_ACTUAL);

    _percentage = 100.00;

   }



//---

  const int index = int(type);



  if(index >= 3)

   {

    LogError(StringFormat("Invalid maximum gain type: %s (index: %d)", EnumToString(type), index), FUNCION_ACTUAL);

    return false;

   }



//---

  CLossProfit* new_profit = NULL;

  if(_mode == money)

    new_profit = new CLossProfitMoney(false, dynamic_cast<CRiskManagemetBase*>(&this));

  else

    new_profit = new CLossProfitPercentage(false, dynamic_cast<CRiskManagemetBase*>(&this));



//---

  new_profit.SetProperties(_percentage, _applied, type, SuperateModeToFunctionProfit(type), is_strict_);



//---

  if(!loss_profits_manager.Add(new_profit))

   {

    delete new_profit;

    return false;

   }



//---

  new_profit.SetPtrSuperated(GetPtrLossProfits());



//---

  if(is_dynamic == true && percentages_to_activate != NULL && risks_to_be_applied != NULL)

   {

    if(!isCachedModifier[index])

     {

      new_profit.SetDynamic(percentages_to_activate, risks_to_be_applied, this.chosen_balance);

      LogInfo(StringFormat("Maximum dynamic gain %s successfully set", EnumToString(type)), FUNCION_ACTUAL);

     }

    else

     {

      LogError(StringFormat("Maximum gain %s already has an active modifier", EnumToString(type)), FUNCION_ACTUAL);

     }

   }

  else

   {

    LogInfo(StringFormat("Maximum gain %s added: %.2f%%", EnumToString(type), _percentage), FUNCION_ACTUAL);

   }

  return true;

 }



//+------------------------------------------------------------------+

//| Function to add a risk modifier                                  |

//+------------------------------------------------------------------+

bool               CRiskManagemet::AddModificator(CExtraModifications *modificator)

 {

//--- Check pointer

  if(!CheckPointer(modificator))

   {

    LogError("The risk modifier is null-invalid", FUNCION_ACTUAL);

    return false;

   }



//--- Property to be modified is invalid ?

  const ENUM_TYPE_LOSS_PROFIT loss_or_profit = modificator.MaximumProfitOrLossAModify();

  if(loss_or_profit == WRONG_VALUE)

   {

    LogError("The risk modifier does not modify any risk.", FUNCION_ACTUAL);

    return false;

   }



//--- Property to modify is "empty" ?

  if(loss_profits_manager[loss_or_profit].IsEmpty())

   {

    LogError(StringFormat("The property to be modified %s is not defined", EnumToString(loss_or_profit)), FUNCION_ACTUAL);

    return false;

   }



//--- Is the loss_or_profit already dynamic ?

  if(loss_profits_manager[loss_or_profit].IsDynamicMode())

   {

    LogError(StringFormat("The property to be modified %s is already dynamic", EnumToString(loss_or_profit)), FUNCION_ACTUAL);

    return false;

   }



//---

  const int index = int(loss_or_profit);



  if(isCachedModifier[index])

   {

    LogWarning(StringFormat("The property to be modified %s is already being modified", EnumToString(loss_or_profit)), FUNCION_ACTUAL);

    return false;

   }



//---

  modificator.SetPointer(loss_profits_manager[loss_or_profit]);

  ModfierInitInfo init;

  init.balance = this.chosen_balance;

  init.magic = this.magic_number;

  modificator.OnInitModifier(init);



  LogCaution(StringFormat("The modifier '%s' is being added\nThis will modify the property '%s'", modificator.Name(), loss_profits_manager[loss_or_profit].Name()), FUNCION_ACTUAL);



//--- Add

  m_hooks.AddItemFast(modificator); // We use the fast version (we already did all the checkpointer checks etc.)



//---

  isCachedModifier[index] = true;

  return true;

 }



//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

bool CRiskManagemet::AddRmHook(IRiskManagementHook *hook)

 {

//--- Check pointer

  if(!CheckPointer(hook))

   {

    LogError("The RM Hook is null-invalid", FUNCION_ACTUAL);

    return false;

   }

//--- Add

  m_hooks.AddItemFast(hook); // We use the fast version (we already did all the checkpointer checks etc.)

//---

  return true;

 }





//+----------------------------------------------------------------------------------+

//| Get the ideal stop loss based on a specified lot and the maximum loss per trade  |

//+----------------------------------------------------------------------------------+

long CRiskManagemet::GetSL(ENUM_ORDER_TYPE type, double entry_price, ulong deviation, ulong stop_limit)

 {

  if(loss_profits_manager[LP_GMLPO].IsEmpty())

   {

    LogCriticalError("GMLPO not configured: Stop Loss cannot be calculated", FUNCION_ACTUAL);

    Remover();

    return 0;