//+------------------------------------------------------------------+
//|                                                   FileExecV1.mq5 |
//|                        Copyright 2017, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2017, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"

#include <Trade\AccountInfo.mqh>
#include<Trade\SymbolInfo.mqh>
#include<Trade\Trade.mqh>
#include <Files\File.mqh>
//#include <Math\Stat\Math.mqh>
CAccountInfo account;
CSymbolInfo symbol_info;
CTrade  trade;
CFile file;

input string symb="GAZP.MM";
input double VM=100;
input datetime DayExp=0;
input double MaxProfit=20;
input double MinProfit=-20;
input bool OpenPositionsBuy=false,OpenPositionsSell=false;
input int lot1=1,lot=10,lotK=10;
//input bool ClosePositions=false;
input int Round=1;

string symb1;
ENUM_TIMEFRAMES per;
double ticksize0,ticksize1,tickvalue0,tickvalue1,di,DeltaSpread=0.03;
int digit0,digit1;
bool spos,spos1;
double maxProfit,minProfit,Profit;
double ask,bid,last,ask1,bid1,last1,high,low,open,SLask,SLbid,high01,low01,open01,close01,open11,close11;
double ds,maxspread0=0.016,prCalc0,prCalc1,sprd,sprdI,sprdO;
int spread0,spread1;
string commentB,commentS;
int day,hour,min,BARS,BARS1,minH,minL;
bool trueTime=false,trueTrade=false;
int tempmin=0,timePos=0,rd=0;
bool keyclose=false;
double High[],Low[],Close[],Open[],Spread[],reg[];
int Spr[];
datetime Time[];
bool buypos=false,sellpos=false,buypos1=false,sellpos1=false,buypos2=false,sellpos2=false;
string posS="NONE",posS1="NONE",posS2="NONE";
int posC=0,posC1=0,posC2=0;
double sd,sdu1,sdu2,sdu3,sdu4,sdu5,sdd1,sdd2,sdd3,sdd4,sdd5,sr,srb,srs;
double Dreg=0;
double DIV=0,maxDIV,minDIV;
double pDIV=0,pDIVmax=0,pDIVmin=0, pDIVi=0,pDIVimax=0,pDIVimin=0, pDIVo=0,pDIVomax=0,pDIVomin=0;
double pDIVisr=0;
datetime dayC;
int daym,mon;
int sf,sord=0;
int lotA;


MqlDateTime dt;

//MqlBookInfo bArr1[];
//MqlBookInfo bArr2[];
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+

int OnInit()
  {
//---

//--- получим номер счета, на котором запущен советник
   long login=account.Login();
   Print("Login=",login);
//--- выясним тип счета
   ENUM_ACCOUNT_TRADE_MODE account_type=account.TradeMode();
//--- если счет оказался реальным, прекращаем работу эксперта немедленно!
/* if(account_type==ACCOUNT_TRADE_MODE_REAL)
     {
   //   MessageBox("Работа на реальном счете запрещена, выходим","Эксперт запущен на реальном счете!");
      MessageBox("РЕАЛЬНЫЙ СЧКЕТ !!!");
   //   return(-1);
     }*/
//--- выведем тип счета    
   Print("Тип счета: ",EnumToString(account_type));
//--- выясним, можно ли вообще торговать на данном счете
   if(account.TradeAllowed())
      Print("Торговля на данном счете разрешена");
   else
      Print("Торговля на счете запрещена: возможно, вход был совершен по инвест-паролю");
//--- выясним, разрешено ли торговать на счете с помощью эксперта
   if(account.TradeExpert())
      Print("Автоматическая торговля на счете разрешена");
   else
      Print("Запрещена автоматическая торговля с помощью экспертов и скриптов");
//--- допустимое количество ордеров задано или нет
   int orders_limit=account.LimitOrders();
   if(orders_limit!=0)Print("Максимально допустимое количество действующих отложенных ордеров: ",orders_limit);
//--- выведем имя компании и сервера
   Print(account.Company(),": server ",account.Server());
//--- напоследок выведем баланс и текущую прибыль на счете
   Print("Balance=",account.Balance(),"  Profit=",account.Profit(),"   Equity=",account.Equity());
//----------------------------------------------------------------------------------------
//--- объект для получения свойств символа

//--- зададим имя символа, для которого будем получать информацию

   symb1=_Symbol;
   per=_Period;

   Symbol_Info(symb);
   Symbol_Info(symb1);

   ticksize0=SymbolInfoDouble(symb,SYMBOL_TRADE_TICK_SIZE);
   ticksize1=SymbolInfoDouble(symb1,SYMBOL_TRADE_TICK_SIZE);
   tickvalue0=SymbolInfoDouble(symb,SYMBOL_TRADE_TICK_VALUE);
   tickvalue1=SymbolInfoDouble(symb1,SYMBOL_TRADE_TICK_VALUE);
   digit0=(int)SymbolInfoInteger(symb,SYMBOL_DIGITS);
   digit1=(int)SymbolInfoInteger(symb1,SYMBOL_DIGITS);
//------------------------------------------------------------------------------------
//--- зададим MagicNumber для идентификации своих ордеров
   int MagicNumber=123456;
   trade.SetExpertMagicNumber(MagicNumber);
//--- установим допустимое проскальзывание в пунктах при совершении покупки/продажи
   int deviation=1;
   trade.SetDeviationInPoints(deviation);
//--- режим заполнения ордера, нужно использовать тот режим, который разрешается сервером
   trade.SetTypeFilling(ORDER_FILLING_RETURN);
//--- режим логирования: лучше не вызывать этот метод вообще, класс сам выставит оптимальный режим
   trade.LogLevel(1);
//--- какую функцию использовать для торговли: true - OrderSendAsync(), false - OrderSend()
   trade.SetAsyncMode(false);
//---
   file.SetCommon(FILE_COMMON); //\Terminal\Common\Files
                                // string text="maxProfit";

   CheckPos();

  // day=dt;
  
 
  dayC=TimeCurrent();
  day=dd(dayC,DayExp);
  lotA=lot*lotK;
  pDIV=0;pDIVmax=0;pDIVmin=0; pDIVi=0;pDIVisr=0;
  pDIVimax=0;pDIVimin=0; pDIVo=0;pDIVomax=0;
  pDIVomin=0;



   EventSetTimer(1);
//ExecClose();
   Print(__FUNCTION__,"  completed");

//---
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---

  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTimer()
  {
   
   symbol_info.Name(symb);
   if (!symbol_info.IsSynchronized() || !symbol_info.RefreshRates()) return;
   symbol_info.Name(symb1);
   if (!symbol_info.IsSynchronized() || !symbol_info.RefreshRates()) return;
 //------------------------------------------  
   TiksInfo();
 //  OpenPos();
//   ClosePos();
//show();
  }
//-----------------------------------------------------------

//------------------------------------------------------------
void OnTick()
  {
//---
 //  symbol_info.Name(symb);
//   if (!symbol_info.IsSynchronized() || !symbol_info.RefreshRates()) return;
 //  symbol_info.Name(symb1);
 //  if (!symbol_info.IsSynchronized() || !symbol_info.RefreshRates()) return;
   
   
 //TiksInfo();
//if (!IsTradeSessionOpen(symb) || !IsTradeSessionOpen(symb1)) return;
 OpenPos();
 // ClosePos();
   show();

  }
//==================================================================
void OpenPos1(int v,int l)
  {

if (posC1!=0) return;

   if(v==2)
     {
      if(!trade.Buy(l,symb,0,0,0,"2")) //if(!trade.Buy(1,symb,0,SLask, 0,commentB))
        {
         //--- сообщим о неудаче
         Print("Метод Buy() SYM потерпел неудачу. Код возврата=",trade.ResultRetcode(),
               ". Описание кода: ",trade.ResultRetcodeDescription());
        }
      else
        {
         Print("Метод Buy() SYM выполнен успешно. Код возврата=",trade.ResultRetcode(),
               " (",trade.ResultRetcodeDescription(),")");
               spos=PositionSelect(symb);
         spos1=PositionSelect(symb1);
         sord=OrdersTotal();
         // minProfit=0;
         //  maxProfit=0;
         Profit=0;
         timePos=0;
         
Print ("sprd=  ",sprdI," bid1=  ",bid1,"  ask= ",ask," bid=  ",bid," pDIVisr=  ",pDIVi); 
pDIVisr=0;
               
        }
     }
   if(v==1)
     {
      if(!trade.Sell(l,symb,0,0,0,"1")) //SLbid
        {
         //--- сообщим о неудаче
         Print("Метод Sell()SYM потерпел неудачу. Код возврата=",trade.ResultRetcode(),
               ". Описание кода: ",trade.ResultRetcodeDescription());
        }
      else
        {
         Print("Метод Sell()SYM  выполнен успешно. Код возврата=",trade.ResultRetcode(),
               " (",trade.ResultRetcodeDescription(),")");
        }
     }

  }
//=================================================================
void OpenPos2(int v)
  {

//if (posC2!=0) return;

   if(v==2)
     {
      if(!trade.Buy(1,symb1,0,0,0,"2")) //if(!trade.Buy(1,symb,0,SLask, 0,commentB))
        {
         //--- сообщим о неудаче
         Print("Метод Buy() SYM1 потерпел неудачу. Код возврата=",trade.ResultRetcode(),
               ". Описание кода: ",trade.ResultRetcodeDescription());
        }
      else
        {
         Print("Метод Buy() SYM1 выполнен успешно. Код возврата=",trade.ResultRetcode(),
               " (",trade.ResultRetcodeDescription(),")");
        }
     }
   if(v==1) 
     {
      if(!trade.Sell(1,symb1,0,0,0,"1")) //SLbid
        {
         //--- сообщим о неудаче
         Print("Метод Sell() SYM1 потерпел неудачу. Код возврата=",trade.ResultRetcode(),
               ". Описание кода: ",trade.ResultRetcodeDescription());
        }
      else
        {
         Print("Метод Sell() SYM1  выполнен успешно. Код возврата=",trade.ResultRetcode(),
               " (",trade.ResultRetcodeDescription(),")");
        }
     }

  }
//---------------------------------------------------------------
void OpenBuySell(int v)
  {
   for(int i=0; i<100; i++)
     {

      if(v==2 && posC1!=0 && posC2!=0)
        {
         buypos=true;
         Print("BUY"); break;
        }
      if(v==1 && posC1!=0 && posC2!=0)
        {
         sellpos=true;
         Print("SELL"); break;
        }
    //  if(v==2 && posC1==0) OpenPos1(1);
      if(v==2 && posC2==0) OpenPos2(2);
   //   if(v==1 && posC1==0) OpenPos1(2);
      if(v==1 && posC2==0) OpenPos2(1);

      CheckPos();
     }

  }
//================================================================
void OpenPos()
  {

 
      //------sell ----------------------------
      if(OpenPositionsSell 
         && pDIVi>=12
         )
        {
      //   Print ("sprd=  ",sprdI," bid1=  ",bid1,"  ask= ",ask);
     //    OpenBuySell(1);
         spos=PositionSelect(symb);
         spos1=PositionSelect(symb1);
         sord=OrdersTotal();
         
         OpenLimitOrd(1,symb1,bid1,0,0,"2",lot1);
       //  OpenLimitOrd(2,symb,ask+2,0,0,"1",10);
         
        }
if (PositionSelect(symb1))  OpenPos1(2,lot); //OpenLimitOrd(2,symb,ask+1,0,0,"1",lot);
     }
  }
 //====================================================================
 bool OpenLimitOrd(int v,string s,double pr,int sl,int tp,string poc,int l)
  {

   double st=0,tr=0;

 //  if(sord>0 || (spos && spos1)) return(true);
   
   if ( CheckOrd(s) || PositionSelect(s)) return(true);
   
   // if((spos && spos1)) return(true);


   if(v==1)
     {

      if(sl>0) st=NormalizeDouble(pr+sl*ticksize0,digit0);
      if(tr>0) tr=NormalizeDouble(pr-tp*ticksize0,digit0);

      if(!trade.SellLimit(l,pr,s,st,tr,0,0,poc)) //SLbid
        {
         //--- сообщим о неудаче
         Print("Метод Sell() потерпел неудачу. Код возврата=",trade.ResultRetcode(),
               ". Описание кода: ",trade.ResultRetcodeDescription());
        }
      else
        {
         Print("Метод Sell() выполнен успешно. Код возврата=",trade.ResultRetcode(),
               " (",trade.ResultRetcodeDescription(),")");

         // spos=PositionsTotal();
        spos=PositionSelect(symb);
         spos1=PositionSelect(symb1);
         sord=OrdersTotal();
         // minProfit=0;
         //  maxProfit=0;
         Profit=0;
         timePos=0;
         
Print ("sprd=  ",sprdI," bid1=  ",bid1,"  ask= ",ask," bid=  ",bid," pDIVisr=  ",pDIVi); 
pDIVisr=0;
        }
     }

   if(v==2)
     {

      if(sl>0) st=NormalizeDouble(pr-sl*ticksize0,digit0);
      if(tr>0) tr=NormalizeDouble(pr+tp*ticksize0,digit0);

      if(!trade.BuyLimit(l,pr,s,st,tr,0,0,poc)) //s SLoss Tprofit
        {
         //--- сообщим о неудаче
         Print("Метод Buy() потерпел неудачу. Код возврата=",trade.ResultRetcode(),
               ". Описание кода: ",trade.ResultRetcodeDescription());
        }
      else
        {
         Print("Метод Buy () выполнен успешно. Код возврата=",trade.ResultRetcode(),
               " (",trade.ResultRetcodeDescription(),")");

         // spos=PositionsTotal();
         spos=PositionSelect(symb);
         spos1=PositionSelect(symb1);
         sord=OrdersTotal();

         //  minProfit=0;
         //  maxProfit=0;
         Profit=0;
         timePos=0;

        }
     }

   if(sord>0 || spos) return(true);

   return (false);
  }
//=================================================================
bool CheckOrd(string s)
  {

   bool oc=false;

   for(int i=0;i<OrdersTotal();i++)
     {
      //if (OrderSelect(i)==false) break;
      if(OrderGetTicket(i))
        {
         if(OrderGetString(ORDER_SYMBOL)==s) oc=true;
        // Print("1= ",OrderGetString(ORDER_SYMBOL),"  2= ",s);
        }
      // Print ("33=  ",GetLastError(),"  44=  ",OrdersTotal());
     }

   return (oc);
  }
//==================================================================
void ClosePos()
  {

   if(posC1==0 && posC2==0) return;
  // if(spread0+spread1>SSprd) return;


/*if ((hour>=19 && min>=45) || (day==5 && hour>=17))
     {
		Print ("Bid= ",bid,"  Ask= ",ask,"  Last= ",last);
		ExecClose();
		Print ("close time"); 
		}*/

   if(Profit>=MaxProfit && timePos>=2
      )

     {
      ExecClose(); Print("CLOSE v1: sprd=  ",sprd,"  sr= ",sr);
     }

   if(MaxProfit==0 && timePos>=2 &&
      ( (buypos==true && sprd>=sr)
      || (sellpos==true && sprd<=sr))
      )

     {
      ExecClose(); Print("CLOSE v2: sprd=  ",sprd,"  sr= ",sr);
     }

   if((Profit<=MinProfit && timePos>=2)
      || (((posC1!=0 && posC2==0) || (posC1==0 && posC2!=0)) && timePos>=5)

      )

     {
      ExecClose(); Print("CLOSE v3");
     }


  }
//============================================================================
void ExecClose()
  {
   if(posC1==0 && posC2==0) return;

   for(int i=0; i<100; i++)

     {
      if(posC1>0)
        {
         if(!trade.PositionClose(symb))
           {
            //--- сообщим о неудаче
            Print("Метод PositionClose() потерпел неудачу. Код возврата=",trade.ResultRetcode(),
                  ". Описание кода sym: ",trade.ResultRetcodeDescription());
           }
         else
           {
            Print("Метод PositionClose() выполнен успешно SYM. Код возврата=",trade.ResultRetcode(),
                  " (",trade.ResultRetcodeDescription(),")");

           }
        }

      if(posC2>0)
        {
         if(!trade.PositionClose(symb1))
           {
            //--- сообщим о неудаче
            Print("Метод PositionClose() потерпел неудачу. Код возврата=",trade.ResultRetcode(),
                  ". Описание кода sym1: ",trade.ResultRetcodeDescription());
           }
         else
           {
            Print("Метод PositionClose() выполнен успешно SYM1. Код возврата=",trade.ResultRetcode(),
                  " (",trade.ResultRetcodeDescription(),")");

           }
        }

      CheckPos();
      if(posC1==0 && posC2==0) break;

     }
  }
//============================================================================
void TiksInfo()
  {
// TimeLocal(dt);
   TimeTradeServer(dt);
 //  day=dt;
   hour=dt.hour;
   min=dt.min;
   
  daym=dt.day;
  mon=dt.mon;

   bid=SymbolInfoDouble(symb,SYMBOL_BID);
   ask=SymbolInfoDouble(symb,SYMBOL_ASK);
   last=SymbolInfoDouble(symb,SYMBOL_LAST);

   bid1=SymbolInfoDouble(symb1,SYMBOL_BID);
   ask1=SymbolInfoDouble(symb1,SYMBOL_ASK);
   last1=SymbolInfoDouble(symb1,SYMBOL_LAST);

   spread0=(int)((ask-bid)*lotA);///ticksize0);
   spread1=(int)((ask1-bid1)*lot1);///ticksize1);

   sprd=(int)(last1*lot1-lotA*last);
   sprdI=(int)(bid1*lot1-lotA*ask);
   sprdO=(int)(ask1*lot1-lotA*bid);

    double ba=MathMax(ask,bid);
   pDIV=NormalizeDouble(((last1-last*lotA)/(last1*VM/100+last*lotA))*100*365/day,2);
   
   pDIVi=NormalizeDouble(((bid1-ba*lotA)/(bid1*VM/100+ba*lotA))*100*365/day,2);
   
   if(pDIVmax==0 || pDIVmin==0) { pDIVmax=pDIV; pDIVmin=pDIV;}
   if(pDIV>pDIVmax) pDIVmax=pDIV;
    if(pDIV<pDIVmin) pDIVmin=pDIV;
    
     if(pDIVimax==0 || pDIVimin==0) { pDIVimax=pDIVi; pDIVimin=pDIVi;}
   if(pDIVi>pDIVimax) { pDIVimax=pDIVi; }
    if(pDIVi<pDIVimin) pDIVimin=pDIVi;
    
   pDIVisr=(pDIVmax+pDIVmin)/2;

      Profit=iProfit();
      if(maxProfit==0 || minProfit==0) { maxProfit=Profit; minProfit=Profit;}
      if(Profit>maxProfit) maxProfit=Profit;
      if(Profit<minProfit) minProfit=Profit;
      if(tempmin!=min) {timePos=timePos+1; tempmin=min;}
      
      pDIVo=NormalizeDouble(((ask1-bid*lotA)/(ask1*VM/100+bid*lotA))*100*365/day+
        ((Profit)/(ask1*VM/100+bid*lotA))*100*365/day,2) ;
       
       if(pDIVomax==0 || pDIVomin==0) { pDIVomax=pDIVo; pDIVomin=pDIVo;}
      if(pDIVo>pDIVomax) pDIVomax=pDIVo;
      if(pDIVo<pDIVomin) pDIVomin=pDIVo; 



   if((OpenPositionsBuy==true || OpenPositionsSell==true) && rd<Round && trueTime==true)// && min<25) 
      trueTrade=true; else trueTrade=false;

   IsNewBar();

  }
//============================================================================
int dd (datetime a, datetime b)
{
int c=(int)MathFloor(b-a)/86400;

//Print ("d= ",c);

return (c);
}

//--------------------------------------------------------------------------
void CheckPos()
  {
 //  spos=PositionSelect(symb);
      sord=OrdersTotal();
   buypos1=false; sellpos1=false; posS1="NONE";
   buypos2=false; sellpos2=false; posS2="NONE";
   posC1=0; posC2=0;

   if(PositionSelect(symb) || PositionSelect(symb1) )
     {

      if(PositionSelect(symb)==true)
        {
         posC1=1;//PositionGetString(POSITION_COMMENT);
         if(PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_BUY) {buypos1=true; posS1="BUY";}
         if(PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_SELL) {sellpos1=true; posS1="SELL";}
         //Print ("posC1=  ",PositionGetDouble(POSITION_PRICE_OPEN));
        
        }

      if(PositionSelect(symb1)==true)
        {
         posC2=1;//PositionGetString(POSITION_COMMENT);
         if(PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_BUY) {buypos2=true; posS2="BUY";}
         if(PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_SELL) {sellpos2=true; posS2="SELL";}
         //Print ("posC2=  ",PositionGetDouble(POSITION_PRICE_OPEN));
        }

     }
//tradeInfo();
  }
//--------------------------------------------------------------------------
void show()
  {

   string text1="\n\n           "+(string)hour+"   :   "+(string)min+
                "\n\nTrue Trade: "+(string)trueTrade+"   Round= "+(string)rd+
                "\n\nProfit= "+(string)Profit+"  maxProfit= "+
                (string)maxProfit+" minProfit= "+(string)minProfit+
                "\n\nTime Positions= "+(string)timePos+" minute"
                +"\nPosition1;   "+symb+"   "+posS1
                +"\nPosition2;   "+symb1+"   "+posS2
                +"\nspread0= "+(string)spread0+"  spread1= "+(string)spread1
                + "\n\n\n Spread= "+(string)sprdI+"   DayOFFexp= "+(string)day//+"  DIV= "+(string)DIV
                +"\n\n\n% pDIV= "+(string)pDIV+"  % pDIVmax= "+(string)pDIVmax+"  % pDIVmin= "+(string)pDIVmin
                +"\n% pDIVi= "+(string)pDIVi+"  % pDIVimax= "+(string)pDIVimax+"  % pDIVimin= "+(string)pDIVimin+"     % SR= "+(string)pDIVisr
                +"\n% pDIVo= "+(string)pDIVo+"  % pDIVomax= "+(string)pDIVomax+"  % pDIVomin= "+(string)pDIVomin
                // + "\n\n Spread1= "+DoubleToString(sd,digit0) 
                ;
   Comment(text1);

  }
//============================================================================
bool IsNewBar()
  {
   if(BARS!=Bars(symb,per))
     {
      BARS=Bars(symb,per);
      high01=iHigh(symb,per,1);
      low01=iLow(symb,per,1);
      open01=iOpen(symb,per,1);
      close01=iClose(symb,per,1);
      dayC=TimeCurrent();
      day=dd(dayC,DayExp);
      
      if (hour==15) {
      pDIVmax=0; pDIVmin=0;
      pDIVimax=0; pDIVimin=0;
      pDIVomax=0; pDIVomin=0;
      pDIVisr=0;}


      return(false);
     }
   return(true);
  }

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

//----------------------------------------------------------------------
int iProfit()
  {
   double pO=0,pC=0,pC1=0,pO1=0,pr=0,pr1=0;

   if(spos || 0==0)
     {
      if(PositionSelect(symb))
        {
         pO=PositionGetDouble(POSITION_PRICE_OPEN);
         //pC=PositionGetDouble(POSITION_PRICE_CURRENT);

         if(PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_BUY)
           {
            pC=bid;
            if(pC>0 && pO>0) pr=(pC-pO)*lotA;
           }
         else
         if(PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_SELL)
           {
            pC=ask;
            if(pC>0 && pO>0) pr=(pO-pC)*lotA;
           }
        }
     if(PositionSelect(symb1))
        {
         pO=PositionGetDouble(POSITION_PRICE_OPEN);
         //pC=PositionGetDouble(POSITION_PRICE_CURRENT);

         if(PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_BUY)
           {
            pC=bid1;
            if(pC>0 && pO>0) pr1=(pC-pO)*lot1;
           }
         else
         if(PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_SELL)
           {
            pC=ask1;
            if(pC>0 && pO>0) pr1=(pO-pC)*lot1;
           }
        }
     }
   return((int)(pr+pr1));
  }
//------------------------------------------------------------------------
double iProfit11()
  {
   double pO=0,pC=0,pC1=0,pC2=0,pr=0;

   if(PositionSelect(symb)==true)
     {
      //pC=PositionGetDouble(POSITION_PRICE_CURRENT);
      pC1=PositionGetDouble(POSITION_PROFIT);

     }

   if(PositionSelect(symb1)==true)
     {
      // pO2=PositionGetDouble(POSITION_PRICE_OPEN);       //pC=PositionGetDouble(POSITION_PRICE_CURRENT);
      pC2=PositionGetDouble(POSITION_PROFIT);

     }
   pC=pC1+pC2;

   return(pC);
  }

//+------------------------------------------------------------------+
void tradeInfo()
  {
   if(posC1>0 && posC2>0)
     {
      maxProfit=iProfit();
      minProfit=maxProfit;


      tempmin=0;
      timePos=0;
     }
   if(posC1==0 && posC2==0 && timePos>0)
     {
      Print("Profit= ",(string)Profit,"  maxProfit= ",
            (string)maxProfit," minProfit= ",(string)minProfit,
            "  Time Positions= ",(string)timePos," minute");
      rd=rd+1;
      posS="NONE";
      buypos=false;
      sellpos=false;

      tempmin=0;
      timePos=0;
     }
  }
//---------------------------------------------------------------------
void OnTrade()
  {
//---
   CheckPos();
   tradeInfo();
  }
//+------------------------------------------------------------------+
void Symbol_Info(string symbol)
  {
   Print("symbol = ",symbol);
   symbol_info.Name(symbol);
//--- получим текущие котировки и выведем
   symbol_info.RefreshRates();
   Print(symbol_info.Name()," (",symbol_info.Description(),")",
         "  Bid=",symbol_info.Bid(),"   Ask=",symbol_info.Ask());
//--- получим значения минимальных отступов для торговых операций
   Print("StopsLevel=",symbol_info.StopsLevel()," pips, FreezeLevel=",
         symbol_info.FreezeLevel()," pips");
//--- получим количество знаков после запятой и размер пункта
   int digit111=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
   Print("Digit=",digit111,
         ", Point=",DoubleToString(symbol_info.Point(),symbol_info.Digits()));
//--- получим ticksize
   double ticksize111=symbol_info.TickSize();
   double tickvalue111=symbol_info.TickValue();

   Print("Ticksize= ",ticksize111,"  TickValue= ",tickvalue111);
//--- информация о спреде
   Print("SpreadFloat=",symbol_info.SpreadFloat(),", Spread(текущий)=",
         symbol_info.Spread()," pips");
//--- запросим тип исполнения ордеров, нет ли ограничений
   Print("Ограничения на торговые операции: ",EnumToString(symbol_info.TradeMode()),
         " (",symbol_info.TradeModeDescription(),")");
//--- выясним режим заключения сделок
   Print("Режим исполнения сделок: ",EnumToString(symbol_info.TradeExecution()),
         " (",symbol_info.TradeExecutionDescription(),")");
//--- выясним способ вычисления стоимости контрактов
   Print("Вычисление стоимости контракта: ",EnumToString(symbol_info.TradeCalcMode()),
         " (",symbol_info.TradeCalcModeDescription(),")");
//--- размер контрактов
   Print("Размер стандартного контракта: ",symbol_info.ContractSize(),
         " (",symbol_info.CurrencyBase(),")");
//--- минимальный, максимальный размеры объема в торговых операциях
   Print("Volume info: LotsMin=",symbol_info.LotsMin(),"  LotsMax=",symbol_info.LotsMax(),
         "  LotsStep=",symbol_info.LotsStep());
         
         

  }
//+------------------------------------------------------------------+