//+------------------------------------------------------------------+
//|                                             BollingerBandsEA.mq5 |
//|                                     Copyright 2024, Igor Widiger |
//|                         https://www.mql5.com/en/users/deinschanz |
//+------------------------------------------------------------------+
#property copyright "Copyright 2024, Igor Widiger"
#property link      "https://www.mql5.com/en/users/deinschanz"
#property version   "2.00"


input ulong       Magic                      = 111111111111;            // Magic number
enum my_lots {
   fixed_volume                              = 1,                       // Fixed volume
   procent_volume                            = 2,                       // Procent volume
};
input my_lots     volumetype                 = procent_volume;          // Volume type

input double      Risk                       = 1;                       // Risk for Position
input double      Lots                       = 0.10;                    // Lots
input int         Stopp                      = 100;                     // Stoploss in points
input int         MinutesAfterSessionStart   = 420;                     // Trading (minutes) begins after session start
input int         MinutesBeforSessionStart   = 5;                       // Trading (minutes) end before session
input bool        ClosePos                   = false;                   // Close position after indicator
input bool        Trall                      = true;                    // Allow trailing stop?
input int         ProfitFactor               = 2;                       // Profit factor (RR) after stop is pulled
input bool        Break                      = false;                   // Allow breakeven?
input int         ProfitFactor2              = 1;                       // Profit factor (RR) after stop is pulled
input int         ClosePosMinutes            = 30;                      // Close position if it is in minus (after minutes)


#include <Trade/Trade.mqh>
#include <Trade/SymbolInfo.mqh>


int handleBp, handleMa;
static datetime timestamp;
static double lot = 0;

CTrade trade;
CSymbolInfo m_symbol;
CPositionInfo  m_position;
CHistoryOrderInfo m_history;
CDealInfo m_deal;

int OnInit() {

   handleBp  = iBands(_Symbol,PERIOD_CURRENT,20,0,2.000,PRICE_CLOSE);
   handleMa  = iMA(_Symbol,PERIOD_D1,100,0,MODE_SMA,PRICE_CLOSE);

   //---
   trade.SetExpertMagicNumber(Magic);
//---
   trade.SetMarginMode();
   trade.SetTypeFillingBySymbol(m_symbol.Name());

   return(INIT_SUCCEEDED);
}

void OnDeinit(const int reason) {


}

void OnTick() {


   // Sessioncheck
   if(IsInTradingSession(_Symbol) == false)  return;

   int bars             = iBars(_Symbol,PERIOD_CURRENT);

   datetime time        = iTime(_Symbol,PERIOD_CURRENT,0);

   double DayHigh       = iHigh(NULL,PERIOD_D1,0); // Day High Period
   double DayLow        = iLow(NULL,PERIOD_D1,0);  // Day Low Period
   double DayHigh1      = iHigh(NULL,PERIOD_D1,1); // Day High Period
   double DayLow1       = iLow(NULL,PERIOD_D1,1);  // Day Low Period

   double DayHighPrice  = 0;
   double DayLowPrice   = 0;
   double DayHighPrice1 = 0;
   double DayLowPrice1  = 0;

   if(timestamp        != time) {
      timestamp         = time;

      DayHighPrice      = DayHigh;
      DayLowPrice       = DayLow;

      DayHighPrice1     = DayHigh1;
      DayLowPrice1      = DayLow1;

   }

   double close1        = iClose(_Symbol,PERIOD_CURRENT,1);
   double high0         = iHigh(_Symbol,PERIOD_CURRENT,0);
   double low0          = iLow(_Symbol,PERIOD_CURRENT,0);
   double high1         = iHigh(_Symbol,PERIOD_CURRENT,1);
   double low1          = iLow(_Symbol,PERIOD_CURRENT,1);

   double ask           = SymbolInfoDouble(_Symbol,SYMBOL_ASK);
   ask = NormalizeDouble(ask,_Digits);
   double bid           = SymbolInfoDouble(_Symbol,SYMBOL_BID);
   bid = NormalizeDouble(bid,_Digits);


   double bbUpper[], bbLowwer[], bbMiddle[];
   CopyBuffer(handleBp,BASE_LINE,1,2,bbMiddle);
   CopyBuffer(handleBp,UPPER_BAND,1,2,bbUpper);
   CopyBuffer(handleBp,LOWER_BAND,1,2,bbLowwer);

   // Range middle upper and lowwer line
   double rangeUpper = (bbUpper[1] - bbMiddle[1])/_Point;
   double rangeLowwer = (bbMiddle[1] -bbLowwer[1])/_Point;

   // Ma indikator
   double ma[];
   CopyBuffer(handleMa,MAIN_LINE,1,1,ma);


   // Close position after indicator
   if(ClosePos == true) {
      for(int i=PositionsTotal()-1; i>=0; i--) // Returns the number of open positions
         if(m_position.SelectByIndex(i)) {
            //---
            if(m_position.Symbol()== _Symbol && m_position.Magic()==Magic) { // Checks for symbol and magic number
               if(m_position.PositionType()==POSITION_TYPE_BUY) {

                  if(bid >= bbMiddle[0]) {
                     ClosePos(_Symbol);
                  }

               } else {
                  if(ask <= bbMiddle[0]) {
                     ClosePos(_Symbol);
                  }

               }

            }
         }
   }

   // Trailingstop
   if(Trall == true) {
      Trailing(_Symbol);
   }
   // Breakeven
   if(Break == true) {
      Breakeven(_Symbol);
   }

   // End trade after time if order is positiv
   datetime AktZeit=TimeCurrent();
   HistorySelect(0,TimeCurrent());
   for(int pos=HistoryDealsTotal()-1; pos>=0; pos--) {
      if(m_position.SelectByIndex(pos)) {
         // Read deal out and get deal time
         if(m_position.Symbol()==_Symbol && m_position.Magic()==Magic) {
            datetime close_time = m_position.Time();
            datetime adierentime = close_time + (ClosePosMinutes*60);

            if(AktZeit >= adierentime && AProfit() > 0) {
               ClosePos(_Symbol);
               return;
            }
         }
      }
   }

   // Start trading for profit the next day!
   if(Profit(0) > 0) {
      return;
   }


   if(CalculateOnePositions(_Symbol) >= 1)
      return;

   if(close1 > bbUpper[1] && bid > bbUpper[1] && rangeUpper > Stopp*2 && ask < ma[0]) {
      if(bid > DayHighPrice || bid > DayHighPrice1) {

         if(ProfitSell(0) < 0) return;

         double newSl = 0;
         if(high1 > high0) {
            newSl = high1;
         } else if(high1 < high0) {
            newSl = high0;
         } else {
            return;  // Kein Trade
         }

         double sl      = newSl + Stopp*_Point;
         double tp      = DayLow;



         // Calculate SL in points
         double Points  = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
         double SlPoints = (sl - ask) / _Point;

         if(volumetype == 2) {
            lot = NormalizeDouble(LotsByRisk(ORDER_TYPE_SELL,Risk,(int)SlPoints,_Symbol,Points),2);
         } else {
            lot= Lots;
         }


         double volume = lot;
         volume=LotCheck(volume, _Symbol);
         if(volume==0)
            return;

         if(!CheckStopLoss_Takeprofit(ORDER_TYPE_SELL,sl,tp)) {
            return;
         }
         double max_volume=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_LIMIT);
         double current_lots=getAllVolume();

         if(max_volume>0 && max_volume-volume<=0) {
            return;
         }

         trade.Sell(volume,_Symbol,bid,sl,tp);
      }
   } else if(close1 < bbLowwer[1] && ask < bbLowwer[1] && rangeLowwer > Stopp*2 && bid > ma[0]) {
      if(ask < DayLowPrice || ask < DayLowPrice1) {

         if(ProfitBuy(0) < 0) return;

         double newSl = 0;
         if(low1 > low0) {
            newSl = low0;
         } else if(low1 < low0) {
            newSl = low1;
         } else {
            return;  // Kein Trade
         }
         double sl      = newSl - Stopp*_Point;
         double tp      = DayHigh;

         // Calculate SL in points
         double Points  = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
         double SlPoints = (bid - sl)/_Point;

         if(volumetype == 2) {
            lot = NormalizeDouble(LotsByRisk(ORDER_TYPE_BUY,Risk,(int)SlPoints,_Symbol,Points),2);
         } else {
            lot= Lots;
         }

         double volume = lot;
         volume=LotCheck(volume, _Symbol);
         if(volume==0)
            return;

         if(!CheckStopLoss_Takeprofit(ORDER_TYPE_BUY,sl,tp)) {
            return;
         }
         double max_volume=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_LIMIT);
         double current_lots=getAllVolume();

         if(max_volume>0 && max_volume-volume<=0) {
            return;
         }

         trade.Buy(volume,_Symbol,ask,sl,tp);
      }
   }




}
//+------------------------------------------------------------------+
//| Calculate one positions                                          |
//+------------------------------------------------------------------+
int CalculateOnePositions(string ssymBol) {
   int total=0;
   for(int i=PositionsTotal()-1; i>=0; i--)
      if(m_position.SelectByIndex(i)) // selects the position by index for further access to its properties
         if(m_position.Symbol() == ssymBol && m_position.Magic()==Magic) { // Checks by magic number end Symbol
            total++;
            //---
         }
   return(total);
}
//+------------------------------------------------------------------+
// Close position function
void ClosePos(string symbolss) {
   for(int i=PositionsTotal()-1; i>=0; i--)
      if(m_position.SelectByIndex(i))
         if(m_position.Symbol()== _Symbol && m_position.Magic()==Magic) { // Checks by symbol and magic number
            trade.PositionClose(m_position.Ticket());
         }
}
//------------- Profit sell ausrechnen Funktion ---------------------------
double ProfitSell(int ai_0) {

// HistorySelect(von_datum,zum_datum);
   HistorySelect(iTime(_Symbol,PERIOD_D1,ai_0),iTime(_Symbol,PERIOD_D1,ai_0)+60*60*24);
   double gewonnene_trade=0.0;
   double verlorene_trade=0.0;
   double total_profit=0.0;
   uint total=HistoryDealsTotal();
   ulong    ticket=0;

//--- for all deals
   for(uint i=0; i<total; i++) {
      //--- Sucht nach Tickets die grösser als Null sind
      if((ticket=HistoryDealGetTicket(i))>0) {
         long entry=HistoryDealGetInteger(ticket,DEAL_ENTRY);
         if(entry==DEAL_ENTRY_IN)
            continue;

         string          symbol = HistoryDealGetString(ticket,DEAL_SYMBOL);
         long       order_magic = HistoryDealGetInteger(ticket,DEAL_MAGIC);
         double deal_commission = HistoryDealGetDouble(ticket,DEAL_COMMISSION);
         double       deal_swap = HistoryDealGetDouble(ticket,DEAL_SWAP);
         double     deal_profit = HistoryDealGetDouble(ticket,DEAL_PROFIT);
         double profit=deal_commission+deal_swap+deal_profit;

         ENUM_DEAL_TYPE  deal_type= (ENUM_DEAL_TYPE)HistoryDealGetInteger(ticket, DEAL_TYPE);
         long dreason= (int)HistoryDealGetInteger(ticket,DEAL_REASON);

         if(deal_type!=DEAL_TYPE_BUY)
            continue;

         if(order_magic==Magic) {
            //... processing of deal with some DEAL_MAGIC
            if(symbol==_Symbol && dreason==(DEAL_REASON_SL)) {
               if(profit<0.0)
                  verlorene_trade+=profit;
               total_profit+=profit;
            }
         }
      }
   }
   return(total_profit);
}
//------------- Profit sell ausrechnen Funktion ---------------------------
double ProfitBuy(int ai_0) {

// HistorySelect(von_datum,zum_datum);
   HistorySelect(iTime(_Symbol,PERIOD_D1,ai_0),iTime(_Symbol,PERIOD_D1,ai_0)+60*60*24);
   double gewonnene_trade=0.0;
   double verlorene_trade=0.0;
   double total_profit=0.0;
   uint total=HistoryDealsTotal();
   ulong    ticket=0;

//--- for all deals
   for(uint i=0; i<total; i++) {
      //--- Searches for tickets greater than zero
      if((ticket=HistoryDealGetTicket(i))>0) {
         long entry=HistoryDealGetInteger(ticket,DEAL_ENTRY);
         if(entry==DEAL_ENTRY_IN)
            continue;

         string          symbol = HistoryDealGetString(ticket,DEAL_SYMBOL);
         long       order_magic = HistoryDealGetInteger(ticket,DEAL_MAGIC);
         double deal_commission = HistoryDealGetDouble(ticket,DEAL_COMMISSION);
         double       deal_swap = HistoryDealGetDouble(ticket,DEAL_SWAP);
         double     deal_profit = HistoryDealGetDouble(ticket,DEAL_PROFIT);
         double profit=deal_commission+deal_swap+deal_profit;


         ENUM_DEAL_TYPE  deal_type= (ENUM_DEAL_TYPE)HistoryDealGetInteger(ticket, DEAL_TYPE);
         if(deal_type!=DEAL_TYPE_SELL)
            continue;

         long dreason= (int)HistoryDealGetInteger(ticket,DEAL_REASON);

         if(order_magic==Magic) {
            //... processing of deal with some DEAL_MAGIC
            if(symbol==_Symbol && dreason==(DEAL_REASON_SL)) {
               if(profit<0.0)
                  verlorene_trade+=profit;
               total_profit+=profit;
            }
         }
      }
   }
   return(total_profit);
}
//------------- Profit ausrechnen Funktion ---------------------------
double Profit(int ai_0) {

// HistorySelect(von_datum,zum_datum);
   HistorySelect(iTime(_Symbol,PERIOD_D1,ai_0),iTime(_Symbol,PERIOD_D1,ai_0)+60*60*24);
   double gewonnene_trade=0.0;
   double verlorene_trade=0.0;
   double total_profit=0.0;
   uint total=HistoryDealsTotal();
   ulong    ticket=0;

//--- for all deals
   for(uint i=0; i<total; i++) {
      //--- Sucht nach Tickets die grösser als Null sind
      if((ticket=HistoryDealGetTicket(i))>0) {
         long entry=HistoryDealGetInteger(ticket,DEAL_ENTRY);
         if(entry==DEAL_ENTRY_IN)
            continue;

         string          symbol = HistoryDealGetString(ticket,DEAL_SYMBOL);
         long       order_magic = HistoryDealGetInteger(ticket,DEAL_MAGIC);
         double deal_commission = HistoryDealGetDouble(ticket,DEAL_COMMISSION);
         double       deal_swap = HistoryDealGetDouble(ticket,DEAL_SWAP);
         double     deal_profit = HistoryDealGetDouble(ticket,DEAL_PROFIT);
         double profit=deal_commission+deal_swap+deal_profit;
         if(order_magic==Magic) {
            //... processing of deal with some DEAL_MAGIC
            if(symbol==_Symbol) {
               if(profit>0.0)
                  gewonnene_trade+=profit;
               if(profit<0.0)
                  verlorene_trade+=profit;
               total_profit+=profit;
            }
         }
      }
   }
   return(total_profit);
}
//+------------------------------------------------------------------+
double AProfit() {
   double pft=0;
   for(int i=PositionsTotal()-1; i>=0; i--) {
      ulong ticket=PositionGetTicket(i);
      if(ticket>0) {
         if(PositionGetInteger(POSITION_MAGIC)==Magic && PositionGetString(POSITION_SYMBOL)==_Symbol) {
            pft+=PositionGetDouble(POSITION_PROFIT);
         }
      }
   }
   return(pft);
}
//+------------------------------------------------------------------+
// Trailing in %  Function
void Trailing(string symssBol) {

   int total=0;
   for(int j=PositionsTotal()-1; j>=0; j--)
      if(m_position.SelectByIndex(j)) // selects the position by index for further access to its properties
         if(m_position.Symbol()== symssBol && m_position.Magic()==Magic) { // Checks by symbol and magic number
            total++;
         }

   if(total<=0) {
      //Trailing no Positions
      return;
   }

// Spannefunktion
   double RangeHigh      = iHigh(NULL,PERIOD_D1,0);
   double RangeLow       = iLow(NULL,PERIOD_D1,0);
   double RangeProzent  = NormalizeDouble(((RangeHigh - RangeLow) / RangeHigh * 100),2);
// 1
   double RangeHigh1      = iHigh(NULL,PERIOD_D1,1);
   double RangeLow1       = iLow(NULL,PERIOD_D1,1);
   double RangeProzent1  = NormalizeDouble(((RangeHigh1 - RangeLow1) / RangeHigh1 * 100),2);
// 2
   double RangeHigh2      = iHigh(NULL,PERIOD_D1,2);
   double RangeLow2       = iLow(NULL,PERIOD_D1,2);
   double RangeProzent2  = NormalizeDouble(((RangeHigh2 - RangeLow2) / RangeHigh2 * 100),2);
// 3
   double RangeHigh3      = iHigh(NULL,PERIOD_D1,3);
   double RangeLow3       = iLow(NULL,PERIOD_D1,3);
   double RangeProzent3  = NormalizeDouble(((RangeHigh3 - RangeLow3) / RangeHigh3 * 100),2);
// 4
   double RangeHigh4      = iHigh(NULL,PERIOD_D1,4);
   double RangeLow4       = iLow(NULL,PERIOD_D1,4);
   double RangeProzent4  = NormalizeDouble(((RangeHigh4 - RangeLow4) / RangeHigh4 * 100),2);

   double RangeGes = (RangeProzent + RangeProzent1 + RangeProzent2 + RangeProzent3 + RangeProzent4)/5;


// Trailling in procent
   int ProfitProzent;
   if(RangeProzent < RangeGes) {
      ProfitProzent = 50;
   } else {
      ProfitProzent = 75;
   }

   for(int i=PositionsTotal()-1; i>=0; i--) // Returns the number of open positions

      if(m_position.SelectByIndex(i)) {
         double price_current = m_position.PriceCurrent();
         double price_open    = m_position.PriceOpen();
         double stop_loss     = m_position.StopLoss();
         double take_profit   = m_position.TakeProfit();
         datetime price_time  = m_position.Time();


         //---
         if(m_position.Symbol()== symssBol && m_position.Magic()==Magic) { // Checks for symbol and magic number
            if(m_position.PositionType()==POSITION_TYPE_BUY) {


               int    digits=(int)SymbolInfoInteger(symssBol,SYMBOL_DIGITS); // number of decimal places
               double point=SymbolInfoDouble(symssBol,SYMBOL_POINT);         // point
               double Ask = NormalizeDouble(SymbolInfoDouble(symssBol,SYMBOL_ASK),digits); // Define Ask
               double Bid = NormalizeDouble(SymbolInfoDouble(symssBol,SYMBOL_BID),digits); // Define Bid
               double priceRangePoints = (Ask - price_open)/point;
               double price = price_open + (priceRangePoints/100*ProfitProzent)*point;

               // SL Range Buy
               double NeuSl = (((price_open - stop_loss)/point)*ProfitFactor);
               double SlRangeBuy = price_open + NeuSl * point;


               if(price > SlRangeBuy && price > stop_loss) {
                  trade.PositionModify(m_position.Ticket(),price+(100/ProfitProzent)*_Point,take_profit);
               }

            } else if(m_position.PositionType()==POSITION_TYPE_SELL) {

               int    digits=(int)SymbolInfoInteger(symssBol,SYMBOL_DIGITS); // number of decimal places
               double point=SymbolInfoDouble(symssBol,SYMBOL_POINT);         // point
               double Ask = NormalizeDouble(SymbolInfoDouble(symssBol,SYMBOL_ASK),digits); // Define Ask
               double Bid = NormalizeDouble(SymbolInfoDouble(symssBol,SYMBOL_BID),digits); // Define Bid
               double priceRangePoints = (price_open - Bid)/point;
               double price = price_open - (priceRangePoints/100*ProfitProzent)*point;

               // SL Range Sell
               double NeuSl = (((stop_loss - price_open)/point)*ProfitFactor);
               double SlRangeSell = price_open - NeuSl * point;


               if(price < SlRangeSell && stop_loss > price) {
                  trade.PositionModify(m_position.Ticket(),price-(100/ProfitProzent)*_Point,take_profit);
               }
            } else {

            }
         }
      }
   ChartRedraw(0);

}

// Breakeven
void Breakeven(string symBreakeven) {
   for(int i=PositionsTotal()-1; i>=0; i--) // Returns the number of open positions
      if(m_position.SelectByIndex(i)) {

         double price_current = m_position.PriceCurrent();
         double price_open    = m_position.PriceOpen();
         double stop_loss     = m_position.StopLoss();
         double take_profit   = m_position.TakeProfit();

         int    digits = (int)SymbolInfoInteger(symBreakeven,SYMBOL_DIGITS); // number of decimal places
         double point = SymbolInfoDouble(symBreakeven,SYMBOL_POINT);         // point
         ulong  Spread        = SymbolInfoInteger(_Symbol,SYMBOL_SPREAD);                      // Define Spread

         //---
         if(m_position.Symbol()== symBreakeven && m_position.Magic()==Magic) { // Checks for symbol and magic number
            if(m_position.PositionType()==POSITION_TYPE_BUY) {

               double SlNewPrice = 0.0;
               double SlRangeBuy = (price_open - stop_loss)/point;
               SlNewPrice  =  price_open + ((SlRangeBuy*ProfitFactor2)*point);


               if(stop_loss < price_open && price_current > SlNewPrice) {
                  if(price_current > price_open)
                     trade.PositionModify(m_position.Ticket(),price_open,take_profit);
               }
            } else {

               double SlNewPrice = 0.0;
               double SlRangeSell = (stop_loss - price_open)/point;
               SlNewPrice  =  price_open - ((SlRangeSell*ProfitFactor2)*point);

               if(stop_loss > price_open && price_current <  SlNewPrice) {
                  if(price_current< price_open)
                     trade.PositionModify(m_position.Ticket(),price_open,take_profit);
               }
            }
         }
      }
}
//+------------------------------------------------------------------+
bool IsInTradingSession(string symbole) {
   MqlDateTime mqt;
   if(TimeToStruct(TimeTradeServer(),mqt)) {
      //flatten
      ENUM_DAY_OF_WEEK dow=(ENUM_DAY_OF_WEEK)mqt.day_of_week;
      mqt.hour=0;
      mqt.min=0;
      mqt.sec=0;
      datetime base=StructToTime(mqt),get_from=0,get_to=0;
      //now loop in all the trading sessions
      uint session=0;
      while(SymbolInfoSessionTrade(symbole,dow,session,get_from,get_to)) {
         //so if this succeeds a session exists and fills up get from and get to , but it just fills up with hour , minute + second
         //that means we have to project it on the base time we flattened above for today
         get_from=(datetime)(base+get_from);
         get_to=(datetime)(base+get_to);
         //and we pump one session in
         session++;
         //and we check , if we happen to be inside that range , we return true because we can trade
         if(TimeTradeServer()>=get_from&&TimeTradeServer()<=get_to) {

            // Start trading after the specified time after the start of the season!
            datetime TimeStart = get_from + MinutesAfterSessionStart*60; // Start Trading
            datetime TimeSesEnd = get_to - MinutesBeforSessionStart*60;  // Ends Trading

            // Trading Start
            if(TimeTradeServer()>=get_from && TimeTradeServer()<= TimeStart) {
               return(true);
            }
            // trading end
            if(TimeTradeServer()<=get_to && TimeTradeServer()>= TimeSesEnd) {
               return(true);
            }

            return(true);
         } else {
            // Print("market closed: ");
         }
      }
   }
   return(false);
}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| Calculate Volume with stop in %                                  |
//+------------------------------------------------------------------+
double LotsByRisk(int op_type,double risk,int sloss, string Sym_Name, double points) {
   double  lot_min = SymbolInfoDouble(Sym_Name,SYMBOL_VOLUME_MIN);
   double  lot_max = SymbolInfoDouble(Sym_Name,SYMBOL_VOLUME_MAX);
   double lot_step = SymbolInfoDouble(Sym_Name,SYMBOL_VOLUME_STEP);
   double  lotcost = ((SymbolInfoDouble(Sym_Name, SYMBOL_TRADE_TICK_VALUE)*points)/(SymbolInfoDouble(Sym_Name,SYMBOL_TRADE_TICK_SIZE)));
   lot = 0.0;
   double UsdPerPip = 0.0;

   lot = AccountInfoDouble(ACCOUNT_BALANCE)*risk/100;
   UsdPerPip = lot/sloss;
   if(UsdPerPip <= 0.0)
      return(0);
   lot = NormalizeDouble(UsdPerPip/lotcost, 2);
   if(lot <= 0.0)
      return(0);
   lot = NormalizeDouble(lot/lot_step, 0) * lot_step;
   if(lot < lot_min)
      lot = lot_min;
   if(lot > lot_max)
      lot = lot_max;
   return(lot);
}
//+------------------------------------------------------------------+
//| Lot Check                                                        |
//+------------------------------------------------------------------+
double LotCheck(double lots, string SymName) {
//--- calculate maximum volume
   double volume=NormalizeDouble(lots,2);
   double stepvol=SymbolInfoDouble(SymName,SYMBOL_VOLUME_STEP);
   if(stepvol>0.0)
      volume=stepvol*MathFloor(volume/stepvol);
//---
   double minvol=SymbolInfoDouble(SymName,SYMBOL_VOLUME_MIN);
   if(volume<minvol)
      volume=0.0;
//---
   double maxvol=SymbolInfoDouble(SymName,SYMBOL_VOLUME_MAX);
   if(volume>maxvol)
      volume=maxvol;
   return(volume);
}
//+------------------------------------------------------------------+
// Check Sl TP
bool CheckStopLoss_Takeprofit(ENUM_ORDER_TYPE type,double SL,double TP) {

   double Ask           = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_ASK),_Digits);
   double Bid           = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_BID),_Digits);
//---  Let's get the SYMBOL_TRADE_STOPS_LEVEL level
   int stops_level=(int)SymbolInfoInteger(_Symbol,SYMBOL_TRADE_STOPS_LEVEL);
   if(stops_level!=0) {
      PrintFormat("SYMBOL_TRADE_STOPS_LEVEL=%d: StopLoss and TakeProfit must not be closer"+
                  " as %d points from the exit price",stops_level,stops_level);
   }
//---
   bool SL_check=false,TP_check=false;
//--- Let's examine only two types of orders
   switch(type) {
//--- The buying operation
   case  ORDER_TYPE_BUY: {
      //--- Let's check StopLoss
      SL_check=(Bid-SL>stops_level*_Point);
      if(!SL_check)
         PrintFormat("For order %s StopLoss=%.5f must be less than %.5f"+
                     " (Bid=%.5f - SYMBOL_TRADE_STOPS_LEVEL=%d points)",
                     EnumToString(type),SL,Bid-stops_level*_Point,Bid,stops_level);
      //--- Let's check TakeProfit
      TP_check=(TP-Bid>stops_level*_Point);
      if(!TP_check)
         PrintFormat("For order %s TakeProfit=%.5f must be greater than %.5f"+
                     " (Bid=%.5f + SYMBOL_TRADE_STOPS_LEVEL=%d points)",
                     EnumToString(type),TP,Bid+stops_level*_Point,Bid,stops_level);
      //--- we return the result of the verification
      return(SL_check&&TP_check);
   }
//--- The sale operation
   case  ORDER_TYPE_SELL: {
      //--- Let's check StopLoss
      SL_check=(SL-Ask>stops_level*_Point);
      if(!SL_check)
         PrintFormat("For order %s StopLoss=%.5f must be greater than %.5f "+
                     " (Ask=%.5f + SYMBOL_TRADE_STOPS_LEVEL=%d points)",
                     EnumToString(type),SL,Ask+stops_level*_Point,Ask,stops_level);
      //--- Let's check TakeProfit
      TP_check=(Ask-TP>stops_level*_Point);
      if(!TP_check)
         PrintFormat("For order %s TakeProfit=%.5f must be less than %.5f "+
                     " (Ask=%.5f - SYMBOL_TRADE_STOPS_LEVEL=%d points)",
                     EnumToString(type),TP,Ask-stops_level*_Point,Ask,stops_level);
      //--- we return the result of the verification
      return(TP_check&&SL_check);
   }
   break;
   }
//--- For the pending orders you need another function
   return false;
}
//+------------------------------------------------------------------+
//volume counting function
double getAllVolume() {
   int itotal=PositionsTotal();
   ulong uticket=-1;
   double dVolume=0;

   for(int i=itotal-1; i>=0; i--) {
      if(!(uticket=PositionGetTicket(i))) continue;

      if(PositionGetString(POSITION_SYMBOL)==m_symbol.Name())
         dVolume+=PositionGetDouble(POSITION_VOLUME);
   }

   itotal=OrdersTotal();

   for(int i=itotal-1; i>=0; i--) {
      if(!(uticket=OrderGetTicket(i))) continue;

      if(OrderGetString(ORDER_SYMBOL)==m_symbol.Name())
         dVolume+=OrderGetDouble(ORDER_VOLUME_CURRENT);
   }

   return dVolume;
}
//+------------------------------------------------------------------+