//+------------------------------------------------------------------+
//|                                                      ProjectName |
//|                                      Copyright 2012, CompanyName |
//|                                       http://www.companyname.net |
//+------------------------------------------------------------------+
#property copyright "http://dmffx.com"
#property link      "http://dmffx.com"

#property indicator_chart_window
#property indicator_buffers 3
#property indicator_color1 CLR_NONE
#property indicator_color2 DeepSkyBlue
#property indicator_color3 Red
#property indicator_width2 1
#property indicator_width3 1

/*
   HLPeriod - Параметр зигзага аналогичный параметру ExtDepth индикатора ZigZag
   MinHeight - Минимальная высота колена зигзага по вертикали (в пунктах)
   Bottom - Допустимое отклонение значений на вершинах дна паттерна. Измеряется в пропорции от вертикального размера паттерна. Допустимые значения от 0 до 1
   Peaks - Минимальная разница значений на соседних пиках паттерна. Измеряется в пропорции от вертикального размера паттерна. Допустимые значения от 0 до 1
   Depth - Соотношение величины предшествующего паттерну движения цены к размеру паттерна от его дна до первого пика
*/

extern   int      HLPeriod       =  5;     // Параметр зигзага аналогичный параметру ExtDepth индикатора ZigZag
extern   int      MinHeight      =  0;     // Минимальная высота колена зигзага по вертикали (в пунктах)
extern   double   Bottom         =  1;     // Допустимое отклонение значений на вершинах дна паттерна. Измеряется в пропорции от вертикального размера паттерна. Допустимые значения от 0 до 1
extern   double   Peaks          =  0.00;  // Минимальная разница значений на соседних пиках паттерна. Измеряется в пропорции от вертикального размера паттерна. Допустимые значения от 0 до 1
extern   double   Depth          =  0;     // Соотношение величины предшествующего паттерну движения цены к размеру паттерна от его дна до первого пика

                                           //0.25//0.04//1.5

//---- buffers
double zz[];

double lht[];
double llt[];
double buy[];
double sell[];
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {

//---- indicators
   IndicatorBuffers(5);

   SetIndexStyle(0,DRAW_SECTION);
   SetIndexBuffer(0,zz);
   SetIndexEmptyValue(0,0.0);

   SetIndexStyle(1,DRAW_ARROW);
   SetIndexBuffer(1,buy);
   SetIndexArrow(1,233);
   SetIndexEmptyValue(1,0.0);

   SetIndexStyle(2,DRAW_ARROW);
   SetIndexBuffer(2,sell);
   SetIndexArrow(2,234);
   SetIndexEmptyValue(2,0.0);

   SetIndexBuffer(3,lht);
   SetIndexBuffer(4,llt);

   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
//----

//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {

//int cb=IndicatorCounted();
//int limit=Bars-cb-1;

   int cb=IndicatorCounted();
   if(cb<0) return(-1);
   if(cb>0) cb--;
   int limit=Bars-cb;
   if(cb==0)
     {
      limit-=1+1;
      ArrayInitialize(lht,0);
      ArrayInitialize(llt,0);
     }

   static datetime LastTime=0;
   static int cDir=0;
   static int pDir=0;
   static double cUp=0;
   static double pUp=0;
   static double cDn=0;
   static double pDn=0;

   if(cb==0)
     {
      LastTime=0;
      cDir=0;
      pDir=0;
      cUp=0;
      pUp=0;
      cDn=0;
      pDn=0;
     }

   for(int i=limit;i>=0;i--)
     {
      if(Time[i]>LastTime)
        {
         LastTime=Time[i];
         pDir=cDir;
         pUp=cUp;
         pDn=cDn;
        }
      else
        {
         cDir=pDir;
         cUp=pUp;
         cDn=pDn;
        }
      lht[i]=lht[i+1];
      llt[i]=llt[i+1];
      zz[i]=0;
      int lhb;
      int llb;
      int hb=iHighest(NULL,0,MODE_HIGH,HLPeriod,i);
      int lb=iLowest(NULL,0,MODE_LOW,HLPeriod,i);

      if(hb>-1 && lb>-1)
        {

         lhb=Bars-lht[i]-1;
         llb=Bars-llt[i]-1;
         //Print("lhb=",lhb," llb=",llb, " array",ArraySize(zz));
         //if (lhb>=0 && llb>=0)

         if(llb>lhb)
           {
            zz[lhb]=High[lhb];
           }
         else
           {
            zz[llb]=Low[llb];
           }

         if(hb==lb)
           {
            if(hb==i)
              {
               switch(cDir)
                 {
                  case 1:
                     if(High[i]>zz[lhb])
                       {
                        zz[lhb]=0;
                        zz[i]=High[i];
                        lht[i]=Bars-i-1;
                       }
                     else
                       {
                        if(Low[i]<=zz[lhb]-Point*MinHeight)
                          {
                           zz[i]=Low[i];
                           llt[i]=Bars-i-1;
                           cDir=-1;
                          }
                       }
                     break;
                  case -1:
                     if(Low[i]<zz[llb])
                       {
                        zz[llb]=0;
                        zz[i]=Low[i];
                        llt[i]=Bars-i-1;
                       }
                     else
                       {
                        if(High[i]>=zz[llb]+Point*MinHeight)
                          {
                           zz[i]=High[i];
                           lht[i]=Bars-i-1;
                           cDir=1;
                          }
                       }
                     break;
                 }
              }
           }
         else if(lb>hb)
           {
            if(hb==i)
              {
               if(cDir==1)
                 {
                  if(High[i]>zz[lhb])
                    {
                     zz[lhb]=0;
                     zz[i]=High[i];
                     lht[i]=Bars-i-1;
                    }
                 }
               else
                 {
                  if(High[i]>=zz[llb]+Point*MinHeight)
                    {
                     zz[i]=High[i];
                     lht[i]=Bars-i-1;
                     cDir=1;
                    }
                 }
              }
           }
         else if(hb>lb)
           {
            if(lb==i)
              {
               if(cDir==-1)
                 {
                  if(Low[i]<zz[llb])
                    {
                     zz[llb]=0;
                     zz[i]=Low[i];
                     llt[i]=Bars-i-1;
                    }
                 }
               else
                 {
                  if(Low[i]<=zz[lhb]-Point*MinHeight)
                    {
                     zz[i]=Low[i];
                     llt[i]=Bars-i-1;
                     cDir=-1;
                    }
                 }
              }
           }


        }

      buy[i]=0;
      sell[i]=0;
      if(cDir==-1)
        {
         if(pDir==1)
           {
            cUp=0;
            int z0=Bars-lht[i]-1;
            int z1=Bars-llt[z0]-1;
            int z2=Bars-lht[z1]-1;
            int z3=Bars-llt[z2]-1;
            int z4=Bars-lht[z3]-1;
            int z5=Bars-llt[z4]-1;
            int z6=Bars-lht[z5]-1;
            int z7=Bars-llt[z6]-1;
            if(zz[z4]<zz[z2] && zz[z2]<zz[z0])
              {
               double min=MathMin(zz[z1],zz[z3]);
               double size=zz[z0]-min;
               if(MathAbs(zz[z1]-zz[z3])<=Bottom*size)
                 {
                  if(zz[z4]-zz[z5]>Depth*(zz[z4]-min))
                    {
                     if(zz[z4]<zz[z2]-Peaks*size && zz[z2]<zz[z0]-Peaks*size)
                       {
                        cDn=min;
                       }
                    }
                 }
              }
           }
        }

      if(cDir==1)
        {
         if(pDir==-1)
           {
            cDn=0;
            z0=Bars-llt[i]-1;
            z1=Bars-lht[z0]-1;
            z2=Bars-llt[z1]-1;
            z3=Bars-lht[z2]-1;
            z4=Bars-llt[z3]-1;
            z5=Bars-lht[z4]-1;
            z6=Bars-llt[z5]-1;
            z7=Bars-lht[z6]-1;
            if(zz[z4]>zz[z2] && zz[z2]>zz[z0])
              {
               min=MathMax(zz[z1],zz[z3]);
               size=min-zz[z0];
               if(MathAbs(zz[z1]-zz[z3])<=Bottom*size)
                 {
                  if(zz[z5]-zz[z4]>Depth*(min-zz[z4]))
                    {
                     if(zz[z4]>zz[z2]+Peaks*size && zz[z2]>zz[z0]+Peaks*size)
                       {
                        cUp=min;
                       }
                    }
                 }
              }
           }
        }
      if(cDn!=0)
        {
         if(Low[i]<cDn)
           {
            cDn=0;
            sell[i]=High[i]+Point*5;
           }
        }
      if(cUp!=0)
        {
         if(High[i]>cUp)
           {
            cUp=0;
            buy[i]=Low[i]-Point*5;
           }
        }
     }
   return(0);
  }
//+------------------------------------------------------------------+