//+------------------------------------------------------------------+
//|                                                    TrendAndDiver |
//|                      Copyright © 2005, MetaQuotes Software Corp. |
//|                                        http://www.metaquotes.net |
//+------------------------------------------------------------------+
#include <WinUser32.mqh>
#include <stderror.mqh>
#include <stdlib.mqh>
//+------------------------------------------------------------------+
//| EX4 imports                                                      |
//+------------------------------------------------------------------+
 #import "Diver.ex4"
 int BreackUpTrendCondition (int TimeFrame, int MaxWaveNum);
 int BreackDownTrendCondition (int TimeFrame, int WaveNum);
 bool SeachDiv(int TimeFrame, int MaxWaveNum, int StartBar);
 bool SeachConv(int TimeFrame,int cMaxWaveNum,int StartBar);
 bool DiverKind(int SeekBar, int TimeFrame);
 bool ConvKind(int SeekBar, int TimeFrame);
 void dinstall(int StrBar);
 void cinstall(int StrBar);
 void AddpipsInit(int spips,int bpips);
 void PeriodInit(int P1,int P2);
 #import
//+------------------------------------------------------------------+

#property copyright "Mikhail Sapozhnikov "
#property link      "http://www.metaquotes.net"

//---- input parameters

//extern int    trend = 1;

extern double Lots = 1;
extern double StopLoss = 150;
extern double TakeProfit = 0;

extern double    dADX0 = 65; 
extern double    dADX1 = 30 ;
extern double    cADX0 = 30; 
extern double Bulls100=0.041  ;
//extern double Bears100=-0.02;
extern double MaxStStopSellonDn= 25;
extern double MinStSellonDn=53;
extern int    cWaveTopNum = 12;
extern int    dWaveTopNum = 8;
extern double    dMinTp = 600;
extern int Days=5 ;

extern int    OrderNum=3;
extern int    MainOrderNum=2;
extern int    LocalOrderNum=2;
extern int    LocalOrderNum1=3;
extern double Boundary=0.5;

extern int    Spips=25;
extern int    Bpips=0;
// ----- Трендовые константы ------
#define Up 3
#define Flat 2  
#define Down 1
#define Unknown -1

#define NoSignal 9
#define Ready 8
#define Ready1 7
#define Ready2 6
#define Go 1
#define TakeYourTime 10
#define MainLongMagic 234
#define LongMagic 2345
#define LongMagic1 2346
#define LongMagic2 2347
#define MainShortMagic 123
#define ShortMagic 1235
#define ShortMagic1 1236
#define ShortMagic2 1237


 int  cMainFrame=PERIOD_D1;
 int  cSlaveFrame=PERIOD_W1;
 int  dMainFrame=PERIOD_W1;
 int  dSlaveFrame=PERIOD_H4;
 int  shift=0; //Готовимся к анализу на прошлых барах
 double    W1MinBears=-0.055 ;

 int    Week = 5;
 bool Gb,test1;

int total,OrderCount; //общее кол-во открытых ордеров
int lastCloseMagic, lastCloseProf;

int sMagicNum,sMagicNum1, sMagicNum2, sMainMagicNum,
    lMagicNum, lMagicNum1, lMagicNum2, lMainMagicNum; 

int lWaitMagicCnt;
int sWeekMnMagicCnt,lWeekMnMagicCnt,lDayMagicCnt, sDayMagicCnt;
int sDaySmallMagicCnt, sDaySmallMagic2Cnt, lDaySmallMagicCnt,lDaySmallMagic2Cnt;

datetime  LastMainDnGoWeek,LastMainUpGoWeek;
datetime  LastLocDnGoDay,LastLocUpGoDay;
datetime  LastSmallUpDay, LastSmallUpDay2, LastSmallDnDay, LastSmallDn2Day;

double StartBalance, HPR, SumHPR, AHPR, GHPR;

int BarsNum=500, BullsP=13, BearsP=13, ADXperiod=13, adx55step=16;
   
//== сигналы  ===
double buyADX, sellADX,sellADXDmax, sellADXWmax;

  int WaitUp, WaitDn, WaitCorre, WaitCont, WaitSmallCorr,WaitSmallCont,
      WaitSmallUp, WaitSmallDn;

  int sStartWaitingTime,bStartWaitingTime,sStartCorreTime, sStartTakeYourTime; //начало отсчета
  int MainTrend,  LocalTrend, SmallTrend,MA100Vector;
  int   WaveNum, LongCall, ShortCall;
  

bool SetGlobVar(string Name, int Val)
{ datetime Now=TimeCurrent(), r=0;
  while (!(r>0 || TimeCurrent()-Now>10))
   r=GlobalVariableSet(Name,Val);
   if(r==0)
    { Print("Oшибка ",GetLastError()," глобальной переменной ",Name);
            return(false);            
    }
    return(true);
}

//--------------------------
bool LastCloseParam()
{ int i , histotal= OrdersHistoryTotal();
   int mag;
   bool Y;
   
    for( i=histotal-1;i>=0;i--)
    {
    if(OrderSelect(i,SELECT_BY_POS,MODE_HISTORY)==false) 
    { Print("Error in history!");lastCloseProf=0 ;break; }
    if(OrderSymbol()!=Symbol() || OrderType()>OP_SELL) continue;
 
     lastCloseMagic=OrderMagicNumber();
    if ((lastCloseMagic!=MainLongMagic 
        && lastCloseMagic!=LongMagic 
        && lastCloseMagic!=LongMagic1 
        && lastCloseMagic!=LongMagic2 
        && lastCloseMagic!=MainShortMagic 
        && lastCloseMagic!=ShortMagic 
        && lastCloseMagic!=ShortMagic1 
        && lastCloseMagic!=ShortMagic2 ))
         {Y=false;continue;}
        Y=true;
       lastCloseProf=OrderProfit();
       break;
   }
   
   if(lastCloseProf>=0) Y=true;
   else Y=false;
 return(Y);
}

//-------------------------- 
 void OrdersMagic() 
  {  int cn; 
     double Prof;
     
     lMagicNum=0;
     lMagicNum1=0;
     lMagicNum2=0;
     lMainMagicNum=0;
     lWeekMnMagicCnt=0;
     lDayMagicCnt=0;
     lDaySmallMagicCnt=0;
     lDaySmallMagic2Cnt=0;
    
     sMagicNum=0;
     sMagicNum1=0;
     sMagicNum2=0;
     sMainMagicNum=0;
     sWeekMnMagicCnt=0;
     sDayMagicCnt=0;
     sDaySmallMagicCnt=0;
     sDaySmallMagic2Cnt=0;


    lWaitMagicCnt=0;    
    
     for(cn=0;cn<total;cn++)
       {//for
        if( OrderSelect(cn, SELECT_BY_POS, MODE_TRADES)==true)
        if(OrderType()<=OP_SELL && 
           OrderSymbol()==Symbol())  // check for symbol
          {//1 
        if(OrderType()==OP_BUY)   // long position is opened
            {//2
            if(OrderMagicNumber()==MainLongMagic)
              { lMainMagicNum++; LastMainUpGoWeek=OrderOpenTime();
                if(TimeCurrent()- LastMainUpGoWeek<86400*10)
                 lWeekMnMagicCnt++;
                 continue;
               }    
                         
             if(OrderMagicNumber()==LongMagic)
              {lMagicNum++; LastLocUpGoDay=OrderOpenTime();
                if(TimeCurrent()- LastLocUpGoDay<86400*3)
                lDayMagicCnt++;
                continue;
               }
               
             if(OrderMagicNumber()==LongMagic1) 
             {lMagicNum1++; LastSmallUpDay=OrderOpenTime();
              if( TimeCurrent()-LastSmallUpDay<86400*2)
               lDaySmallMagicCnt++;

             if(Bid-OrderOpenPrice()>90*Point && !(OrderStopLoss()==OrderOpenPrice()) )
                 OrderModify(OrderTicket(),Bid-20*Point,OrderOpenPrice(),OrderTakeProfit(),0,Gold);
              
               if(Bid-OrderOpenPrice()>200*Point)
                 {LocalTrend=Up; GlobalVariableSet("gLocalTrend"+Symbol(),Up);}
             continue;    
           }
              
             if(OrderMagicNumber()==LongMagic2) 
             {lMagicNum2++; LastSmallUpDay2=OrderOpenTime();
              if( TimeCurrent()-LastSmallUpDay2<86400*2)
               lDaySmallMagic2Cnt++;
               continue;
               }
            }
        if(OrderType()==OP_SELL) 
            {if(OrderMagicNumber()==MainShortMagic) 
            {sMainMagicNum++;LastMainDnGoWeek=OrderOpenTime();
             if(TimeCurrent()- LastMainDnGoWeek<86400*10)
             sWeekMnMagicCnt++;
             continue;
             }              
            if(OrderMagicNumber()==ShortMagic)
             {sMagicNum++;LastLocDnGoDay=OrderOpenTime();
              if(TimeCurrent()- LastLocDnGoDay<86400*5)
                sDayMagicCnt++;
             if( TimeCurrent()-LastLocDnGoDay>86400*Days 
                  )
             {  if(iMA(NULL,cMainFrame,100,0,MODE_SMA,PRICE_CLOSE,1)
                  >iMA(NULL,cMainFrame,100,0,MODE_SMA,PRICE_CLOSE,10))
              {Prof=MathFloor(10000*iIchimoku(NULL, dMainFrame, 9, 26, 52, MODE_KIJUNSEN, 0))/10000;
               if (Prof-MathFloor(10000*iIchimoku(NULL, dMainFrame, 9, 26, 52, MODE_KIJUNSEN, 1))/10000>3*Point
                   && Prof!=OrderTakeProfit()  )
              { if(sellADXDmax>=59) 
               { if( (sellADXDmax<=68 || MainTrend==Down) && OrderOpenPrice()-Bid >15*Point
                      && OrderStopLoss()!=OrderOpenPrice())
                  OrderModify(OrderTicket(),OrderOpenPrice(),OrderOpenPrice(),Prof,0,Gold);
                }
                } 
               }
              }
            continue;
              }
            if(OrderMagicNumber()==ShortMagic1)
             {sMagicNum1++; LastSmallDnDay=OrderOpenTime();
              if(TimeCurrent()- LastSmallDnDay<86400*3)
                sDaySmallMagicCnt++;
              continue;
              }
             if(OrderMagicNumber()==ShortMagic2)
             {sMagicNum2++; LastSmallDn2Day=OrderOpenTime();
              if(TimeCurrent()- LastSmallDn2Day<86400*1)
                sDaySmallMagic2Cnt++;
                if( iMA(NULL,240,21,0,MODE_EMA,PRICE_CLOSE,21)-
                   iMA(NULL,240,21,0,MODE_EMA,PRICE_CLOSE,1)>=90*Point
                   &&  OrderTakeProfit()>0)
                   OrderModify(OrderTicket(),OrderOpenPrice(),OrderStopLoss(),0,0,Gold);   
              }
              continue; 
            }
          }
       }
 }
//==============================

   int CheckADX (int TimeFrame, int P, int Start, int adxStep)
 {
    if ( iADX(NULL,TimeFrame,P,PRICE_HIGH,MODE_MAIN,Start)<
         iADX(NULL,TimeFrame,P,PRICE_HIGH,MODE_MAIN,Start+adxStep)
        )
        return(Down);
        else
        {if ( iADX(NULL,TimeFrame,P,PRICE_HIGH,MODE_MAIN,Start)>
         iADX(NULL,TimeFrame,P,PRICE_HIGH,MODE_MAIN,Start+adxStep))
        return(Up);}
    return(Flat);
   }
//--------------------------------------------------------------
   int CheckiMa(int TimeFrame, int P, int Mode, int Start, int Step)
 {
    if ( iMA(NULL,TimeFrame,P,0,PRICE_CLOSE,Mode,Start)<
         iMA(NULL,TimeFrame,P,0,PRICE_CLOSE,Mode,Start+Step)
        )
        return(Down);
        else
        {if (iMA(NULL,TimeFrame,P,0,PRICE_CLOSE,Mode,Start)>
         iMA(NULL,TimeFrame,P,0,PRICE_CLOSE,Mode,Start+Step))
        return(Up);}
    return(Flat);
   }
//===================================================================+
double minStoch(int Frame, int StartBar, int BarCnt )
{ int i,j;
 double minStoch;
 minStoch=iStochastic(NULL,Frame,8,3,3,MODE_SMA,0,MODE_MAIN, StartBar);
for (i=StartBar+1;i<=StartBar+BarCnt;i++)
{ if(minStoch>iStochastic(NULL,Frame,8,3,3,MODE_SMA,0,MODE_MAIN, i))
   minStoch=iStochastic(NULL,Frame,8,3,3,MODE_SMA,0,MODE_MAIN, i);
}//for
return(minStoch);
}
//===================================================================+
double maxADX(int Frame, int StartBar, int BarCnt )
{ int i,j;
 double maxAD=iADX(NULL,Frame,13,PRICE_HIGH,MODE_MAIN,StartBar);
 for (i=StartBar+1;i<=StartBar+BarCnt;i++)
{ if(maxAD<iADX(NULL,Frame,13,PRICE_HIGH,MODE_MAIN,i))
   maxAD=iADX(NULL,Frame,13,PRICE_HIGH,MODE_MAIN,i);
}//for
return(maxAD);
}
//===================================================================+
double BearForce(int Frame, int BarCnt )
{ int i,j;
 double Bear;
 Bear= iBearsPower( NULL, Frame, 13, PRICE_CLOSE, 1);
for (i=2;i<=BarCnt;i++)
{ if(Bear>iBearsPower( NULL, Frame, 13, PRICE_CLOSE, i))
   Bear=iBearsPower( NULL, Frame, 13, PRICE_CLOSE, i);
}//for
return(Bear);
}
double BullDecline(int Frame, int BarCnt )
{ int i,j;
 double  Bull;
 Bull= iBullsPower( NULL, Frame, 13, PRICE_CLOSE, 1);
for (i=2;i<=BarCnt;i++)
{ if(Bull>iBullsPower( NULL, Frame, 13, PRICE_CLOSE, i))
   Bull=iBullsPower( NULL, Frame, 13, PRICE_CLOSE, i);
}//for
return(Bull);
}
//+------------------------------------------------------------------+
//  условия для дивергенции
//+------------------------------------------------------------------+
double dStrongCond (int TimeFrame, double dADXhigh, int StBar)
{  double tmpADX;
    tmpADX=iADX(NULL,TimeFrame,ADXperiod,PRICE_HIGH,MODE_MAIN,StBar);
  if (  ( tmpADX>dADXhigh 
        && iADX(NULL,TimeFrame,ADXperiod,PRICE_HIGH,MODE_PLUSDI,StBar+1)>
           iADX(NULL,TimeFrame,ADXperiod,PRICE_HIGH,MODE_MINUSDI,StBar+1))
      )
     return(tmpADX);
     else
     return(0);
}

//+------------------------------------------------------------------+
//  условия для конвергенции
//+------------------------------------------------------------------+
double  cMidlCond(int TimeFrame,int applied_price, double cADXhigh, int StBar)
{
double tmpADX;
   tmpADX=iADX(NULL,TimeFrame,ADXperiod,applied_price,MODE_MAIN,StBar);
if (  ( tmpADX>cADXhigh 
        && iADX(NULL,TimeFrame,ADXperiod,applied_price,MODE_PLUSDI,StBar+1)<
        iADX(NULL,TimeFrame,ADXperiod,applied_price,MODE_MINUSDI,StBar+1))
        ) 
        return(tmpADX);
        else
        return(0);
}  

//+------------------------------------------------------------------+
//| expert  function for short 
//+------------------------------------------------------------------+
int MainShortOrder(int OrderCnt, int MagNum, double  sTP=0)
{   datetime Begin=TimeCurrent();
    double SL; // StopLoss в пунктах
     int mg, error,result;
     bool Y;
//---- 
if( total<OrderNum )
{Y=true;
mg=MagNum;
switch (mg)
{
case MainShortMagic :
{ if (
       sMainMagicNum>=MainOrderNum 
     || sWeekMnMagicCnt>=1 ) 
    Y=false;
   else    SL= iHigh(NULL,dMainFrame,0)+250*Point;
 }
 break;
 case ShortMagic :
 if (sMagicNum>=LocalOrderNum
 || sDayMagicCnt>=1)
  Y=false;
   else    SL= iHigh(NULL,dMainFrame,0)+StopLoss*Point;
 break;
 case ShortMagic1 :
 if (sMagicNum1>=LocalOrderNum1
     || sDaySmallMagicCnt>=1 ) 
 Y=false;
  else    SL= iHigh(NULL,dMainFrame,0)+StopLoss*Point;
 break;
 case ShortMagic2 :
 {if (sMagicNum2>=LocalOrderNum1
     || sDaySmallMagic2Cnt>=1 ) 
 Y=false;
 else    SL= iHigh(NULL,dMainFrame,0)+80*Point;
 }
 break;

 }//sw
}else Y=false;


if(Y )
{
  result= OrderSend(Symbol(),OP_SELL,Lots,Bid,3,SL,
           sTP,"",mg,0,White);
  
   if (result==-1)
    {error=GetLastError();
      Print("error(",error,"): ",ErrorDescription(error));
       if(!IsTesting())
         {while(!( result>0 || TimeCurrent()-Begin>20))
          {Sleep(1000);   RefreshRates();
           result= OrderSend(Symbol(),OP_SELL,Lots,Bid,3,SL,
            sTP,"",mg,0,White); }
         }
     }
           else  
           { total=OrdersTotal();ChangeLot();
            SelectData();
           }
   }
   return(result);
 }
 
	   
//-----------------------------------------  
// Профит для длинных позиций на конвергенции D1
//-----------------------------------------
  double bProfit( double Adx)
  { double Level;
    double Level1;
   if (
   CheckADX(1440,13,0,adx55step)==Up
        || MainTrend==Up)
   { 
    Level=0;
  return(0);   }
  else
   { 
   //Если движение наисходе, ограничиваем Profit
   if (CheckADX(1440,13,0,adx55step)==Down)
     {Level1 =       iMA(NULL,cMainFrame,55,0,MODE_EMA,PRICE_HIGH, 0 );
      Level=Level1 + iMA(NULL,cMainFrame,55,0,MODE_EMA,PRICE_HIGH,1)-
                     iMA(NULL,cMainFrame,55,0,MODE_SMA,PRICE_HIGH, 10);
      return(Level);
      }
   }
  return(Level);
  }
  
 int MainLongOrder(double  bTkP=0, int Mag=MainLongMagic)
{ datetime Begin=TimeCurrent();
double StL;
  int magic, res, err;
  res=-1;
   if( total<OrderNum )
{ 
     magic=Mag;
     switch (magic)
     {case MainLongMagic :
      {if (lMainMagicNum>=MainOrderNum
      || lWeekMnMagicCnt>=1
      ) return;
      else  StL=iLow(NULL,cMainFrame,0)-StopLoss*Point;
      }
      break;
      case LongMagic :
      {if (lMagicNum>=LocalOrderNum
      || lDayMagicCnt>=1)return;
      else  StL=iLow(NULL,cMainFrame,0)-StopLoss*Point;
      }
      break;
      case LongMagic1 :
      {if (lMagicNum1>=LocalOrderNum1
      || lDaySmallMagicCnt>=1)return;
      else  StL=iLow(NULL,cMainFrame,0)-80*Point;
      }
      break;
      case LongMagic2 :
      {if (lMagicNum2>=LocalOrderNum1
      || lDaySmallMagic2Cnt>=1)return;
      else  StL=iLow(NULL,cMainFrame,0)-80*Point;
      }
     }
        res= OrderSend(Symbol(),OP_BUY,Lots,Ask,3,StL,
           bTkP,"",magic,0,Lime);

    if (res<0)
        {err=GetLastError();
         Print("error(",err,"): ",ErrorDescription(err));
    if(!IsTesting())
     {while(!( res>0 || TimeCurrent()-Begin>20))
      {Sleep(1000);   RefreshRates();
       res=OrderSend(Symbol(),OP_BUY,Lots,Ask,3,StL,
           bTkP,"",magic,0,Lime);
      }
     }

         }
        else   { total=OrdersTotal();ChangeLot(); SelectData(); }
}
    return(res);
}

void SelectData()
{ double BullTop, BearTop, AdxD1,AdxD2;
Print("WaveNum=",WaveNum);
int Move=CheckADX(1440,13,1,2);
if (Move==Up) Print("ADX Up");
 else 
  if (Move==Down) Print("ADX Down");
  else
    if (Move==Flat) Print("ADX Flat");

AdxD1=  iADX(NULL,1440,13,PRICE_HIGH,MODE_MAIN,1);
AdxD2=  iADX(NULL,1440,13,PRICE_HIGH,MODE_MAIN,2);
Print("AdxD1=",AdxD1,"  AdxD2=",AdxD2);
Print("sellADXDmax=",sellADXDmax);

BullTop=iBullsPower( NULL, dMainFrame, 13, PRICE_CLOSE, 0);
for (int i=1;i==10;i++)
{if(iBullsPower( NULL, dMainFrame, 13, PRICE_CLOSE, i)>BullTop)
BullTop=iBullsPower( NULL, dMainFrame, 13, PRICE_CLOSE, i);
}
BearTop=iBearsPower( NULL, dMainFrame, 13, PRICE_CLOSE, 0);
for ( i=1;i==10;i++)
{if(iBearsPower( NULL, dMainFrame, 13, PRICE_CLOSE, i)>BearTop)
BearTop=iBearsPower( NULL, dMainFrame, 13, PRICE_CLOSE, i);
}
if(WaitDn==Ready) Print("WaitDn=Ready");
else
  if(WaitDn==NoSignal) Print("WaitDn=NoSignal");
  else
  if(WaitDn==Go) {Print("WaitDn=Go");
   Print("Bid=", Bid);}   

if(WaitUp==Ready) Print("WaitUp=Ready");
else
  if(WaitUp==NoSignal) Print("WaitUp=NoSignal");
  else
  if(WaitUp==Go) {Print("WaitUp=Go");
   Print("Ask=", Ask);}   
Print("BullTop=",BullTop,"  BearTop=",BearTop);
if(WaitCorre==Ready) Print("WaitCorre=Ready");
else
  if(WaitCorre==NoSignal) Print("WaitCorre=NoSignal");
  else
  if(WaitCorre==Go) {Print("WaitCorre=Go");
   Print("Bid=", Bid);}
   
if(WaitCont==Ready) Print("WaitCont=Ready");
 else
   if(WaitCont==Go)
  {Print("WaitCont=Go"); Print("Ask=", Ask); }   
  Print("");
  Print("========================= New Data =======================================");
return;
}

void ChangeLot()
{ int histtotal=OrdersHistoryTotal();
      if(histtotal>0)
      {HPR=(AccountBalance()/(AccountBalance()-lastCloseProf));
       SumHPR=SumHPR+HPR;
       AHPR=(SumHPR)/histtotal;
       }

 if(lastCloseProf>0) Lots+=0.1;
  if(lastCloseProf<0) Lots-=0.1;
     if(Lots>5)   Lots=5;
     if(Lots<0.1)   Lots=0.1;
}

void TestInstall()
{ if(TimeCurrent()<StrToTime("2006.10.10 00:00"))
{WaveNum=0;
WaitUp=NoSignal; WaitDn=NoSignal;  WaitCorre=NoSignal;
 MainTrend=Unknown;
 LocalTrend=Unknown;
 SmallTrend=Unknown;  
 WaitSmallUp=NoSignal;
 WaitSmallDn=NoSignal;
 WaitSmallCont=NoSignal;}
 else
 { if(  TimeCurrent()<StrToTime("2007.9.21 00:00"))
   {MainTrend=Up;SetGlobVar("gMainTrend"+Symbol(),MainTrend);}
   if(TimeCurrent()<StrToTime("2006.12.08 16:01"))
   {LocalTrend=Up;SetGlobVar("gLocalTrend"+Symbol(),LocalTrend);
   WaveNum=1;SetGlobVar("gWaveNum"+Symbol(),1);}
   else
   if(TimeCurrent()<StrToTime("2007.01.11 15:20"))
   {LocalTrend=Down;SetGlobVar("gLocalTrend"+Symbol(),LocalTrend);
   WaveNum=2;SetGlobVar("gWaveNum"+Symbol(),WaveNum);}
   else
   if(TimeCurrent()<StrToTime("2007.04.25 00:00"))
   {LocalTrend=Up;SetGlobVar("gLocalTrend"+Symbol(),LocalTrend);
   WaveNum=3;SetGlobVar("gWaveNum"+Symbol(),WaveNum);}
      else
   if(TimeCurrent()<StrToTime("2007.06.2 00:00"))
   {LocalTrend=Down;SetGlobVar("gLocalTrend"+Symbol(),LocalTrend);
   WaveNum=4;SetGlobVar("gWaveNum"+Symbol(),WaveNum);}
      else
   if(TimeCurrent()<StrToTime("2007.07.17 00:00"))
   {LocalTrend=Up;SetGlobVar("gLocalTrend"+Symbol(),LocalTrend);
   WaveNum=5;SetGlobVar("gWaveNum"+Symbol(),WaveNum);}
      else
   if(TimeCurrent()<StrToTime("2007.08.20 00:00"))
   {LocalTrend=Down;SetGlobVar("gLocalTrend"+Symbol(),LocalTrend);
   WaveNum=6;SetGlobVar("gWaveNum"+Symbol(),WaveNum);}
      else
   if(TimeCurrent()<StrToTime("2007.09.21 00:00"))
   {LocalTrend=Up;SetGlobVar("gLocalTrend"+Symbol(),LocalTrend);
   WaveNum=7;SetGlobVar("gWaveNum"+Symbol(),WaveNum);}

}
}
//+------------------------------------------------------------------+
//| expert initialization function                                   |
//+------------------------------------------------------------------+
int init()
 {    LastMainUpGoWeek=0;
      LastMainDnGoWeek=0;
      LastLocUpGoDay=0;
      LastLocDnGoDay=0;
      LastSmallUpDay=0;
      LastSmallUpDay2=0;
      LastSmallDnDay=0;
      LastSmallDn2Day=0;
      StartBalance=AccountBalance(); HPR=0; SumHPR=0;
      AHPR=0; GHPR=0;
      
   test1=true;  
   Gb=true;

    if (!GlobalVariableCheck("gMainTrend"+Symbol()))
      Gb= SetGlobVar("gMainTrend"+Symbol(),Unknown);
    if (!GlobalVariableCheck("gLocalTrend"+Symbol()))
      Gb=  Gb &&   SetGlobVar("gLocalTrend"+Symbol(),Unknown);
    if (!GlobalVariableCheck("gSmallTrend"+Symbol()))
      Gb=  Gb &&   SetGlobVar("gSmallTrend"+Symbol(),Unknown);  
    
    if (!GlobalVariableCheck("gWaitUp"+Symbol()))
      Gb=  Gb &&   SetGlobVar("gWaitUp"+Symbol(),NoSignal);  
    if (!GlobalVariableCheck("gWaitDn"+Symbol()))
      Gb=  Gb &&   SetGlobVar("gWaitDn"+Symbol(),NoSignal);  
     if (!GlobalVariableCheck("gWaitCorre"+Symbol()))
      Gb=  Gb &&   SetGlobVar("gWaitCorre"+Symbol(),NoSignal);  
     if (!GlobalVariableCheck("gWaitSmallUp"+Symbol()))
      Gb=  Gb &&   SetGlobVar("gWaitSmallUp"+Symbol(),NoSignal);  
     if (!GlobalVariableCheck("gWaitSmallDn"+Symbol()))
      Gb=  Gb &&   SetGlobVar("gWaitSmallDn"+Symbol(),NoSignal);  
     if (!GlobalVariableCheck("gWaitSmallCont"+Symbol()))
      Gb=  Gb &&   SetGlobVar("gWaitSmallCont"+Symbol(),NoSignal);  
     if (!GlobalVariableCheck("gWaveNum"+Symbol()))
      Gb=  Gb &&   SetGlobVar("gWaveNum"+Symbol(),0);  
     if (!GlobalVariableCheck("sWaitTime"+Symbol()))
      Gb=  Gb &&   SetGlobVar("sWaitTime"+Symbol(),0);  
     if (!GlobalVariableCheck("bWaitTime"+Symbol()))
      Gb=  Gb &&   SetGlobVar("bWaitTime"+Symbol(),0);  
                    
     
   WaitCont=NoSignal;
   if (! IsTesting())
   {  MainTrend=GlobalVariableGet("gMainTrend"+Symbol());
      LocalTrend=GlobalVariableGet("gLocalTrend"+Symbol());
      WaitUp=GlobalVariableGet("gWaitUp"+Symbol());
      WaitDn=GlobalVariableGet("gWaitDn"+Symbol());
      WaitCorre=GlobalVariableGet("gWaitCorre"+Symbol());
      WaitSmallUp=GlobalVariableGet("gWaitSmallUp"+Symbol());
      WaitSmallDn=GlobalVariableGet("gWaitSmallDn"+Symbol());
      WaitSmallCont=GlobalVariableGet("gWaitSmallCont"+Symbol());
      sStartWaitingTime=GlobalVariableGet("sWaitTime"+Symbol()); 
      bStartWaitingTime=GlobalVariableGet("bWaitTime"+Symbol()); 

    }  else
{WaveNum=0;
WaitUp=NoSignal; WaitDn=NoSignal;  WaitCorre=NoSignal;
 MainTrend=Unknown;
 LocalTrend=Unknown;
 SmallTrend=Unknown;  
 WaitSmallUp=NoSignal;
 WaitSmallDn=NoSignal;
 WaitSmallCont=NoSignal;
}

//----
 AddpipsInit(Spips, Bpips);
 PeriodInit(BearsP,BullsP);
 OrderCount=OrdersTotal();

//----
   return(0);
  }
//+------------------------------------------------------------------+
//| expert deinitialization function                                 |
//+------------------------------------------------------------------+
int deinit()
  {int histtotal=OrdersHistoryTotal();
      if(histtotal>0)
      {GHPR=MathPow(StartBalance/AccountBalance(),1/histtotal);
      Print("AHPR=",AHPR,"   GHPR=",GHPR);
       }
   
//----
   return(0);
  }
  
//+------------------------------------------------------------------+
//| expert start function                                            |
//+------------------------------------------------------------------+
int start()
   {if (!Gb) 
   {Print("Begin againe!!");
   return(0);}

//MainTrend=trend;SetGlobVar("gMainTrend"+Symbol(),MainTrend);
//LocalTrend=trend;SetGlobVar("gMainTrend"+Symbol(),MainTrend);
    int  cnt;//счетчик ордеров
    int  res; // результат установкм ордера
    int err,i,j;
    int shift55; //сдвиг  на H4 с периодом ADX 55
    double maxAdx;
   double Adx;
    double StL; // StopLoss в пунктах
    double bTkP; // TakeProfit в пунктах
    double sTkP; // TakeProfit в пунктах
     int magic;
//---- 
   if(Bars<BarsNum)  return(0);  
     if (IsTesting() &&  test1)
  { TestInstall(); test1=false;}

  MA100Vector=Up; 
     res=0;//вспомогательная перем. для сохр. рузультатов установки ордеров
     total=OrdersTotal();
     LastCloseParam();
    OrdersMagic();     

    if (OrderCount<total)
    OrderCount=total;


      //Готовимся анализировать график на закрытых барах
       if (shift>0)
         shift55=(shift-1)*6+1+TimeHour(TimeCurrent())/4;
       else
        shift55=0;  

//============================================================== 
// До тех пор пока количество пиков индикатора на будет равным WaveTopNum 
// исследуем график на наличие дивергенции м-ду индикаторм и High(Low)_ 
//Проверяется дивергенция и-ду баром 0 и 1 и если дивергенции нет,
// а быки на баре 1 сильнее, то бар 1 становится началом поиска дивергенции.
// Если дивергенция есть - увеличиваем счетчик дивергенций и сохраняем номер ее бара.
// "По пути" находятся пики индикатора силы быков(медведей). На них счетчик 
//волн увеличивается на 1
// Так продолжается до тех пор, пока не  обнаружено три дивергеенции (Div=3), 
// или не найдено WaveTopNum пиков индикатора.
//============================================================== 
//-----------Принятие решения по коротким позициям ------------
  switch(WaitDn)
   {//sw
   case NoSignal :
   {
 sellADX=dStrongCond(dMainFrame,dADX0,0) ;
 if (  sellADX>0  )
 { AddpipsInit(Spips, Bpips);

 if (  SeachDiv(dMainFrame,dWaveTopNum,shift) 
       &&  DiverKind(0, dMainFrame)
     )
  {  
           if ( CheckADX(240,55,shift,adx55step)==Down
           && maxADX(1440, 1, 30 )<81)
           {//Print("sellADXDmax=",sellADXDmax);
           WaitDn=Go; SetGlobVar("gWaitDn"+Symbol(), Go);
           sStartWaitingTime = TimeCurrent();
           }
           else
           {WaitDn=Ready;  SetGlobVar("gWaitDn"+Symbol(), Ready);}
 }// if Seach
 }
 }//case  NoSignal  
 break;
case Ready : 
 {//case Ready
  if (maxADX(1440, 1, 30 )<81) 
        {WaitDn=Go; sStartWaitingTime = TimeCurrent();SetGlobVar("sWaitTime"+Symbol(), sStartWaitingTime);
        SetGlobVar("gWaitDn"+Symbol(), Go);
        }
        else 
        {WaitDn=TakeYourTime;SetGlobVar("gWaitDn"+Symbol(), TakeYourTime);
              sStartTakeYourTime = TimeCurrent();}
  }//case Ready
break;
case Go : 
 {//case Go
  // Alert("Продаем!"); 
   MainShortOrder(OrderNum,MainShortMagic);
   if(MainTrend!=Down)
         {WaveNum=1;SetGlobVar("gWaveNum"+Symbol(),1);}
         else  if(TimeCurrent()- LastMainDnGoWeek>86400*40)
         {WaveNum++;SetGlobVar("gWaveNum"+Symbol(),WaveNum);}//Wave counter

   MainTrend=Down;
   GlobalVariableSetOnCondition("gMainTrend"+Symbol(), Down, Up);
   GlobalVariableSetOnCondition("gMainTrend"+Symbol(), Down, Flat);
   LocalTrend=Down;GlobalVariableSet("gLocalTrend"+Symbol(),Down);

if((TimeCurrent()-sStartWaitingTime) > 864000 )
WaitDn=NoSignal;    SetGlobVar("gWaitDn"+Symbol(),NoSignal);
sStartWaitingTime=NoSignal;SetGlobVar("sWaitTime"+Symbol(), sStartWaitingTime);
 }//case Go
 break;
 case TakeYourTime : 
 {
 if(iClose(NULL, cMainFrame,1)-iOpen(NULL, cMainFrame,1)<=0
  || MathAbs(iClose(NULL, cMainFrame,1)-iOpen(NULL, cMainFrame,1))<=15*Point)
        { WaitCorre=NoSignal; sellADXDmax=0; sStartTakeYourTime =0;
        WaitDn=Go; sStartWaitingTime = TimeCurrent(); SetGlobVar("sWaitTime"+Symbol(), sStartWaitingTime);
        SetGlobVar("gWaitDn"+Symbol(),Go);
        SetGlobVar("gWaitCorre"+Symbol(),NoSignal);
    }
   }//TakeYourTime
break;
 }//sw
 
 
//==========================================================
maxAdx=iADX(NULL,cMainFrame,13,PRICE_HIGH,MODE_MAIN,0);
 if(((maxAdx>=58 && MainTrend==Up) //58
        ||
      (maxAdx>27  && MainTrend==Down)
        ||
       (maxAdx>25 && MainTrend==Flat)
      )  
    && CheckADX(1440,13,1,2)==Up 
    && WaitCorre!=Go) 
{
 sellADXDmax=maxAdx; sellADXWmax=iADX(NULL,dMainFrame,13,PRICE_HIGH,MODE_MAIN,0);
 WaitCorre=Ready;SetGlobVar("gWaitCorre"+Symbol(),Ready);
 } else
{ //SelectData();
if( iBearsPower( NULL, 1440, 13, PRICE_CLOSE,3)<0 )
     {WaitCorre=NoSignal;GlobalVariableSet("gWaitCorre"+Symbol(),NoSignal);}
}//else
if ( iMA(NULL,cMainFrame,100,0,MODE_SMA,PRICE_CLOSE,1)
    <iMA(NULL,cMainFrame,100,0,MODE_SMA,PRICE_CLOSE,10)
     && 
     MathAbs(iBands(NULL,1440,100,2,0,PRICE_CLOSE,MODE_UPPER,0)-iHigh(NULL,1440,0))
     <100*Point && WaitCorre==NoSignal
     )
{WaitCorre=Ready;SetGlobVar("gWaitCorre"+Symbol(),Ready);}
if( iBearsPower( NULL, 1440, 13, PRICE_CLOSE,3)<0  && WaitCorre<NoSignal)
     {WaitCorre=NoSignal;SetGlobVar("gWaitCorre"+Symbol(),NoSignal);}


if(WaitCorre<NoSignal )
{if(MainTrend==Up &&
iMA(NULL,cMainFrame,100,0,MODE_SMA,PRICE_CLOSE,1)
 >iMA(NULL,cMainFrame,100,0,MODE_SMA,PRICE_CLOSE,10))
WaitCorre=sellSw(WaitCorre);
else WaitCorre=sellSw(WaitCorre,0);
SetGlobVar("gWaitCorre"+Symbol(),WaitCorre);
}

//==============Long================================
 if(LocalTrend==Down)
 { double Bulls=BullDecline(1440, 32 );
   double Bears=BearForce(1440, 32 );
     if(MainTrend==Up  && LocalTrend==Down 
     && WaitUp==NoSignal
     && CheckADX(10080,13,1,5)==Up 
     && dStrongCond(dMainFrame,dADX0,0)>0
     )
     if(
       sellADXDmax>50   
        && MathAbs(iMA(NULL,cMainFrame,21,0,MODE_EMA,PRICE_CLOSE,0)-
           iClose(NULL,1440,0 ))<100*Point             
         )
     {WaitUp=Go; SetGlobVar("gWaitUp"+Symbol(),Go); LongCall=0;
      bStartWaitingTime =TimeCurrent(); SetGlobVar("bWaitTime"+Symbol(), bStartWaitingTime);}

   if(((MainTrend!=Up  && WaveNum==1) ||
        (MainTrend==Up  && (WaveNum==4 || WaveNum==6 || WaveNum==8)))
        && WaitUp>Ready && CheckiMa(1440, 100, MODE_SMA, 1, 40)== Up &&
     MathAbs(iClose(NULL,1440,1)-
     iIchimoku(NULL, dMainFrame, 9, 26, 52, MODE_KIJUNSEN, 1))<=50*Point)
      {   if(Bears+Bulls>-0.06) {WaitUp=Ready;SetGlobVar("gWaitUp"+Symbol(),WaitUp); 
                                 bStartWaitingTime=TimeCurrent();SetGlobVar("bWaitTime"+Symbol(), bStartWaitingTime);
                                }
         else {WaitSmallUp=Ready;SetGlobVar("gWaitSmallUp"+Symbol(),Ready);}
       }
   else
  { if((MainTrend==Up || (MainTrend==Flat && WaveNum==1)) && WaitUp==NoSignal 
     &&
     MathAbs(iLow(NULL,1440,0 )-
     iMA(NULL,cMainFrame,100,0,MODE_SMA,PRICE_CLOSE,1))<=50*Point)
        {if(MainTrend!=Flat)
        {WaitUp=Ready;GlobalVariableSet("gWaitUp"+Symbol(),Ready); }
     }
   }
 }

 WaitUp=LongSwich( WaitUp, cADX0);
 SetGlobVar("gWaitUp"+Symbol(),WaitUp); 

//=== Добавочные ордера Buy
//+++++++++++++++++++++++++++++++++++++++++++
//1
if(LocalTrend==Down && MainTrend==Up)
{
if (iTime(NULL,cMainFrame,0)-LastLocDnGoDay>86400*3
&& iMFI(NULL, cMainFrame,7,0)>15 )
  WaitSmallCont=buySw(WaitSmallCont,6,cMainFrame,cMainFrame);
}

//==========================================================
if(MainTrend!=Unknown && LocalTrend!=Unknown)
{
switch (WaitSmallUp)
{
case NoSignal :
 { if(LocalTrend==Up) 
 SmallBuyonUp();
   }
 break;
case Ready :
  {  AddpipsInit(0, 5);WaitSmallDn=NoSignal; SetGlobVar("gWaitSmallDn"+Symbol(),NoSignal);
    if ( SeachConv(240,cWaveTopNum,shift)
        && ConvKind(0, 240))
 {WaitSmallUp=Go; SetGlobVar("gWaitSmallUp"+Symbol(),WaitSmallUp);}
 else   StopSmallBuyonUp();
   AddpipsInit(Spips, Bpips);
   }
 break;
case Ready1 :
  {  AddpipsInit(0, 0);WaitSmallDn=NoSignal; SetGlobVar("gWaitSmallDn"+Symbol(),NoSignal);
    if ( SeachConv(60,cWaveTopNum,0)
        && ConvKind(0, 60))
 {WaitSmallUp=Go; SetGlobVar("gWaitSmallUp"+Symbol(),Go);}
 else   StopSmallBuyonUp();
   AddpipsInit(Spips, Bpips);
   }
 break; 

}//sw

if(WaitSmallUp==Go)
//if(MainTrend==Up )
{ SmallTrend=Up;SetGlobVar("gSmallTrend"+Symbol(),Up);
   StopSmallBuyonUp(); 
 if ( AccountFreeMargin()/AccountBalance()>0.90)
  {if(LocalTrend==Up) bTkP=Ask+250*Point;
  else bTkP=Ask+180*Point;
  if(WaitDn>Go && WaitCorre>Go)
  MainLongOrder(bTkP,LongMagic2);
   }
}
//++++++++++++++++++++++++++++++++++++++++++++
//++++++++++++++++++++++Small+++++++++++++++++++++
if(!(WaitDn==TakeYourTime || WaitDn==Ready))
 switch (WaitSmallDn)
{case NoSignal : 
{if(LocalTrend==Down)
SmallSellonDn();}
 break;
 case Ready :
  {  AddpipsInit(10, 0); WaitSmallUp=NoSignal;SetGlobVar("gWaitSmallUp"+Symbol(),NoSignal);
     SetGlobVar("gWaitSmallUp"+Symbol(),NoSignal);
     StopSmallSellonDn();
    if ( SeachDiv(240,cWaveTopNum,1) )
   {//if(LocalTrend==Up)
      //WaitSmallDn=Ready1;
   //else  
   WaitSmallDn=Go;
    SetGlobVar("gWaitSmallDn"+Symbol(),WaitSmallDn);
     AddpipsInit(Spips, Bpips);}
    else{AddpipsInit(Spips, Bpips);}
    break; 
   }
 case Ready1 :
  {  AddpipsInit(10, 0); WaitSmallUp=NoSignal;
     SetGlobVar("gWaitSmallUp"+Symbol(),NoSignal);
    if ( (SeachDiv(60,cWaveTopNum,shift) && LocalTrend==Down)
         ||
       (SeachDiv(60,cWaveTopNum,shift) && LocalTrend==Up &&  DiverKind(shift, 60))
       //SeachDiv(60,cWaveTopNum,shift)
         )    
   {WaitSmallDn=Go; SetGlobVar("gWaitSmallDn"+Symbol(),Go);
     AddpipsInit(Spips, Bpips);}
    else{AddpipsInit(Spips, Bpips); StopSmallSellonDn(); 
    break;} 
   }   
 case Ready2 :
  {  AddpipsInit(10, 0); WaitSmallUp=NoSignal;
     SetGlobVar("gWaitSmallUp"+Symbol(),NoSignal);
    if ( SeachDiv(1440,cWaveTopNum,shift)
        &&  DiverKind(0, 1440)
              )    
   {WaitSmallDn=Go; SetGlobVar("gWaitSmallDn"+Symbol(),Go);
     AddpipsInit(Spips, Bpips);}
    else{AddpipsInit(Spips, Bpips); StopSmallSellonDn(); 
    break;} 
   }      
case Go : 
{  if( (iStochastic(NULL,1440,8,3,3,MODE_SMA,0,MODE_MAIN,1)>
      iStochastic(NULL,1440,8,3,3,MODE_SMA,0,MODE_MAIN,2) 
      && iStochastic(NULL,1440,8,3,3,MODE_SMA,0,MODE_MAIN,1)<10)
      ||
      (LocalTrend==Up 
      && iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_MAIN,0)<50   )
       )
      {WaitSmallDn=NoSignal; SetGlobVar("gWaitSmallDn"+Symbol(),NoSignal);}
else      
if(LocalTrend==Down && iBearsPower(NULL, 240, 13,PRICE_CLOSE,1)>0
)
{SmallTrend=Down;SetGlobVar("gSmallTrend"+Symbol(),Down);}
else if(LocalTrend==Up)
{SmallTrend=Down;SetGlobVar("gSmallTrend"+Symbol(),Down);}
}
break;
}
if (WaitSmallDn==Go)
{SmallTrend=Down; SetGlobVar("gSmallTrend"+Symbol(),Down);
 if ( AccountFreeMargin()/AccountBalance()>0.90)
  { if (LocalTrend==Down)  sTkP=Bid-200*Point; else sTkP=Bid-150*Point;
    if(WaitUp>Go)
  MainShortOrder(OrderNum,ShortMagic2,sTkP);}
if(iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_MAIN,0)<35)
{WaitSmallDn=NoSignal;SetGlobVar("gWaitSmallDn"+Symbol(),NoSignal);}
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
}

if (WaitUp==NoSignal && WaitDn==NoSignal  && WaitCorre!=Go
    && iADX(NULL,dMainFrame,13,PRICE_HIGH,MODE_MAIN,0)<65 
   )
{
   if (    
   (  iMA(NULL,dMainFrame,100,0,MODE_SMA,PRICE_CLOSE,1)>
     iMA(NULL,dMainFrame,100,0,MODE_SMA,PRICE_CLOSE, 10 )
   &&
        iClose(NULL, 1440,1)>
        iBands(NULL,1440,100,2,0,PRICE_CLOSE,MODE_UPPER,1)
        &&
       iClose(NULL, 1440,2)>
       iBands(NULL,1440,100,2,0,PRICE_CLOSE,MODE_UPPER,2) 
    )
   ) 
    {if(CheckADX(1440,13,1,2)==Up && MainTrend!=Up)
          {MainTrend=Up;GlobalVariableSet("gMainTrend"+Symbol(),Up);  }
   } 
}

//---- Условия закрытия, модификации и удаления ордеров------------
  for(cnt=0;cnt<total;cnt++)
       {//for
        if( OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES)==true)
        {//Seltct
         if(OrderType()<=OP_SELL &&   // check for opened position 
            OrderSymbol()==Symbol())  // check for symbol
          {//1

 //--Обработка длинных позиций ----------------
            if(OrderType()==OP_BUY)   // long position is opened
              {//OP_BUY
             //-----------------
              if ( AccountFreeMargin()/AccountBalance()<Boundary)
              { res=OrderClose(OrderTicket(),OrderLots(),Bid,3,Gold); continue;}

              if (  WaitDn==Go  
                   ||
                   (MainTrend==Down && OrderMagicNumber()==MainLongMagic)
                  )
                    res=OrderClose(OrderTicket(),OrderLots(),Bid,3,Aqua);
                    
             if (  LocalTrend==Down
                   && (OrderMagicNumber()==LongMagic || OrderMagicNumber()==MainLongMagic)
                )
                 res=OrderClose(OrderTicket(),OrderLots(),Bid,3,Aqua);
              
              if ( (OrderMagicNumber()==LongMagic2 || OrderMagicNumber()==LongMagic1)
                   && (SmallTrend==Down || WaitSmallDn==Go)
                  )
                  res=OrderClose(OrderTicket(),OrderLots(),Bid,3,Red);
                      
                   
             //-----------------  
     
             }//OP_BUY
   //--Конец обработки длинных позиций -----------           

   //--Обработка коротких позиций ------------------
          if(OrderType()==OP_SELL)   // short position is opened
            {//OP_SELL
             //-----------------------------
              if ( AccountFreeMargin()/AccountBalance()<Boundary)
                  {if(OrderMagicNumber()!=MainShortMagic)
                   res=OrderClose(OrderTicket(),OrderLots(),Ask,3,Gold); continue;
                  }
                 
               if ( OrderMagicNumber()==MainShortMagic  && MainTrend==Up)
                    res=OrderClose(OrderTicket(),OrderLots(),Ask,3,Red);
              if ( OrderMagicNumber()==ShortMagic  && LocalTrend==Up)
                    res=OrderClose(OrderTicket(),OrderLots(),Ask,3,Red);                  
                  

              if (  //if
                    (//2
                     (TimeCurrent()-OrderOpenTime()>dMainFrame*Week*60)
                      &&
                     (TimeCurrent()-OrderOpenTime()<dMainFrame*(Week+2)*60) 
                      &&
                     (iHigh(NULL,dMainFrame,Highest(NULL,dMainFrame,MODE_HIGH,Week+5,0))-
                      iLow(NULL,dMainFrame,Lowest(NULL,dMainFrame,MODE_LOW,Week,0)) )
                      <dMinTp*Point
                      && OrderMagicNumber()==MainShortMagic
                     )//2
                   )//if
                       {res=OrderClose(OrderTicket(),OrderLots(),Ask,3,Aqua);
                        MainTrend=Flat; 
                        GlobalVariableSetOnCondition("gMainTrend"+Symbol(),Flat ,Down);
                        }
                    
 
                if ( OrderMagicNumber()==MainShortMagic
                     && MainTrend==Flat
                     && iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_MAIN,1)<20 
                     &&  SeachConv(240,dWaveTopNum,0) 
                     )
                   res=OrderClose(OrderTicket(),OrderLots(),Ask,3,Red);

              if ( OrderMagicNumber()==ShortMagic2 
                   && (SmallTrend==Up || WaitSmallUp==Go)
                 )
                  res=OrderClose(OrderTicket(),OrderLots(),Ask,3,Red);
         
           }//OP_SELL
          //--Конец обработки коротких позиций -----------           
         }
        //Конец условий для открытых ордеров
        }//Select
      }//for ;
 //---------------
  
//-------------------------------------------------------------------+
   return(0);
//+------------------------------------------------------------------+
}

//+------------------------------------------------------------------+
int buySw(int Wait, int MFIperiod, int  MFITimeFrame, int  ConvTimeFrame)
{ int shf;
  if( iMFI(NULL, MFITimeFrame,MFIperiod,0)>30 || WaitUp<NoSignal) 
  Wait=NoSignal;

switch (Wait)
{case NoSignal :
{ if(MFIperiod<7) shf=0; else shf=1;
if ( iMFI(NULL, MFITimeFrame,MFIperiod,shf)==0) Wait=Ready;
}
break;
case Ready :
{if( iMFI(NULL, MFITimeFrame,MFIperiod,0)>30 || WaitUp<NoSignal) Wait=NoSignal;
else
{if(MFIperiod<7) AddpipsInit(Spips, 5);
if (SeachConv(ConvTimeFrame,cWaveTopNum,shift)
    && ConvKind(shift, ConvTimeFrame)
         )Wait= Go;
AddpipsInit(Spips, Bpips);         
}
 } break;
case Go :  
{//SelectData();
 if(MFIperiod==7)
  {LocalTrend=Up;GlobalVariableSet("gLocalTrend"+Symbol(),Up);
    MainLongOrder(0,LongMagic);}

if(MFIperiod<7)
  {SmallTrend=Up;  GlobalVariableSet("gSmallTrend"+Symbol(),Up);
  double Tp=Ask+100*Point;
  if(lMagicNum1==1)
   Tp=0;
  MainLongOrder(Tp,LongMagic1); }
}
break;
}
return(Wait);
}

//+++++++++++++++++++++++++++++++++
 int sellSw(int WaitCorr, int StartBar=1)
{switch (WaitCorr)
{//sw
case NoSignal :
  ShortCall=0;
  break;
case Ready :
{ShortCall=0;
if (
   CheckADX(1440,13,StartBar,StartBar+1)==Down 
   ||
   (  CheckADX(240,55,1,14)==Down 
       &&
     !(MainTrend==Up && iBullsPower( NULL, 1440, 100, PRICE_CLOSE, 0)>Bulls100)
   //&& iADX(NULL,240,55,PRICE_HIGH,MODE_MAIN,1)>32
   )   
)
  WaitCorr=Go; 
}
 break;
case Go :
{  AddpipsInit(10, 0);
    if (SeachDiv(cMainFrame,dWaveTopNum,shift)
        &&   DiverKind(shift, cMainFrame)
      )
    DownCorrection();
     else
   if ((MainTrend==Down ||       
       iMA(NULL,cMainFrame,100,0,MODE_SMA,PRICE_CLOSE,1)
       <iMA(NULL,cMainFrame,100,0,MODE_SMA,PRICE_CLOSE,10))

    &&
        TimeCurrent()-sStartCorreTime>86400*5 &&
        SeachDiv(dSlaveFrame,dWaveTopNum,shift)
       &&   DiverKind(shift, dSlaveFrame) )
            DownCorrection();
  AddpipsInit(Spips, Bpips);

}
break;
}//sw WaitCorr
return(WaitCorr);
}

void DownCorrection(int Frame=1440)
{  double TP;
      if(iMA(NULL,Frame,100,0,MODE_SMA,PRICE_CLOSE,1)
         >iMA(NULL,cMainFrame,100,0,MODE_SMA,PRICE_CLOSE,10))
    { if( sellADXDmax>75 && MainTrend==Up) 
      TP=iMA(NULL,cMainFrame,21,0,MODE_EMA,PRICE_CLOSE,0)+20*Point;
       else
       TP=iIchimoku(NULL, dMainFrame, 9, 26, 52, MODE_KIJUNSEN, 0);
       }
       else
       TP=  0;      
       //TP= ( iHigh(NULL,cMainFrame,1) + 
        //     iLow(NULL,dMainFrame,iLowest(NULL,dMainFrame,MODE_LOW,12,1)))/2.2;
 
      ShortCall++;
     if(ShortCall==1)
   {
       if(MainTrend==Up 
       )
        WaveNum+=1; 
         else
          if(MainTrend==Down 
             && TimeCurrent()- LastLocDnGoDay>86400*30
             &&  TimeCurrent()- LastMainDnGoWeek>86400*30)
           WaveNum+=1;//Wave counter

       SetGlobVar("gWaveNum"+Symbol(),WaveNum);
       LocalTrend=Down;GlobalVariableSet("gLocalTrend"+Symbol(),Down);
         }
     if(AccountFreeMargin()/AccountBalance()>0.80)       
      MainShortOrder(OrderNum,ShortMagic, TP);
       
}
//-----------------------------------------------------------
int LongSwich(int Wait, double ADX, int magicnum=MainLongMagic,  int DayCnt=10 )
{int magic, ret, lastTrend;
 double bTkP;
 switch(Wait)
   {//sw
 case NoSignal : 
   {LongCall=0;
   buyADX= cMidlCond(cMainFrame,PRICE_HIGH, ADX, shift );
  if ( buyADX>0  )
    {     
     if ( SeachConv(cMainFrame,cWaveTopNum,shift)
         && ConvKind(shift, cMainFrame)
         )
    { if (CheckADX(240,55,0,adx55step/2)==Down
        && iBearsPower( NULL, cSlaveFrame, 13, PRICE_CLOSE,1)>W1MinBears)
       {Wait=Go; bStartWaitingTime =TimeCurrent();SetGlobVar("bWaitTime"+Symbol(), bStartWaitingTime);}
       else
	    Wait=Ready;
	  }
     }
   }//case 0
   break;
   case Ready :
   {//case Ready : 
   LongCall=0;
   if (CheckADX(240,55,0,adx55step/2)==Down
       && iBearsPower( NULL, cSlaveFrame, 13, PRICE_CLOSE,1)>W1MinBears)
        { Wait=Go; bStartWaitingTime = TimeCurrent();SetGlobVar("bWaitTime"+Symbol(), bStartWaitingTime);
}
   }//case Ready 
   break;
   case Go :
   {//case 2 :  
       AddpipsInit(Spips, 15 );
 if (   ( SeachConv(cMainFrame,cWaveTopNum,0)
         && ConvKind(0, cMainFrame))
         ||
          (SeachConv(dMainFrame,cWaveTopNum,0)
         && ConvKind(0, dMainFrame))
      )
    {lastTrend=MainTrend; LongCall++;
      LocalTrend=Up;GlobalVariableSet("gLocalTrend"+Symbol(),Up);

    AddpipsInit(Spips, Bpips);
     { bTkP=bProfit(buyADX);
       if (bTkP==0)  
       {magic=MainLongMagic;MainTrend=Up;GlobalVariableSet("gMainTrend"+Symbol(),Up);
       if(LongCall==1){
       if(lMainMagicNum==0 && lastTrend!=Up)WaveNum=1;
      else if(lWeekMnMagicCnt==0 && lastTrend==Up && TimeCurrent()- LastMainUpGoWeek>86400*30)
               WaveNum++;}
          }
        else
        { magic=LongMagic;
          if(LongCall==1 && (TimeCurrent()- LastLocUpGoDay>86400*30))WaveNum++;
        }
        GlobalVariableSet("gWaveNum"+Symbol(),WaveNum);

     if( AccountFreeMargin()/AccountBalance()>0.9)
        {ret=MainLongOrder(bTkP,magic);
        }
      }       
}
if((TimeCurrent()-bStartWaitingTime) > 86400*DayCnt )
{ 
Wait=NoSignal; bStartWaitingTime=NoSignal;SetGlobVar("bWaitTime"+Symbol(), bStartWaitingTime);
 }
}//case Go
break;
}//sw
return(Wait);
}

//==========================================================
void StopSmallBuyonUp()
 {   
  if((WaitCorre!=NoSignal && iBullsPower( NULL, 1440, 100, PRICE_CLOSE, 0)<Bulls100)
       ||WaitDn==Go)
   RotUpWaitSmall();
else
{  if (!(MainTrend==Up && iBullsPower( NULL, 1440, 100, PRICE_CLOSE, 0)>Bulls100))
{
 if(iMA(NULL,240,100,0,MODE_SMA,PRICE_CLOSE,1)-
     iMA(NULL,240,100,0,MODE_SMA,PRICE_CLOSE,5)
         <5*Point 
         &&
   iMA(NULL,240,5,0,MODE_SMA,PRICE_CLOSE,1)-
   iMA(NULL,240,5,0,MODE_SMA,PRICE_CLOSE,11)
        <80*Point                 
     )
  {  if(iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_MAIN,1)>80
                    &&
        iStochastic(NULL,1440,8,3,3,MODE_SMA,0,MODE_MAIN,0)>75
       )
      { WaitSmallDn=Ready2;
        SetGlobVar("gWaitSmallDn"+Symbol(),Ready2);
        WaitSmallUp=NoSignal;
        SetGlobVar("gWaitSmallUp"+Symbol(),NoSignal); }

}//iMa>
else
  if(iMA(NULL,240,21,0,MODE_SMA,PRICE_CLOSE,0)-
     iMA(NULL,240,21,0,MODE_SMA,PRICE_CLOSE,6)
         <45*Point 
         )
 {if(minStoch(240, 1, 4 )>87
       &&
   iStochastic(NULL,1440,8,3,3,MODE_SMA,0,MODE_MAIN,1)<=
   iStochastic(NULL,1440,8,3,3,MODE_SMA,0,MODE_SIGNAL,1) 
   )
   RotUpWaitSmall();
   }
   else
    Rot1WaitSmall();
  }
  else
    if ( MainTrend==Up && iBullsPower( NULL, 1440, 100, PRICE_CLOSE, 0)>Bulls100
    )
     if(CheckiMa(60, 21, MODE_SMA, 1, 10)== Up)
      {WaitSmallUp=NoSignal;
       SetGlobVar("gWaitSmallUp"+Symbol(),NoSignal);}

  }
}
//===========================================================

 void SmallBuyonUp()
 {
  if ( MainTrend==Up && iBullsPower( NULL, 1440, 100, PRICE_CLOSE, 0)>Bulls100)
  {if(CheckiMa(60, 21, MODE_SMA, 1, 10)== Down)
      Rot1UpWaitSmall();
    else       
      {WaitSmallUp=NoSignal;
       SetGlobVar("gWaitSmallUp"+Symbol(),NoSignal);}
  }
else
 {if(iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_MAIN,0)>=
   iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_SIGNAL,0)
   &&
   iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_MAIN,1)>
   iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_MAIN,2)
      &&
   iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_MAIN,1)<25
            &&
   iStochastic(NULL,1440,8,3,3,MODE_SMA,0,MODE_MAIN,0)<82
)
Rot1WaitSmall();
else
StopSmallBuyonUp();
  }
 }
//===========================================================

 void StopSmallSellonDn()
 { switch (MainTrend)
 {//sw
 case  Flat:
 { if(iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_MAIN,0)>=
   iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_SIGNAL,0)
   &&
   iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_MAIN,1)>
   iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_MAIN,2)
      &&
   iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_MAIN,1)<25
         &&
   iStochastic(NULL,1440,8,3,3,MODE_SMA,0,MODE_MAIN,2)<80
   )     
          Rot1WaitSmall();
 }
 break;
 default :
 {if((MainTrend==Down && LocalTrend==Down && 
       CheckiMa(1440, 100, MODE_SMA, 1, 10)== Down ))
{  if(CheckiMa(60, 21, MODE_SMA, 1, 10)== Up )  
       {WaitSmallDn=NoSignal;
       SetGlobVar("gWaitSmallDn"+Symbol(),NoSignal);
       }    else RotDnWaitSmall();
 }
 else
   if(MainTrend==Down && LocalTrend==Down && 
       CheckiMa(1440, 100, MODE_SMA, 1, 10)== Up  
      &&  iStochastic(NULL,1440,8,3,3,MODE_SMA,0,MODE_MAIN,0)<25)
        {WaitSmallDn=NoSignal;
       SetGlobVar("gWaitSmallDn"+Symbol(),NoSignal);
       }
else   
 if(!( iMA(NULL,240,21,0,MODE_EMA,PRICE_CLOSE,21)-
         iMA(NULL,240,21,0,MODE_EMA,PRICE_CLOSE,1)>=90*Point)
         )
{
  if( iStochastic(NULL,1440,8,3,3,MODE_SMA,0,MODE_MAIN,1)<=MaxStStopSellonDn//25!
        &&
    iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_MAIN,1)<25
       &&              
    iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_MAIN,1)>=
    iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_MAIN,2)
    )
   Rot1WaitSmall();
    }
     else
     {if( iRSI(NULL,1440,14,PRICE_CLOSE,1)<=33
         &&
       iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_MAIN,1)<20
        &&              
      iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_MAIN,1)>
      iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_MAIN,2) )
   Rot1WaitSmall();
    }
   }
    break;
    }//sw
 }
//==============================================================  
  void SmallSellonDn()
 {
  if(LocalTrend==Down)
  {//1
 if(CheckiMa(240, 100, MODE_SMA, 1, 24)== Down 
    && SmallTrend==Down
    && WaitUp>Ready  )
  {//2
    if(iStochastic(NULL,1440,8,3,3,MODE_SMA,0,MODE_MAIN,0)<
    iStochastic(NULL,1440,8,3,3,MODE_SMA,0,MODE_MAIN,1)
    &&
    iStochastic(NULL,60,8,3,3,MODE_SMA,0,MODE_MAIN,0)<
    iStochastic(NULL,60,8,3,3,MODE_SMA,0,MODE_MAIN,1)
    &&
    iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_MAIN,0)>22
     && 
    iStochastic(NULL,60,8,3,3,MODE_SMA,0,MODE_MAIN,1)>60
     &&
   iStochastic(NULL,60,8,3,3,MODE_SMA,0,MODE_MAIN,0)<=
   iStochastic(NULL,60,8,3,3,MODE_SMA,0,MODE_SIGNAL,0)
   )
RotDnWaitSmall();
  }//2
else
 if(iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_MAIN,0)<=
   iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_SIGNAL,0)
      &&
   iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_MAIN,1)>60
            &&
    iStochastic(NULL,1440,8,3,3,MODE_SMA,0,MODE_MAIN,1)>MinStSellonDn
   )
    RotWaitSmall();
   else
    StopSmallSellonDn(); 
  }//1
   }
   //----------------------------------------------
  void RotWaitSmall()
   {WaitSmallDn=Ready;
    SetGlobVar("gWaitSmallDn"+Symbol(),Ready);
    WaitSmallUp=NoSignal;
    SetGlobVar("gWaitSmallUp"+Symbol(),NoSignal);
    }
   //----------------------------------------------
  void Rot1WaitSmall()
      {WaitSmallUp=Ready;
       SetGlobVar("gWaitSmallUp"+Symbol(),Ready);
       WaitSmallDn=NoSignal;
       SetGlobVar("gWaitSmallDn"+Symbol(),NoSignal);
       }

  void RotDnWaitSmall()
   {WaitSmallDn=Ready1;
    SetGlobVar("gWaitSmallDn"+Symbol(),Ready1);
    WaitSmallUp=NoSignal;
    SetGlobVar("gWaitSmallUp"+Symbol(),NoSignal);
    }
  
    void RotUpWaitSmall()  
    {WaitSmallDn=Ready2;
     SetGlobVar("gWaitSmallDn"+Symbol(),Ready2);
     WaitSmallUp=NoSignal;
     SetGlobVar("gWaitSmallUp"+Symbol(),NoSignal); }

      void Rot1UpWaitSmall()
      {WaitSmallUp=Ready1;
       SetGlobVar("gWaitSmallUp"+Symbol(),Ready1);
       WaitSmallDn=NoSignal;
       SetGlobVar("gWaitSmallDn"+Symbol(),NoSignal);
       }