//+------------------------------------------------------------------------------------------------------------------------------------------+
//|                                                                                                               ObserveCandle_ea_MT5_3.mq5 |
//+------------------------------------------------------------------------------------------------------------------------------------------+

/*------------------------------------------------------------------------------------------------------------------------ specification ---//

//------------------------------------------------------------------------------------------------------------------------------------------*/
#include <Trade\Trade.mqh> 

CTrade trade; 
//==========================================================================================================================================//
enum ENUM_AP_PRICE { CLOSE=0, OPEN=1, HIGH=2, LOW=3 };
//==========================================================================================================================================//
input string _1_="___ trade entry settings ___";
input double FixedLot=0.1;
input    int CandlesToObserve=3;
input double MinMovement=20.0;
input double StopLoss=0.0;
input double TakeProfit=0.0;
input   bool Use_TradingBan=true;
input    int TradingBan_sec=30;
input   bool Trailing=true;
input double TrailStart=20.0;
input double TrailStop=20.0;
input double TrailStep=1.0;
input string _2_="___ other settings ___";
input    int MagicNumber=25172;
input string TradeComment="";
input ENUM_TIMEFRAMES TF=PERIOD_CURRENT; 
input    int ExpirationTime_sec=3600; 
//===================================================================================================================== global variables ===//
 MqlTick tick; 
 
 datetime TimeNow, TimePrev;
 
   double TickSize, TickValue, Spread, StopLevel, MinLot, MaxLot, LotStep, Pnt,
          Total_result, Result;
     bool isBO, isSO, isO, _isBO, _isSO, _isO, 
          Ans, Activate, FreeMarginAlert, IsTester,
          IsModify;
//============================================================================================ The initialization function of the expert ===//
void OnInit() 
 {
  Activate=false; 
  
  if(MQL5InfoInteger(MQL5_TESTING) || MQL5InfoInteger(MQL5_OPTIMIZATION) || MQL5InfoInteger(MQL5_VISUAL_MODE)) IsTester=true; else IsTester=false;
  
  Pnt=_Point; 
   
  trade.SetExpertMagicNumber(MagicNumber);
  trade.SetDeviationInPoints(SymbolInfoInteger(_Symbol,SYMBOL_SPREAD));
  trade.SetTypeFilling(ORDER_FILLING_FOK);
  trade.SetAsyncMode(false);

  Activate=true; 
  return;
 }
//========================================================================================== The deinitialization function of the expert ===//
void OnDeinit(const int reason) 
 {
  Comment(""); 
  
  Obj_Del();
  
  if(!IsTester) {
   if(reason==0 || reason==1) { 
    GVD("IsModify"); GVD("TimePrev"); } }

  return;
 }
//====================================================================================================== The main function of the expert ===//
void OnTick() 
 {
  if(!Activate) return; 
  if(!GetLatestPrice()) return; 
  
  GetMarketInfo();

  drawFixedLbl("str1","ObserveCandles",0,25,25,14,"Courier New",clrLime);  
  drawFixedLbl("str2","Candles To Count="+IntegerToString(CandlesToObserve),0,25,50,14,"Courier New",clrLime);  
  double movement=0.0;  if(!isO && Time(CandlesToObserve-1,TF)>TimePrev) movement=(ND(Get_highest()-Get_lowest()))/Pnt;
  drawFixedLbl("str3","Movement="+DoubleToString(movement,1)+", Min="+DoubleToString(MinMovement,1),0,25,75,14,"Courier New",clrLime);  
  drawFixedLbl("str4","StopLoss="+DoubleToString(StopLoss,1)+", TakeProfit="+DoubleToString(TakeProfit,1),0,25,100,14,"Courier New",clrLime);  
  drawFixedLbl("str5","Floating PL="+DoubleToString(GetPos("_Profit"),2),0,25,125,14,"Courier New",clrLime);  
  if(Trailing) {
   drawFixedLbl("str6","TrailStart="+DoubleToString(TrailStart,1)+", TrailStop="+DoubleToString(TrailStop,1)+", TrailStep="+DoubleToString(TrailStep,1),0,25,150,14,"Courier New",clrLime);  
   }

  CheckPos(); 
  
  if(!IsTester) { IsModify=(bool)GVG("IsModify");  TimePrev=(datetime)GVG("TimePrev"); }

  if(!IsModify && isO) { if(isBO) IsModify=Modify_SL_TP(1); else if(isSO) IsModify=Modify_SL_TP(-1); }

  Trail();
  Trade(); 

  if(!IsTester) { GVS("IsModify",(double)IsModify);  GVS("TimePrev",(double)TimePrev); }

  return;
 }
//==========================================================================================================================================//
void Trade() {  

 TimeNow=Time(0,TF);
 
 if(isBO) {
  if(TimePrev!=TimeNow) TimePrev=TimeNow;
  if((StopLoss>0.0 && ND(GetPos("Op")-tick.bid)>=StopLoss*Pnt) || (TakeProfit>0.0 && ND(tick.bid-GetPos("Op"))>=StopLoss*Pnt) || (ExpirationTime_sec>0 && (int)TimeCurrent()-GetPosInt("Ot")>=ExpirationTime_sec && GetPos("_Profit")<0.0)) {
   trade.PositionClose(_Symbol); 
   }
  return; } 
  
 if(isSO) {
  if(TimePrev!=TimeNow) TimePrev=TimeNow;
  if((StopLoss>0.0 && ND(tick.ask-GetPos("Op"))>=StopLoss*Pnt) || (TakeProfit>0.0 && ND(GetPos("Op")-tick.ask)>=StopLoss*Pnt) || (ExpirationTime_sec>0 && (int)TimeCurrent()-GetPosInt("Ot")>=ExpirationTime_sec && GetPos("_Profit")<0.0)) {
   trade.PositionClose(_Symbol);
   }
  return; }
 
 if(TimePrev<Time(CandlesToObserve-1,TF) && ND(GetBarValue(0,CLOSE,TF)-Get_lowest())>=MinMovement*Pnt) {
  if(!Use_TradingBan || (Use_TradingBan && TimeCurrent()-TimeNow<=TradingBan_sec)) {
   if(!TradeBuy(FixedLot,TradeComment)) return;
   IsModify=Modify_SL_TP(1);
   if(TimePrev!=TimeNow) TimePrev=TimeNow;
   }
  }
 
 if(TimePrev<Time(CandlesToObserve-1,TF) && ND(Get_highest()-GetBarValue(0,CLOSE,TF))>=MinMovement*Pnt) {
  if(!Use_TradingBan || (Use_TradingBan && TimeCurrent()-TimeNow<=TradingBan_sec)) {
   if(!TradeSell(FixedLot,TradeComment)) return;
   IsModify=Modify_SL_TP(-1);
   if(TimePrev!=TimeNow) TimePrev=TimeNow;
   }
  }

 }
//==========================================================================================================================================//
double Get_highest() {
 double high=0.0, highest=GetBarValue(0,HIGH,TF);
    int i=0;
 
 for(i=1; i<=CandlesToObserve-1; i++) {
  high=GetBarValue(i,HIGH,TF);
  if(high>highest) highest=high;
  } // for
  
 return(highest);
 }
//==========================================================================================================================================//
double Get_lowest() {
 double low=0.0, lowest=GetBarValue(0,LOW,TF);
    int i=0;
 
 for(i=1; i<=CandlesToObserve-1; i++) {
  low=GetBarValue(i,LOW,TF);
  if(low>lowest) lowest=low;
  } // for
  
 return(lowest);
 } 
//==========================================================================================================================================//
double GetPos(string value) { 
 if(PositionSelect(_Symbol)) { 
  if(value=="Op")         return(PositionGetDouble(POSITION_PRICE_OPEN)); else
  if(value=="Sl")         return(PositionGetDouble(POSITION_SL)); else
  if(value=="Tp")         return(PositionGetDouble(POSITION_TP)); else
  if(value=="Lot")        return(PositionGetDouble(POSITION_VOLUME)); else 
  if(value=="Swap")       return(PositionGetDouble(POSITION_SWAP)); else
  if(value=="Commission") return(PositionGetDouble(POSITION_COMMISSION)); else
  if(value=="Profit")     return(PositionGetDouble(POSITION_PROFIT)); else
  if(value=="_Profit")    return(PositionGetDouble(POSITION_PROFIT)+PositionGetDouble(POSITION_SWAP)+PositionGetDouble(POSITION_COMMISSION)); } 
 return(0.0); } 
//==========================================================================================================================================//
int GetPosInt(string value) { 
 if(PositionSelect(_Symbol)) { 
  if(value=="Ot") return((int)PositionGetInteger(POSITION_TIME)); } 
 return(0.0); } 
//==========================================================================================================================================//
bool Trail() { 
 if(!Trailing || !isO) return(true); 
 double tp=GetPos("Tp"), sl=GetPos("Sl"), op=GetPos("Op"), _sl=0.0;

 if(isBO) {
  if(ND(tick.bid-op)<TrailStart*Pnt) return(true);
  _sl=tick.bid-TrailStop*Pnt;
  if(ND(_sl-op)<0.0 || (sl!=0.0 && ND(_sl-sl)<TrailStep*Pnt)) return(true); 
  if(ND(tick.bid-_sl)<StopLevel) return(false); }
  
 else if(isSO) {
  if(ND(op-tick.ask)<TrailStart*Pnt) return(true);
  _sl=tick.ask+TrailStop*Pnt; 
  if(ND(op-_sl)<0.0 || (sl!=0.0 && ND(sl-_sl)<TrailStep*Pnt)) return(true); 
  if(ND(_sl-tick.ask)<StopLevel) return(false); }

 if(!trade.PositionModify(_Symbol,NT(_sl),NT(tp))) {
  Print("The method PositionModify() failed. Return code=",trade.ResultRetcode(),
        ". Description of the code: ",trade.ResultRetcodeDescription()); 
  return(false); }

 return(true); }
//==========================================================================================================================================//
bool Modify_SL_TP(int direction) { 
 double tp=GetPos("Tp"), sl=GetPos("Sl"), op=GetPos("Op"), _tp=0.0, _sl=0.0;
 
 if(direction==1) { 
  if(StopLoss>0.0) { _sl=NT(op-MathMax(StopLoss*Pnt,StopLevel));  if(ND(tick.bid-_sl)<StopLevel) return(false); } else _sl=sl;
  if(TakeProfit>0.0) { _tp=NT(op+MathMax(TakeProfit*Pnt,StopLevel));  if(ND(_tp-tick.bid)<StopLevel) return(false); } else _tp=tp; }
  
 else if(direction==-1) { 
  if(StopLoss>0.0) { _sl=NT(op+MathMax(StopLoss*Pnt,StopLevel));  if(ND(_sl-tick.ask)<StopLevel) return(false); } else _sl=sl;
  if(TakeProfit>0.0) { _tp=NT(op-MathMax(TakeProfit*Pnt,StopLevel));  if(ND(tick.ask-_tp)<StopLevel) return(false); } else _tp=tp; }
  
 if(ND(_sl-sl)==0.0 && ND(_tp-tp)==0.0) return(true); 
  
 if(!trade.PositionModify(_Symbol,NT(_sl),NT(_tp))) {
  Print("The method PositionModify() failed. Return code=",trade.ResultRetcode(),
        ". Description of the code: ",trade.ResultRetcodeDescription()); 
  return(false); }

 return(true); }
//==========================================================================================================================================//
bool TradeBuy(double lot, string comment=NULL) {

 double margin;
 if(!OrderCalcMargin(ORDER_TYPE_BUY,_Symbol,NL(lot),tick.ask,margin)) return(false);
 if(AccountInfoDouble(ACCOUNT_FREEMARGIN)<margin) {
  if(!FreeMarginAlert) {
   Alert("Not enough money to send the order. Free Margin = ", DoubleToString(AccountInfoDouble(ACCOUNT_FREEMARGIN),2));
   FreeMarginAlert=true; } 
  return(false); }
 FreeMarginAlert=false;  

 if(!trade.Buy(NL(lot),_Symbol,tick.ask,NULL,NULL,comment)) {
  Print("The method Buy() failed. Return code=",trade.ResultRetcode(),". Description of the code: ",trade.ResultRetcodeDescription());
  return(false); } 
        
 return(true); }
//==========================================================================================================================================//
bool TradeSell(double lot, string comment=NULL) {
 
 double margin;
 if(!OrderCalcMargin(ORDER_TYPE_SELL,_Symbol,NL(lot),tick.bid,margin)) return(false);
 if(AccountInfoDouble(ACCOUNT_FREEMARGIN)<margin) {
  if(!FreeMarginAlert) {
   Alert("Not enough money to send the order. Free Margin = ", DoubleToString(AccountInfoDouble(ACCOUNT_FREEMARGIN),2));
   FreeMarginAlert=true; } 
  return(false); }
 FreeMarginAlert=false;  

 if(!trade.Sell(NL(lot),_Symbol,tick.bid,NULL,NULL,comment)) {
  Print("The method Sell() failed. Return code=",trade.ResultRetcode(),". Description of the code: ",trade.ResultRetcodeDescription());
  return(false); } 

 return(true); }
//==========================================================================================================================================//
void CheckPos(int i=0) { 
 if(PositionSelect(_Symbol)) { 
  if(PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_BUY) { 
   isBO=true; isSO=false; isO=true; } 
  else { 
   isBO=false; isSO=true; isO=true; } } 
 else {
  isBO=false; isSO=false; isO=false; }
 
 if(i==0) return; else

 if(i==1) { _isBO=isBO; _isSO=isSO; _isO=isO; } else 

 if(i==2) { _isBO=(bool)GVG("_isBO"); _isSO=(bool)GVG("_isSO"); _isO=(bool)GVG("_isO"); } else 

 if(i==3) { _isBO=isBO; _isSO=isSO; _isO=isO;
            GVS("_isBO",(double)_isBO); GVS("_isSO",(double)_isSO); GVS("_isO",(double)_isO); }
 }
//==========================================================================================================================================//
void GetMarketInfo() { 
 TickSize=SymbolInfoDouble(_Symbol,SYMBOL_TRADE_TICK_SIZE); TickValue=SymbolInfoDouble(_Symbol,SYMBOL_TRADE_TICK_VALUE);
 Spread=SymbolInfoInteger(_Symbol,SYMBOL_SPREAD)*_Point; StopLevel=SymbolInfoInteger(_Symbol,SYMBOL_TRADE_STOPS_LEVEL)*_Point;
 MinLot=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_MIN); MaxLot=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_MAX); 
 LotStep=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_STEP); }
//==========================================================================================================================================//
bool GetLatestPrice() { 
 if(!SymbolInfoTick(_Symbol,tick)) { Print("Error getting the values of the current price!"); return(false); } else return(true); }   
//==========================================================================================================================================//
double NL(double L) { 
 return( MathRound(MathMin(MathMax(L, MinLot), MaxLot)/LotStep)*LotStep ); }
//==========================================================================================================================================//
double ND(double A) { 
 return( NormalizeDouble(A, _Digits) ); }
//==========================================================================================================================================//
double NT(double A) { 
 return( MathRound(A/TickSize)*TickSize ); }
//==========================================================================================================================================//
datetime GVS(string Name, double Value) { 
 return( GlobalVariableSet(Name+Name(), Value) ); } 
//==========================================================================================================================================//
double GVG(string Name) { 
 return( GlobalVariableGet(Name+Name()) ); } 
//==========================================================================================================================================//
bool GVD(string Name) { 
 return( GlobalVariableDel(Name+Name()) ); } 
//==========================================================================================================================================//
datetime GVZ(string Name) { 
 return( GlobalVariableSet(Name+Name(), 0.0) ); }
//==========================================================================================================================================//
string Name() { 
 if(IsTester) return( "_"+IntegerToString(MagicNumber)+"_"+Symbol()+"_"+"Tester" ); else return( "_"+IntegerToString(MagicNumber)+"_"+Symbol() ); }
//==========================================================================================================================================//
datetime Time(int index=0, ENUM_TIMEFRAMES _tf=PERIOD_CURRENT) { 
 datetime time[]; ArrayResize(time,1); ArrayInitialize(time,0); 
 
 int i=0;
 while(i<5) {
  if(CopyTime(_Symbol,_tf,index,1,time)!=-1) break;
  Sleep(1000);
  i++; } // while

 if(i==5) {
  Print("Update and / or receive data failed. Go to the next attempt ...");
  return(-1); } 

 return(time[0]); } 
//==========================================================================================================================================//
double GetBarValue(int index=0, ENUM_AP_PRICE _price=CLOSE, ENUM_TIMEFRAMES _tf=PERIOD_CURRENT) { 
 double value[]; ArrayResize(value,1); ArrayInitialize(value,0.0); 
    int get_value=0;
 
 int i=0;
 while(i<5) {
 
  switch(_price) {
   case CLOSE: get_value=CopyClose(_Symbol,_tf,index,1,value); break;
   case OPEN : get_value=CopyOpen(_Symbol,_tf,index,1,value); break;
   case HIGH : get_value=CopyHigh(_Symbol,_tf,index,1,value); break;
   case LOW  : get_value=CopyLow(_Symbol,_tf,index,1,value); break; } // switch
   
  if(get_value!=-1) break;
  Sleep(1000);
  i++; } // while

 if(i==5) {
  Print("Update and / or receive data failed. Go to the next attempt ...");
  return(-1); } 

 return(value[0]); } 
//==========================================================================================================================================//
double PointsToPips(double points) { if(_Digits==5 || _Digits==3) points/=10.0;  return (points/_Point); }
//=================================================================================================================================================//
void drawFixedLbl(string objname,string s,int Corner,int DX,int DY,int FSize,string Font,color c,bool bg=false) 
  {
   if(ObjectFind(0,objname)<0) {ObjectCreate(0,objname,OBJ_LABEL,0,0,0);}
   ObjectSetInteger(0,objname,OBJPROP_CORNER,Corner);
   ObjectSetInteger(0,objname,OBJPROP_XDISTANCE,DX);
   ObjectSetInteger(0,objname,OBJPROP_YDISTANCE,DY);
   ObjectSetInteger(0,objname,OBJPROP_BACK,bg);

   ObjectSetString(0,objname,OBJPROP_TEXT,s);
   ObjectSetInteger(0,objname,OBJPROP_FONTSIZE,FSize);
   ObjectSetString(0,objname,OBJPROP_FONT,Font);
   ObjectSetInteger(0,objname,OBJPROP_COLOR,c); 
  }
//=================================================================================================================================================//
void Obj_Del() { string label="";
 for(int i=ObjectsTotal(0,-1)-1; i>=0; i--) {
  label=ObjectName(0,i);
  if(StringSubstr(label,0,3)=="str")  ObjectDelete(0,label); } /*for*/ }
//==========================================================================================================================================//