//+------------------------------------------------------------------+
//|                                              gpfTCPivotLimit.mq4 |
//|                                  Copyright © 2006, George-on-Don |
//|                                       http://www.forex.aaanet.ru |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2006, George-on-Don"
#property link      "http://www.forex.aaanet.ru"

#include <stdlib.mqh>
#include <stderror.mqh>

#define MAGICMA  20050610

extern double               Lots=0.1;   // lot size
extern bool               SndMl=true;   // is send e-mail message?
extern bool      isFloatLots = false;   // is cals lot size 
extern double                DcF = 3;   // optimization factor 
extern double            MaxR = 0.02;   // max risk
extern int             TgtProfit = 1;   // 
extern int             Trailing = 30;   //
extern bool       isTradeDay = False;   // is trade intraday or extraday?
extern bool          isTrace = False;   // is tracer on?


double    Pivot;
double  Resist1;
double  Resist2;
double Support1;
double Support2;
double Support3;
double  Resist3;

double   StpBuy;
double  StpSell;
double  PrftBuy;
double PrftSell;


double                  pPoint;
double r1 , s1 ,s2, r2, r3, s3;
int                        err;
bool              isCals=false;
//+------------------------------------------------------------------+
//| CalculateCurrentOrders function                                  |
//+------------------------------------------------------------------+
int CalculateCurrentOrders(string symbol)
  {
   int buys=0;
   int sells=0;
//----
   for(int i=0;i<OrdersTotal();i++)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false) 
         break;
      if(OrderSymbol()==Symbol() && OrderMagicNumber()==MAGICMA)
        {
         if(OrderType()==OP_BUY)  
            buys++;
         if(OrderType()==OP_SELL) 
           sells++;
        }
     }
//---- return orders volume
      if(buys>0) 
         return(buys);
      else
        return(-sells);
  }

//+------------------------------------------------------------------+
//| LotsOptimized function                                           |
//+------------------------------------------------------------------+
double LotsOptimized()
  {
   double lot=Lots;
   if (isFloatLots == true) 
    {  
 	   int    orders=HistoryTotal();     // history orders total
	    int    losses=0;                  // number of losses orders without a break
	//---- select lot size
	    lot=NormalizeDouble(AccountFreeMargin()*MaxR/1000.0,1);
	//---- calcuulate number of losses orders without a break
	    if(DcF>0)
     	 {
      	 for(int i=orders-1;i>=0;i--)
        		 {
	         	 if(OrderSelect(i,SELECT_BY_POS,MODE_HISTORY)==false) 
	         	   { 
	         	    Print("Îøèáêà â èñòîðèè!"); break; 
	         	   }
         		 if(OrderSymbol()!=Symbol() || OrderType()>OP_SELL) continue;
         	 //----
	         	 if(OrderProfit()>0) break;
         		 if(OrderProfit()<0) losses++;
        		 }
      	 if(losses>1) 
      	    lot=NormalizeDouble(lot-lot*losses/DcF,1);
     	 }
    }
//---- return lot size
   if(lot<0.1) lot=0.1;
   return(lot);
  }
//+------------------------------------------------------------------+
//| initialization of Calspivot function                             |
//+------------------------------------------------------------------+
bool isCalsPivot()
  {
   int    tHour;
   double hLine;
   double lLine;
   int i,k;
   if(Volume[0]>1) 
      return(false);
   if (TimeHour(Time[1])== 0 )
     {
      tHour = TimeHour(Time[2]);
 	    k= tHour+1;
 	    if (isTrace == true)
        {
         Print("tHour",tHour);
         Print("K",k);
        }
      hLine = High[tHour];
	     lLine = Low[tHour];
	     for (i = tHour+1; i > 0; i--)
	       {
         if (Low[i+1] < lLine) 
            lLine = Low[i+1];
         if (High[i+1] > hLine) 
            hLine = High[i+1];
         if (isTrace == true)
           {
            Print("i# ",i," lLine# ", lLine, " Low# ", Low[i+1], " hLine #", hLine, " High #", 
                  High[i+1], " time #" , TimeHour(Time[i+1]), " day #", TimeDay(Time[i+1]));
           }
        }
      pPoint = (lLine + hLine + Close[2]) / 3;
      r1 = 2 * pPoint - lLine;
      s1 = 2 * pPoint - hLine;
      r2 = pPoint + (r1 - s1);
      s2 = pPoint - (r1 - s1);
      r3 = hLine + 2 * (pPoint - lLine);
      s3 = lLine - 2 * (hLine - pPoint);
      CalsPivot();
      isCals = true;
      return (true);
     }
   return (false);
  }
//+------------------------------------------------------------------+
//| Cals Pivot    function                                           |
//+------------------------------------------------------------------+
void CalsPivot()
  {
   Pivot    =NormalizeDouble(pPoint,Digits);
   Resist1  =NormalizeDouble(r1,Digits);
   Resist2  =NormalizeDouble(r2,Digits);
   Resist3  =NormalizeDouble(r3,Digits);
   Support1 =NormalizeDouble(s1,Digits);
   Support2 =NormalizeDouble(s2,Digits);
   Support3 =NormalizeDouble(s3,Digits);
   if (isTrace == true)
     {
      Print("Pivot# ",Pivot," Resist1# ",Resist1," Support1# ",Support1);
      Print("Pivot# ",Pivot," Resist2# ",Resist2," Support2# ",Support2);
      Print("Pivot# ",Pivot," Resist3# ",Resist3," Support3# ",Support3);
     }
  }
//+------------------------------------------------------------------+
//| CheckForOpen trade function                                      |
//+------------------------------------------------------------------+
void CheckForOpen()
  {
   string sHeaderLetter;
   string   sBodyLetter;
   int             err2;
   double       StopBuy;
   double     ProfitBuy;
   double        bLevel;
   double      StopSell;
   double    ProfitSell;
   double        sLevel;   
   // is first tick?
   if(Volume[0]>1) return;
   switch (TgtProfit)
     {
      case 1 : sLevel = Resist1;
               StopSell =    Resist2;
               ProfitSell = Support1;
               bLevel =     Support1;
               StopBuy =    Support2;
               ProfitBuy =   Resist1;
               break;
      case 2 : sLevel =      Resist1;
               StopSell =    Resist2;
               ProfitSell = Support2;
               bLevel =     Support1;
               StopBuy =    Support2;
               ProfitBuy =   Resist2;
               break;
      case 3 : sLevel =      Resist2;
               StopSell =    Resist3;
               ProfitSell = Support1;
               bLevel =     Support2;
               StopBuy =    Support3;
               ProfitBuy =   Resist1;
               break;
      case 4 : sLevel =      Resist2;
               StopSell =    Resist3;
               ProfitSell = Support2;
               bLevel =     Support2;
               StopBuy =    Support3;
               ProfitBuy =   Resist2;
               break;
      case 5 :  sLevel =      Resist2;
               StopSell =    Resist3;
               ProfitSell = Support3;
               bLevel =     Support2;
               StopBuy =    Support3;
               ProfitBuy =   Resist3;
               break;
      //default : 
     } 
   //---- Sell trade
   if ( ((High[2]>sLevel || Close[2]>=sLevel) && Open[2]< sLevel) && Close[1]<=sLevel)
     {
      if (isTrace == true)
        {
         Print("Close1#", Close[1]);
         Print("Pivot#",Pivot);
         Print("Close2#",Close[2]);
        }
      err = OrderSend(Symbol(),OP_SELL,LotsOptimized(),Bid,3,StopSell,ProfitSell,"",MAGICMA,0,Red);
      if (err < 0)
        {
         Print("OrderSend Sell failed err#", GetLastError());
         if (isTrace == true)
           {
            Print("Bid#",Bid);
            Print("Pivot #",Pivot);
            Print("Stop loss#",Resist1);
            Print("Take prof#",Support2);
           }
         if (GetLastError()== 130) 
            err2 =OrderSend(Symbol(),OP_SELL,LotsOptimized(),Bid,3,Resist2,Support3,"",MAGICMA,0,Red);
         if ( err2 <0)
           {
            Print("OrderSend Sell failed err2#", GetLastError());
            if (isTrace == True)
              {
               Print("Bid#",Bid);
               Print("Pivot #",Pivot);
               Print("Stop loss#",Resist2);
               Print("Take prof#",Support3);
              }  
           }
         return(0);   
        }
      else
        {
         if (SndMl == True ) 
           {
            sHeaderLetter = "Operation SELL by " + Symbol()+"";
            sBodyLetter = "Order Sell by "+ Symbol() + " at " + DoubleToStr(Bid,4)+ ", and set stop/loss at " + DoubleToStr(StpSell,4)+"";
            sndMessage(sHeaderLetter, sBodyLetter);
          }
        }
    //return;
     }
   //---- Buy trade
   if ((( Low[2]<bLevel || Close[2]<=bLevel) && Open[2]> bLevel) && Close[1]>=bLevel)
     {
      if (isTrace == true)
        {
         Print("Close1#", Close[1]);
         Print("Pivot#",Pivot);
         Print("Close2#",Close[2]);
        }
      err=OrderSend(Symbol(),OP_BUY,LotsOptimized(),Ask,3,StopBuy,ProfitBuy,"",MAGICMA,0,Blue); 
      if (err < 0)
        {
         Print("OrderSend Buy failed err#", GetLastError());
         if (isTrace== true)
           {
            Print("Bid#",Bid);
            Print("Pivot #",Pivot);
            Print("Stop loss#",Support2);
            Print("Take prof#",Resist3);
           }
         if (GetLastError() == 130) 
            err2=OrderSend(Symbol(),OP_BUY,LotsOptimized(),Ask,3,Support2,Resist3,"",MAGICMA,0,Blue);
         StpBuy  = Support2;
         PrftBuy = Resist2;
         if (err2 < 0)
           {
            Print("OrderSend Buy failed err2#", GetLastError());
            if (isTrace== true)
              {
               Print("Bid#",Bid);
               Print("Pivot #",Pivot);
               Print("Stop loss#",Support2);
               Print("Take prof#",Resist3);
              }
           }
         return(0);   
        }
      else
        {
         if ( SndMl == True )
           { 
            sHeaderLetter = "Operation BUY at " + Symbol()+"";
            sBodyLetter = "Order Buy at "+ Symbol() + " for " + DoubleToStr(Ask,4)+ ", and set stop/loss at " + DoubleToStr(StpBuy,4)+"";
            sndMessage(sHeaderLetter, sBodyLetter);
           }
        }      
      return;
     }    
  }  
//+------------------------------------------------------------------+
//| CheckForClose open trade function                                |
//+------------------------------------------------------------------+
void CheckForClose()
  {
   string sHeaderLetter;
   string   sBodyLetter;
   bool        CloseOrd;
//---- 
   if(Volume[0]>1) 
      return;
   for(int i=0;i<OrdersTotal();i++)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false)
         break;
      if(OrderMagicNumber()!=MAGICMA || OrderSymbol()!=Symbol())
         continue;
      //----  
      if(OrderType()==OP_BUY)
        {
         if (isTrace== true)
           {
            Print("in OP_BUY");
           }
         if (isTradeDay == True && TimeHour(Time[1])== 23) 
           {
            CloseOrd=OrderClose(OrderTicket(),OrderLots(),Bid,3,Lime);
           }
         // trailing stop
         if(Trailing>0)  
           {                 
            if (isTrace == true)
              {
               Print("in BUY modify");
              }
            if(Bid-OrderOpenPrice()>Point*Trailing)
              {
               if(OrderStopLoss()<Bid-Point*Trailing)
                 {
                  err = OrderModify(OrderTicket(),OrderOpenPrice(),Bid-Point*Trailing,OrderTakeProfit(),0,Green);
                   if (err < 0)
                     {
                      Print("OrderModify Buy failed err#", GetLastError());
                      if (isTrace== true)
                        {
                         Print("Bid#",Bid);
                         Print("Pivot #",OrderOpenPrice());
                        }
                      return(0);
                     }
                   return ;
                 }
              }
           }
         if ( SndMl == True && CloseOrd == True)
            {
              sHeaderLetter = "Operation CLOSE BUY at" + Symbol()+"";
              sBodyLetter = "Close order Buy at "+ Symbol() + " for " + DoubleToStr(Bid,4)+ ", and finish this Trade";
              sndMessage(sHeaderLetter, sBodyLetter);
            }
         break;
        }
      if(OrderType()==OP_SELL)
        {
         if (isTrace== true)
           {
            Print("in OP_SELL");
           }
         if (isTradeDay == True && TimeHour(Time[1])== 23 ) 
           {
            CloseOrd=OrderClose(OrderTicket(),OrderLots(),Ask,3,Lime);
           }
         // trailing stop
         if(Trailing>0)  
           {                 
            if (isTrace== true)
              {
               Print("in Sell modify");
              }    
            if((OrderOpenPrice()-Ask)>(Point*Trailing))
              {
               if((OrderStopLoss()>(Ask+Point*Trailing)) || (OrderStopLoss()==0))
                 {
                  err = OrderModify(OrderTicket(),OrderOpenPrice(),Ask+Point*Trailing,OrderTakeProfit(),0,Red);
                  if (err < 0)
                    {
                     Print("OrderModify Sell failed err#", GetLastError());
                     if (isTrace== true)
                       {
                        Print("Bid#",Bid);
                        Print("Pivot #",OrderOpenPrice());
                       }
                     return(0);
                    }
                  return;
                 }
              }
           }
         if ( SndMl == True && CloseOrd == True) 
           {
            sHeaderLetter = "Operation CLOSE SELL at" + Symbol()+"";
            sBodyLetter = "Close order Sell at "+ Symbol() + " for " + DoubleToStr(Ask,4)+ ", and finish this Trade";
            sndMessage(sHeaderLetter, sBodyLetter);
           }
         break;
        }
     }
//----
  }  
//--------------------------------------------------------------------
// message sending function                                          |
//--------------------------------------------------------------------
void sndMessage(string HeaderLetter, string BodyLetter)
  {
   int RetVal;
   SendMail( HeaderLetter, BodyLetter );
   RetVal = GetLastError();
   if (isTrace== true)
     {
      if (RetVal!= ERR_NO_MQLERROR) 
         Print ("Error, message not sending: ", ErrorDescription(RetVal));
     }
  }
//+------------------------------------------------------------------+
//| expert start function                                            |
//+------------------------------------------------------------------+
int start()
  {
   if (Period() != PERIOD_H1) 
     {
      Print("Error, Time Frame is not 1 hour!");
      return ; 
     }
   if(Bars<25 || IsTradeAllowed()==false) 
      return;
   isCalsPivot();
   if(CalculateCurrentOrders(Symbol())==0) 
      CheckForOpen();
   else
     CheckForClose();
   return(0);
  }
//+------------------------------------------------------------------+---------------------------------------------------------------+