//EXTERNAL VARIABLES
input int            CmoPeriod1   = 10;     
input int            EmaPeriod1   = 20;      
input int            MAShift1     = 30;     
input int            MAPrice1     = 1;    // MAPrice1 1..7
//+------------------------------------------------------------------+
input int            CmoPeriod2   = 20;     
input int            EmaPeriod2   = 30;      
input int            MAShift2     = 40;     
input int            MAPrice2     = 1;    // MAPrice2 1..7
//+------------------------------------------------------------------+
input int            CmoPeriod3   = 20;     
input int            EmaPeriod3   = 30;      
input int            MAShift3     = 40;     
input int            MAPrice3     = 1;    // MAPrice3 1..7
//+------------------------------------------------------------------+
input int            Direction    = 1;    // Direction (0buy/1sell)
input double         MaxDDperc    = 1;
input int            Optimization = 11;
input int            TradeType    = 1;    // TradeType (1Single/2Basket/3Serial)



// INTERNAL VARIABLES
// general
int y,size,StartBar;
double Spread=0.00020; // spread fixed 2 pips
double MA1,MA2,MA3,MA1old,MA2old,MA3old,EdgePrice;
double ArrayPrices1[],ArrayPrices2[],ArrayPrices3[];
double F1,F2,F3,Result1,Result2,Result3,CMO1,CMO2,CMO3;
double ArrayOpenPrice[9999999];

// virtual trading
int Trades=0;
int OpenTrades=0;
int Crashed=0;   
double BalancePip=0;
double ProfitPip=0;
double OpenPrice=0;
double GrossProfitPip=0;
double GrossLossPip=0;
double EquityPip=0;
double MaxEquityPip=0;
double MinEquityPip=0;
double CurrentEquityPip=0;
double CurrentGainPip=0;
double MAXDDPip=0;
double DDtempPip=0;
double PFPip=0;
double RECFACTPip=0;
double OnTesterResult=0;
datetime MAXDDTimePip=0;

// INTERNAL VARIABLES IMPORTED FROM INCLUDE
#include <EURUSD2_M15.mqh>

// max stagnation
double EquityA;
double Stagnaz=0;
double MaxStagnaz=0;
datetime EquityAdate,StagnazDateA,StagnazDateB;

// standard deviation
int BarsCount=0;
double InitialEquity=0;
double NetEquity[9999999];



//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
   {
   //Print("------------------START INIT------------------------------------------");

   // check entry values
   /*int proceed=0;
   if(
      CmoPeriod1>0 && EmaPeriod1>0 && MAShift1>0 && MAPrice1>=1 && MAPrice1<=7 &&
      CmoPeriod2>0 && EmaPeriod2>0 && MAShift2>0 && MAPrice2>=1 && MAPrice2<=7 &&
      CmoPeriod3>0 && EmaPeriod3>0 && MAShift3>0 && MAPrice3>=1 && MAPrice3<=7
      )
      proceed=1;
   if (proceed==0)
      {
      Print("*****************************ERROR ENTRY VALUES: STOPPED***********************");
      return INIT_PARAMETERS_INCORRECT;
      //TesterStop();
      }*/

   size = ArraySize(Atime);
   //Print("time array total bars:",size);
   
   // initialize for max stagnation
   EquityA     = 0;
   EquityAdate = Atime[0];
   
   // array copy 1
   if (MAPrice1==1) ArrayCopy(ArrayPrices1,Aclose,   0,0,WHOLE_ARRAY); 
   if (MAPrice1==2) ArrayCopy(ArrayPrices1,Aopen,    0,0,WHOLE_ARRAY); 
   if (MAPrice1==3) ArrayCopy(ArrayPrices1,Ahigh,    0,0,WHOLE_ARRAY); 
   if (MAPrice1==4) ArrayCopy(ArrayPrices1,Alow,     0,0,WHOLE_ARRAY); 
   if (MAPrice1==5) ArrayCopy(ArrayPrices1,Amedian,  0,0,WHOLE_ARRAY); 
   if (MAPrice1==6) ArrayCopy(ArrayPrices1,Atypical, 0,0,WHOLE_ARRAY); 
   if (MAPrice1==7) ArrayCopy(ArrayPrices1,Aweighted,0,0,WHOLE_ARRAY);  

   // array copy 2
   if (MAPrice2==1) ArrayCopy(ArrayPrices2,Aclose,   0,0,WHOLE_ARRAY); 
   if (MAPrice2==2) ArrayCopy(ArrayPrices2,Aopen,    0,0,WHOLE_ARRAY); 
   if (MAPrice2==3) ArrayCopy(ArrayPrices2,Ahigh,    0,0,WHOLE_ARRAY); 
   if (MAPrice2==4) ArrayCopy(ArrayPrices2,Alow,     0,0,WHOLE_ARRAY); 
   if (MAPrice2==5) ArrayCopy(ArrayPrices2,Amedian,  0,0,WHOLE_ARRAY); 
   if (MAPrice2==6) ArrayCopy(ArrayPrices2,Atypical, 0,0,WHOLE_ARRAY); 
   if (MAPrice2==7) ArrayCopy(ArrayPrices2,Aweighted,0,0,WHOLE_ARRAY);  

   // array copy 3
   if (MAPrice3==1) ArrayCopy(ArrayPrices3,Aclose,   0,0,WHOLE_ARRAY); 
   if (MAPrice3==2) ArrayCopy(ArrayPrices3,Aopen,    0,0,WHOLE_ARRAY); 
   if (MAPrice3==3) ArrayCopy(ArrayPrices3,Ahigh,    0,0,WHOLE_ARRAY); 
   if (MAPrice3==4) ArrayCopy(ArrayPrices3,Alow,     0,0,WHOLE_ARRAY); 
   if (MAPrice3==5) ArrayCopy(ArrayPrices3,Amedian,  0,0,WHOLE_ARRAY); 
   if (MAPrice3==6) ArrayCopy(ArrayPrices3,Atypical, 0,0,WHOLE_ARRAY); 
   if (MAPrice3==7) ArrayCopy(ArrayPrices3,Aweighted,0,0,WHOLE_ARRAY);  

   /*int size2 = ArraySize(ArrayPrices1);
   Print("array2 total bars:",size2);*/

   F1=2.0/(EmaPeriod1+1.0);
   F2=2.0/(EmaPeriod2+1.0);
   F3=2.0/(EmaPeriod3+1.0);



   //Print("------------------END INIT------------------------------------------");
   return(INIT_SUCCEEDED);
   }



  
//+------------------------------------------------------------------+
//| Tester function                                                  |
//+------------------------------------------------------------------+
double OnTester()
   {
   //Print("-------------------START ONTESTER---------------------------------");

   
  // CALCULATE CORRECT START BAR
   StartBar = CmoPeriod1+MAShift1;
   if ((CmoPeriod2+MAShift2) > StartBar)
      StartBar = CmoPeriod2+MAShift2;
   if ((CmoPeriod3+MAShift3) > StartBar)
      StartBar = CmoPeriod3+MAShift3;
   //StartBar = 108;
   
   MA1old = Aclose[StartBar-1];
   MA2old = MA1old;
   MA3old = MA1old;
   //size=508;

   for (y=StartBar;y<size; y++)
      {
      //Print(Atime[y]," ",Aopen[y]," ",Ahigh[y]," ",Alow[y]," ",Aclose[y]);



      // CALCULATING CURRENT EQUITY WITH BASKET
      EdgePrice = 999999; if (Direction == 1) EdgePrice = 0;
      CurrentGainPip = 0;
      if (OpenTrades>0)
         {
         for(int i=1;i<=OpenTrades;i++)
            {
            if (Direction==0)
               {
               ProfitPip=Aopen[y]-ArrayOpenPrice[i];
               if (ArrayOpenPrice[i]<EdgePrice) EdgePrice = ArrayOpenPrice[i];
               }
            else
               {
               ProfitPip=ArrayOpenPrice[i]-(Aopen[y]+Spread);
               if (ArrayOpenPrice[i]>EdgePrice) EdgePrice = ArrayOpenPrice[i];
               }
            CurrentGainPip = CurrentGainPip + ProfitPip;
            }
         }
      CurrentEquityPip=BalancePip + CurrentGainPip;



      // CLOSE ALL ONLY IF TRADE TYPE IS BASKET (AND POSITIVE)
      if (TradeType==2) // check if basket mode
         {
         if (CurrentGainPip>0) // check if basket > 0
            {
            CloseAll();
            EdgePrice = 999999; if (Direction == 1) EdgePrice = 0;
            }
         }


      // CALCULATION OF STANDARD DEVIATION
      BarsCount++;
      NetEquity[BarsCount] = CurrentEquityPip*10000;
      //Print(Atime[y]+";"+DoubleToString(CurrentEquityPip*10000,2));
      //Print(DoubleToString(CurrentEquityPip*10000,2));


      // CALCULATION AND CHECK MAX STAGNATION v2.4
      if(CurrentEquityPip<=EquityA)
         {
         Stagnaz=double(Atime[y]-EquityAdate); // datediff in seconds
         Stagnaz=Stagnaz/60/60/24; // converstion in days
         if(Stagnaz>MaxStagnaz)
            {
            MaxStagnaz   = Stagnaz;
            StagnazDateA = EquityAdate;
            StagnazDateB = Atime[y];
            }
         }
      else
         {
         EquityA = CurrentEquityPip;
         EquityAdate = Atime[y];
         }



      // CALCULATION AND CHECK MAX DRAWDOWN v2.5
      EquityPip = CurrentEquityPip;
      if(EquityPip > MaxEquityPip) // nex max found: update maxequity and minequity
         {
         MaxEquityPip = EquityPip;
         MinEquityPip = MaxEquityPip;
         }
      else
         {
         if(EquityPip < MinEquityPip) // new low found: update minequity
            {
            MinEquityPip = EquityPip;
            DDtempPip = MaxEquityPip - MinEquityPip;
            if(DDtempPip > MAXDDPip) // new maxdd found
               {
               MAXDDPip = DDtempPip;
               MAXDDTimePip = Atime[y];
               if(MAXDDPip*10000 > MaxDDperc*1000)
                  {
                  Crashed = 1;
                  break;
                  }
               }
            }
         }



      // CALCULATING INDICATORS
      MA1 = VidyaOnArray1(y,CmoPeriod1,EmaPeriod1,MAShift1,MA1old,ArrayPrices1);
      MA2 = VidyaOnArray2(y,CmoPeriod2,EmaPeriod2,MAShift2,MA2old,ArrayPrices2);
      MA3 = VidyaOnArray3(y,CmoPeriod3,EmaPeriod3,MAShift3,MA3old,ArrayPrices3);
      //Print("TimeCurrent2:",Atime[y]," MA1:",DoubleToString(MA1,6)," MA2:",DoubleToString(MA2,6));

     
   
      // TRADING LOGIC
      if (Direction==0) // CHECK BUY CONDITION
         {
         if (MA1 > MA2 && MA2 > MA3 && MA1 > MA1old && MA2 > MA2old && MA3 > MA3old) // CHECK SIGNAL
            {
            if (TradeType==1) // SINGLE MODE
               {
               if (OpenTrades==0) OpenBuy();
               }
            if (TradeType==2) // BASKET MODE
               {
               if (Aopen[y]+Spread<EdgePrice) OpenBuy();
               }
            if (TradeType==3) // SERIAL MODE
               {
               OpenBuy();
               }
            }
         else
            {
            if (TradeType!=2) // NO BASKET MODE
               {
               if (MA1 < MA2 || MA2 < MA3 || MA2 < MA2old || MA3 < MA3old)
                  CloseAll(); // CLOSE ALL
               }
            }
         }
      else              // CHECK SELL CONDITION
         {
         if (MA1 < MA2 && MA2 < MA3 && MA1 < MA1old && MA2 < MA2old && MA3 < MA3old) // CHECK SIGNAL
            {
            if (TradeType==1) // SINGLE MODE
               {
               if (OpenTrades==0) OpenSell();
               }
            if (TradeType==2) // BASKET MODE
               {
               if (Aopen[y]>EdgePrice) OpenSell();
               }
            if (TradeType==3) // SERIAL MODE
               {
               OpenSell();
               }
            }
         else
            {
            if (TradeType!=2) // NO BASKET MODE
               {
               if (MA1 > MA2 || MA2 > MA3 || MA2 > MA2old || MA3 > MA3old)
                  CloseAll(); // CLOSE ALL
               }
            }
         }



      MA1old=MA1;
      MA2old=MA2;
      MA3old=MA3;
      }

   
   

   OnTesterResult=0;
   if(Crashed==0)
      {
      BalancePip=BalancePip*10000;
      MAXDDPip=MAXDDPip*10000;
      GrossProfitPip=GrossProfitPip*10000;
      GrossLossPip=GrossLossPip*10000;
      PFPip=0;
      if (GrossLossPip!=0)
         PFPip=GrossProfitPip/GrossLossPip;
      RECFACTPip=0;
      if (MAXDDPip!=0)
         RECFACTPip=BalancePip/MAXDDPip;

      double StdDev;
      if (BalancePip>0 && PFPip<20 && Trades > 200)
         {
         // standard deviation final calculation
         double BarNetProfit = BalancePip / BarsCount;
         double TotDifference = 0;
         double Difference = 0;
         for(int k=1;k<=BarsCount;k++)
            {
            Difference = NetEquity[k] - (InitialEquity+(BarNetProfit*k));
            Difference = Difference * Difference;
            TotDifference = TotDifference + Difference;
            }
         TotDifference = TotDifference / BarsCount;
         StdDev = MathSqrt(TotDifference);

         // optimization type
         if (Optimization==1)  OnTesterResult = BalancePip;
         if (Optimization==2)  OnTesterResult = PFPip;
         if (Optimization==3)  OnTesterResult = BalancePip * PFPip;

         if (Optimization==4)  OnTesterResult = RECFACTPip * Trades;
         if (Optimization==5)  OnTesterResult = RECFACTPip * Trades * PFPip;
         if (Optimization==6)  OnTesterResult = RECFACTPip * Trades * PFPip * BalancePip;

         if (Optimization==11) OnTesterResult = RECFACTPip * Trades * PFPip * BalancePip / StdDev / MaxStagnaz * 1000;

         Print("virtual BALANCE:",DoubleToString(BalancePip,2));
         Print("virtual MAXDD:",DoubleToString(MAXDDPip,2));
         Print("virtual RECFACTOR:",DoubleToString(RECFACTPip,2));
         Print("virtual TRADES:",Trades);
         Print("virtual PF:",DoubleToString(PFPip,2));
         Print("virtual STDDEV:",DoubleToString(StdDev,2));
         Print("virtual MAXSTAGNAZ: ",DoubleToString(MaxStagnaz,2), " dal ", StagnazDateA , " al ", StagnazDateB);

         /*
         // special ontester composed
         string PROFITtxt,MAXDDtxt,RECFACTtxt,TRADEStxt,PFtxt,STDDEVtxt,OnTesterResulttxt;
         PROFITtxt  = "0000000000" + DoubleToString(BalancePip,0);      PROFITtxt  = StringSubstr(PROFITtxt,StringLen(PROFITtxt)-5);
         MAXDDtxt   = "0000000000" + DoubleToString(MAXDDPip,0);        MAXDDtxt   = StringSubstr(MAXDDtxt,StringLen(MAXDDtxt)-5);
         RECFACTtxt = "0000000000" + DoubleToString(RECFACTPip*100,0);  RECFACTtxt = StringSubstr(RECFACTtxt,StringLen(RECFACTtxt)-5);
         TRADEStxt  = "0000000000" + DoubleToString(Trades,0);          TRADEStxt  = StringSubstr(TRADEStxt,StringLen(TRADEStxt)-5);
         PFtxt      = "0000000000" + DoubleToString(PFPip*100,0);       PFtxt      = StringSubstr(PFtxt,StringLen(PFtxt)-5);
         STDDEVtxt  = "0000000000" + DoubleToString(StdDev,0);          STDDEVtxt  = StringSubstr(STDDEVtxt,StringLen(STDDEVtxt)-5);
         OnTesterResulttxt = DoubleToString(OnTesterResult,0) + PROFITtxt + MAXDDtxt + RECFACTtxt + TRADEStxt + PFtxt + STDDEVtxt;
         Print("OnTesterResulttxt: ",OnTesterResulttxt);
         */

         }
      else
         Print("WARNING: RESULT IGNORED! OnTesterResult will be 0");
      }
   else
      Print("ERROR: CRASHED! OnTesterResult will be 0");
   
   
   //Print("-------------------END ONTESTER---------------------------------");
   OnTesterResult = NormalizeDouble(OnTesterResult,0);
   return(OnTesterResult);
   }





//+------------------------------------------------------------------+
//| Extra functions                                                  |
//+------------------------------------------------------------------+

double VidyaOnArray1(const int i,const int CmoPeriod,const int EmaPeriod,const int Shift,const double PrevValue,const double &Price[])
   {
   CMO1 = CmoOnArray(i,CmoPeriod,Shift,Price);
   if (CMO1<0) CMO1 = MathAbs(CMO1);
   Result1=(Price[i-Shift]*F1*CMO1)+(PrevValue*(1-F1*CMO1));
   return(Result1);
   }
   
double VidyaOnArray2(const int i,const int CmoPeriod,const int EmaPeriod,const int Shift,const double PrevValue,const double &Price[])
   {
   CMO2 = CmoOnArray(i,CmoPeriod,Shift,Price);
   if (CMO2<0) CMO2 = MathAbs(CMO2);
   Result2=(Price[i-Shift]*F2*CMO2)+(PrevValue*(1-F2*CMO2));
   return(Result2);
   }
   
double VidyaOnArray3(const int i,const int CmoPeriod,const int EmaPeriod,const int Shift,const double PrevValue,const double &Price[])
   {
   CMO3 = CmoOnArray(i,CmoPeriod,Shift,Price);
   if (CMO3<0) CMO3 = MathAbs(CMO3);
   Result3=(Price[i-Shift]*F3*CMO3)+(PrevValue*(1-F3*CMO3));
   return(Result3);
   }   
         
double CmoOnArray(const int i,const int CmoPeriod,const int Shift,const double &Price[])
   {
   double Result=0;
   double SumUp=0;
   double SumDn=0;
   double Diff;
   int Start = i-(CmoPeriod+Shift-1);
   int End = Start + CmoPeriod - 1;
   for(int j=Start;j<=End;j++)
      {
      Diff = Price[j]-Price[j-1];
      if (Diff>0)
         SumUp = SumUp + Diff;
      if (Diff<0)
         SumDn = SumDn - Diff;
      }
   if (SumDn < 0) SumDn = MathAbs(SumDn);
   if (SumUp+SumDn!=0) Result = (SumUp-SumDn)/(SumUp+SumDn);
   return(Result);
   }

//------------------------------------------------------------------   

void OpenBuy()
   {
   OpenTrades++;
   ArrayOpenPrice[OpenTrades] = Aopen[y]+Spread;
   }
   
void OpenSell()
   {
   OpenTrades++;
   ArrayOpenPrice[OpenTrades] = Aopen[y];
   }
   
void CloseAll()
   {
   for(int i=1;i<=OpenTrades;i++)
      {
      if (Direction==0)
         ProfitPip=Aopen[y]-ArrayOpenPrice[i];
      else
         ProfitPip=ArrayOpenPrice[i]-(Aopen[y]+Spread);

      if (ProfitPip>=0)
         GrossProfitPip=GrossProfitPip+ProfitPip;
      else
         GrossLossPip=GrossLossPip+MathAbs(ProfitPip);

      BalancePip=BalancePip+ProfitPip;
      Trades++;
      }
   OpenTrades=0;
   }

//----------------------------------------------------------------
//----------------------------------------------------------------
//----------------------------------------------------------------