//+------------------------------------------------------------------+
//|                                                NewNZDCHF.mq4 |
//|                             |
//+------------------------------------------------------------------+
//
/*

*/
//--------------------------------------------------------------------
//external parameters = parameters you can set as a user from the terminal



extern double  TP_Pips = 40,
               SL_Pips = 40;   
extern double  Fixe_Lotsize = 0.01;
extern bool    Close_Posis_bei_Gegensignal = true;  
             
extern int     CycleIdentifier_VerschiebungE1 = 7,
               CycleIdentifier_VerschiebungE2 = 7,
               CycleIdentifier_VerschiebungA1 = 3,
               CycleIdentifier_VerschiebungA2 = 3,                       
               Stochastic_VerschiebungE = 7,
               Maximale_Deals_Gleichzeitig = 1;
              
extern int     Maximale_Slippage = 3,
               Maximaler_Spread = 5; 
extern int     MagicNumber = 1400222;                                                       

//------------------
//Global Variables = variables that are used by several/all functions to come
int      UseSlippage,UseSpread,Order,
         LotsRundung,DealCount,LongCount,ShortCount;
double   UsePoint,UseLots,Lots;
bool     EAAllowed,NewBar,TradingTime=1,
         LongSignal,ShortSignal;
datetime CurrentTimeStamp;         

//----------------
//init function (run one time only upon starting the program)
int init()
   {
      
   
      
      
      UsePoint = PipPoint(Symbol());
      UseSlippage = GetSlippage(Symbol(),Maximale_Slippage);
      UseSpread = GetSpread(Symbol(),Maximaler_Spread);
      CurrentTimeStamp = Time[0];
      
      TradingTime=true;
      
      if(MarketInfo(Symbol(),MODE_LOTSTEP)==0.01) LotsRundung = 2;
      else if (MarketInfo(Symbol(),MODE_LOTSTEP)==0.1) LotsRundung = 1;
      else LotsRundung = 0; 
      
      //Check basic settings
      EAAllowed=true;
      if(CycleIdentifier_VerschiebungE1<0)
         {
            Alert("CycleIdentifier_Verschiebung muss 0 oder größer sein, EA wird beendet");
            EAAllowed=false;
         } 
         
      return(0);
            
   }   


//----------------
//Main Program (run every time a new tick is produced)


int start()
   {   
      
      //Basic Settings End EA
      if(EAAllowed==false)
         {
            return(0);
         }      
      
      //Neuen Bar erkennen
      if(CurrentTimeStamp != Time[0])
         {
            CurrentTimeStamp = Time[0];
            NewBar = true;
         }
      else NewBar = false;
      
      
 
      //Markt
      double   RR0 = iStochastic(NULL,PERIOD_M15,30,30,3,MODE_SMA,0,MODE_MAIN,Stochastic_VerschiebungE);
      double   Rep1 = iCustom(NULL,PERIOD_M15,"Repulse",5,15,30,1,0);
      double   Rep2 = iCustom(NULL,PERIOD_M15,"Repulse",5,15,30,1,2);
      double   CI = iCustom(NULL,PERIOD_M15,"CycleIdentifier",1,3,4,false,1,12,21,1,CycleIdentifier_VerschiebungE1);
      double   CI2 = iCustom(NULL,PERIOD_M15,"CycleIdentifier",1,3,4,false,1,12,21,2,CycleIdentifier_VerschiebungE2);
      double   CI3 = iCustom(NULL,PERIOD_H1,"CycleIdentifier",1,3,4,false,1,12,21,1,CycleIdentifier_VerschiebungA1);
      double   CI4 = iCustom(NULL,PERIOD_H1,"CycleIdentifier",1,3,4,false,1,12,21,2,CycleIdentifier_VerschiebungA2);
                       
      //Handelsignal
      if(NewBar==true && CI==-1 && RR0<20 && Rep1 > Rep2)
         {
            LongSignal=true;
         }
      else LongSignal=false;
      if(NewBar==true && CI2==1 && RR0>80 && Rep1 < Rep2)
         {
            ShortSignal=true;
         }
      else ShortSignal=false;
      
      //MoneyManagement-Modul: Positionsgröße    
      
    
     int i=(OrdersHistoryTotal()-1);
     {
      
       if(OrderSelect(i, SELECT_BY_POS,MODE_HISTORY)==true)
       if(OrderSymbol()==Symbol() && OrderMagicNumber()==MagicNumber)
       double OP = OrderProfit();
       double OL = OrderLots();
       double OT = OrderType();
       
    {
        
       if (OrderProfit()< 0)
         
            {
            UseLots = (NormalizeDouble(OrderLots()*2,Digits));
            }
         else
            {
            UseLots = (NormalizeDouble(Fixe_Lotsize,Digits));
                       
            }
         }
      } 
     
      Lots=MathMax(NormalizeDouble(UseLots,LotsRundung),MarketInfo(Symbol(),MODE_MINLOT));
     
      //Close bei Gegenrichtungs-Signal
      if(Close_Posis_bei_Gegensignal==true)
         {
            if(LongSignal==true&&ShortCount>0)
               {
                  for(int Count = OrdersTotal()-1; Count>=0 ; Count--)
                     {
                        if(OrderSelect(Count,SELECT_BY_POS,MODE_TRADES)==true)
                           {
                              if(OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber && OrderType()==OP_SELL)
                                 {
                                    while(IsTradeContextBusy()) Sleep(10);
                                    bool closeorders=OrderClose(OrderTicket(),OrderLots(),Ask,UseSlippage,Blue);
                                 }
                           }   
                     }
               }
            else if(ShortSignal==true&&LongCount>0)
               {
                  for(Count = OrdersTotal()-1; Count>=0 ; Count--)
                     {
                        if(OrderSelect(Count,SELECT_BY_POS,MODE_TRADES)==true)
                           {
                              if(OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber && OrderType()==OP_BUY)
                                 {
                                    while(IsTradeContextBusy()) Sleep(10);
                                    closeorders=OrderClose(OrderTicket(),OrderLots(),Bid,UseSlippage,Blue);
                                 }
                           }   
                     }
               }   
         }      
      //Close bei CycleIdentifier-Signal
     if(TradingTime==true)
         {
            if(CI3==-1&&ShortCount>0)
               {
                  for(Count = OrdersTotal()-1; Count>=0 ; Count--)
                     {
                        if(OrderSelect(Count,SELECT_BY_POS,MODE_TRADES)==true)
                           {
                              if(OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber && OrderType()==OP_SELL)
                                 {
                                    while(IsTradeContextBusy()) Sleep(10);
                                    closeorders=OrderClose(OrderTicket(),OrderLots(),Ask,UseSlippage,Blue);
                                 }
                           }   
                     }
               }
            else if(CI4==1&&LongCount>0)
               {
                  for(Count = OrdersTotal()-1; Count>=0 ; Count--)
                     {
                        if(OrderSelect(Count,SELECT_BY_POS,MODE_TRADES)==true)
                           {
                              if(OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber && OrderType()==OP_BUY)
                                 {
                                    while(IsTradeContextBusy()) Sleep(10);
                                    closeorders=OrderClose(OrderTicket(),OrderLots(),Bid,UseSlippage,Blue);
                                 }
                           }  
                     }
               }   
         }     
      
        
      //Neue Deals
      if(TradingTime==true)
         {
            string DealKommentar="ROCKNROLL-CycleIdentifier-Strategie";
            //Long Deal
            if(LongCount<Maximale_Deals_Gleichzeitig&&LongSignal==true/*&& MarketInfo(Symbol(),MODE_SPREAD)<=UseSpread*/)
               {
                  while(IsTradeContextBusy()) Sleep(10);
                  Order = OrderSend(Symbol(),OP_BUY,Lots,Ask,UseSlippage,0,0,DealKommentar,MagicNumber,0,Green);
                  if(Order>0) 
                     {
                        LongCount=LongCount+1;
                     }   
               }   
            //Short Deal
            if(ShortCount<Maximale_Deals_Gleichzeitig&&ShortSignal==true/*&& MarketInfo(Symbol(),MODE_SPREAD)<=UseSpread*/)
               {
                  while(IsTradeContextBusy()) Sleep(10);
                  Order = OrderSend(Symbol(),OP_SELL,Lots,Bid,UseSlippage,0,0,DealKommentar,MagicNumber,0,Red);
                  if(Order>0) 
                     {
                        ShortCount=ShortCount+1;
                     }   
               }   
         }   
      
      //Loop through current deal pool
      DealCount = 0;
      LongCount = 0;
      ShortCount = 0;
      for(Count = 0; Count<=OrdersTotal()-1 ; Count++)
         {
            if(OrderSelect(Count,SELECT_BY_POS,MODE_TRADES)==true)
               {
                  if(OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber)
                     {
                        DealCount++;  
                        if(OrderType()==OP_BUY)
                           {
                              LongCount++;
                           }
                        else if(OrderType()==OP_SELL)
                           {
                              ShortCount++;
                           }         
                     }
               }   
         }
      
      
      
      //Initial TP und SL setzen
      //SL
      if(DealCount>0)
         {
            for(Count = OrdersTotal()-1; Count>=0 ; Count--)
               {
                  if(OrderSelect(Count,SELECT_BY_POS,MODE_TRADES)==true)
                     {
                        if(OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber)
                           {
                              if(OrderType()==OP_BUY ) 
                                 {  
                                    if(OrderStopLoss()==0)
                                       {
                                          double SLset = NormalizeDouble(OrderOpenPrice()-(SL_Pips*UsePoint),Digits);      
                                          if(SLset>0&&SLset<OrderOpenPrice())
                                             {
                                                while(IsTradeContextBusy()) Sleep(10);
                                                bool modifytheorder=OrderModify(OrderTicket(),OrderOpenPrice(),SLset,OrderTakeProfit(),0,Yellow);
                                             }   
                                       }
                                 }   
                              else if(OrderType()==OP_SELL ) 
                                 {
                                    if(OrderStopLoss()==0)
                                       {
                                          SLset = NormalizeDouble(OrderOpenPrice()+(SL_Pips*UsePoint),Digits);
                                          if(SLset>0&&SLset>OrderOpenPrice())
                                             {
                                                while(IsTradeContextBusy()) Sleep(10);
                                                modifytheorder=OrderModify(OrderTicket(),OrderOpenPrice(),SLset,OrderTakeProfit(),0,Yellow);
                                             } 
                                       }  
                                 }      
                           }   
                     }
               }
         }
      //TP
      if(DealCount>0)
         {
            for(Count = OrdersTotal()-1; Count>=0 ; Count--)
               {
                  if(OrderSelect(Count,SELECT_BY_POS,MODE_TRADES)==true)
                     {
                        if(OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber)
                           {
                              if(OrderType()==OP_BUY && OrderTakeProfit()==0) 
                                 {  
                                    double TPset = NormalizeDouble(OrderOpenPrice()+(TP_Pips*UsePoint),Digits);
                                    if(TPset>0&&TPset>OrderOpenPrice())
                                       {
                                          while(IsTradeContextBusy()) Sleep(10);
                                          modifytheorder=OrderModify(OrderTicket(),OrderOpenPrice(),OrderStopLoss(),TPset,0,Yellow);
                                       }   
                                 }   
                              else if(OrderType()==OP_SELL && OrderTakeProfit()==0) 
                                 {
                                    TPset = NormalizeDouble(OrderOpenPrice()-(TP_Pips*UsePoint),Digits);
                                    if(TPset>0&&TPset<OrderOpenPrice())
                                       {
                                          while(IsTradeContextBusy()) Sleep(10);
                                          modifytheorder=OrderModify(OrderTicket(),OrderOpenPrice(),OrderStopLoss(),TPset,0,Yellow);
                                       }   
                                 }      
                           }   
                     }
               }
         }
         
      //Start-Funktion schließen
      return(0);
   }


//PipPoint Function
double PipPoint(string Currency)
   {
      int CalcDigits = MarketInfo(Currency,MODE_DIGITS);
      if(CalcDigits == 2 || CalcDigits == 3) double CalcPoint = 0.01;
      else if(CalcDigits == 4 || CalcDigits == 5) CalcPoint = 0.0001;
      else if(CalcDigits == 0) CalcPoint = 1;
      return(CalcPoint);
   }
   
//GetSlippage Function
double GetSlippage (string Currency, int SlippagePips)
   {
      int CalcDigits = MarketInfo(Currency,MODE_DIGITS);
      if(CalcDigits == 2 || CalcDigits == 4 || CalcDigits == 0) double CalcSlippage = SlippagePips;
      else if(CalcDigits == 3 || CalcDigits == 5) CalcSlippage = SlippagePips * 10;
      return(CalcSlippage);
   }
   
//GetSpread Function
double GetSpread (string Currency, int SpreadPips)
   {
      int CalcDigits = MarketInfo(Currency,MODE_DIGITS);
      if(CalcDigits == 0) double CalcSpread = SpreadPips;
      else if(CalcDigits == 2 || CalcDigits == 4) CalcSpread = SpreadPips;
      else if(CalcDigits == 3 || CalcDigits == 5) CalcSpread = SpreadPips * 10;
      return(CalcSpread);
   }