//+------------------------------------------------------------------+
//|                                               high_frequency.mq5 |
//+------------------------------------------------------------------+
#define     propVersion     "1.55"
#define     propDescription "high_frequency"
#property   copyright   "Copyright 2024 Enry, Gian & Luca"
#property   description propDescription
#property   version     propVersion
#include    <Trade\Trade.mqh>
            CTrade trade;
string      Notifica_4H=propDescription; 
string      gvp;    
string      Commom_gvp;   

//variabili medie mobili e variabili x tutti i trend


double      MediaHull []; 
int         MHull;
double      MediaHull_2 []; 
int         MHull_2;
int input   Periodo_Hull = 2;
int input   Deviazione_Hull = 2;
int input   Periodo_Hull_2 = 50;
int input   Deviazione_Hull_2 = 2;

double      Open_Alto;
double      Close, High, myPrice_4H, myLOW, ASK, BID, Spread;


double      PrezzoMedioCarico;
bool        Result = false;
string      Mercato="";
bool        Buy_2_L=false;
//variabili per condizioni BUY
//ulong input Magic=27042021;  
ulong       MagicN;   
int input   N_Barre=9;
int         Segnale=0;     //NOT BUY
int input   SpreadValue=100;
bool        Conto_Hedging = false;
double      SL;
//variabili entrata a mercato
int         NumberOfDeals=0;
double input   PrimaEntrata=0.25;
//double input   TP=400;//Takeprofit
int input      TP_2_L=50; //Breackeven Buy 2 Lotti
int input      SL_2_L=80; //StopLoss Buy 2 Lotti
int input      TralingStop=10;
int input      Punti_Buy_2_Lotti=50; //Punti X Buy 2 Lotti
ulong          Ticket;
double         open=-1;
double         pipDivisor =_Point; 
double         LottiinPancia=NormalizeDouble(0.0,_Digits);
int            P_StopProfit_CT_4H=0;
input bool     UsingTradingHour  = true;  //Filtro Time
//input int      UsingTimeStop     = 60;  //Minuti Time Stop
double            StartHour         = 1;  //Start Hour
double            EndHour           = 23; //End Hour

// Invio Mail e Notifiche
input bool     Send_Email         = true;
input bool     Audible_Alerts     = true;
input bool     Push_Notifications = true;
bool           debug = true;
bool           debug_filtri = true;

bool           debugPosTOT=false;//true;

// Variabili NewBar
datetime       lastbar,prevBar;
datetime       dataDv,dataCandela;
bool           resettaVarGlobali = true;
unsigned long  TKTinvioMail=9999999;
//int            NumeroMaxEntrate = 6;
bool           AlertPerSpread = true;
bool           debugSMAcross=true;
int            Rates_3Barre=5000;   
double         volume_inpancia;
bool           debug_CK_posizione = true;
bool           Posizione_EA_Aperta=false;
bool           debug_Uscita_Step = true;
string         TipoConto="";
bool           CloseEA=false;

//+------------------------------------------------------------------+
//|                Funzione di INIZIALIZZAZIONE                      |
//+------------------------------------------------------------------+ 
int OnInit(){
    if(debug) Print("\n\n-------------------------------------------------------------\nNew Run");
    if(debug) Print("\nVersione: " + propVersion);

// Direzione dell'indicizzazione (Index)    //spostato da OIntick a OnInit   
   ArraySetAsSeries  (MediaHull, true);
   ArraySetAsSeries  (MediaHull_2, true);

   Print("PeriodSeconds=",PeriodSeconds(PERIOD_CURRENT));


   
   if(debug && Conto_Hedging ==true ) Print(//"Init Posizioni=",NumberOfPosition,
                                                               " deal=", NumberOfDeals," Lotti aperti=", LottiinPancia);
   if(debug && Conto_Hedging ==false )Print(//"Init Posizioni=",NumberOfPosition,
                                                            " Lotti aperti=", LottiinPancia);

if(debug) Print("Conversione del simbolo in ASCII");
char simbolo[6];
char simbolo_EA[10];

StringToCharArray(_Symbol,simbolo,0,-1,0);
StringToCharArray(Notifica_4H,simbolo_EA,0,-1,0);

int count1=0;
int primoPezzo=0,secondoPezzo=0;
int count2=0;
int terzoPezzo=0,quartoPezzo=0;

for (int pos=0 ; pos<ArraySize(simbolo); pos++)
{
count1 = count1+ (simbolo[pos] - '0');
if (pos==2) {primoPezzo=count1; count1=0;}
}
secondoPezzo=count1;

for (int pos=0 ; pos<ArraySize(simbolo_EA); pos++)
{
count2 = count2+ (simbolo_EA[pos] - '0');
if (pos==2) {terzoPezzo=count2; count2=0;}
}
quartoPezzo=count2;


if(debug) Print("primoPezzo=",primoPezzo);
if(debug) Print("secondoPezzo=",secondoPezzo);
if(debug) Print("terzoPezzo=",terzoPezzo);
if(debug) Print("quartoPezzo=",quartoPezzo);

//if(debug) Print("Parte inizilae del Magic=",IntegerToString(Magic));
//if(debug) Print("Parte finale del Magic=",count1);
if(debug) Print("Parte finale del Magic=",count2);

//string tempS= IntegerToString(Magic)+IntegerToString(primoPezzo)+ IntegerToString(secondoPezzo);
string tempS= IntegerToString(primoPezzo)+ IntegerToString(secondoPezzo) + IntegerToString(terzoPezzo)+ IntegerToString(quartoPezzo);

if(debug) Print("tempS=",tempS);
MagicN=(ulong)StringToInteger(tempS);   //aggiungo al magic number una parte numerica dipendente dal simbolo convertito in ASCII

Print("EA magic =",MagicN);

   if(MQL5InfoInteger(MQL5_TESTING)) fDeleteGV();
   else        {if(debug && resettaVarGlobali ) Print("impostato flag per reset di tutte le variabili globali"); 
                if(resettaVarGlobali) fDeleteGV();}
   
   if(MQL5InfoInteger(MQL5_TESTING)) fDeleteGV();  // Delete global variables when working in Tester
   fCreateGVP(); // Creating a prefix for the names of global variables of the client terminal
   
   if(fGVC("_Segnale")) {Segnale=(int)fGVG("_Segnale"); if(debug)Print("Letta _Segnale dalle variabili globali d'ambiente");}
   else {Segnale=0;   fGVS("_Segnale",Segnale); if(debug)Print("inizializzata _Segnale a NOT BUY");}

   if(fGVC("_UltimaDv")) dataDv=(datetime)fGVG("_UltimaDv");  //data ultima divergenza
   else dataDv=0;   //origine dei tempi 

   if(fGVC("_SL")) {SL=(double)fGVG("_SL"); if(debug)Print("Letta _SL dalle variabili globali d'ambiente");}
   else {SL=0;   fGVS("_SL",SL); if(debug)Print("inizializzata _SL a 0");}

   if(fGVC("_Buy_2_L")){Buy_2_L=(bool)fGVG("_Buy_2_L");if(debug)Print("Letta _Buy_2_L dalle variabili globali d'ambiente");}
   else{Buy_2_L=false;fGVS("_Buy_2_L",Buy_2_L);if(debug)Print("inizializzata _Buy_2_L a FALSE");}
   
   if(fGVC("_myPrice_4H")) {myPrice_4H=(double)fGVG("_myPrice_4H"); if(debug)Print("Letta _myPrice_4H dalle variabili globali d'ambiente");}
   else {myPrice_4H=0;   fGVS("_myPrice_4H",myPrice_4H); if(debug)Print("inizializzata _myPrice_4H a 0");}

   if(fGVC("_open")) {open=(double)fGVG("_open"); if(debug)Print("Letta _open dalle variabili globali d'ambiente");}
   else {open=0;   fGVS("_open",open); if(debug)Print("inizializzata _open a 0");}

   if(fGVC("_P_StopProfit_CT_4H")) {P_StopProfit_CT_4H=(int)fGVG("_P_StopProfit_CT_4H"); if(debug)Print("Letta _P_StopProfit_CT_4H dalle variabili globali d'ambiente");}
   else {P_StopProfit_CT_4H=0;   fGVS("_P_StopProfit_CT_4H",P_StopProfit_CT_4H); if(debug)Print("inizializzata _P_StopProfit_CT_4H");}

   if(fGVC("_dataCandela")) dataCandela=(datetime)fGVG("_dataCandela");  //data ultima divergenza
   else dataCandela=0;   //origine dei tempi 

   if(fGVC("_CloseEA")){CloseEA=(bool)fGVG("_CloseEA");if(debug)Print("Letta _CloseEA dalle variabili globali d'ambiente");}
   else{CloseEA=false;fGVS("_CloseEA",CloseEA);if(debug)Print("inizializzata _CloseEA a FALSE");}


   
//per debug
   if(debug) Print("path variabile globale= ",Commom_gvp);
   if(debug) Print("_Pos_barra = ", TimeToString(dataDv));
   if(debug) Print("_Segnale = ", Segnale);

//fine 


int AccountMarginMode = (int) AccountInfoInteger(ACCOUNT_MARGIN_MODE);    
   if (AccountMarginMode == 0 ){   //ACCOUNT_MARGIN_MODE_RETAIL_NETTING
      TipoConto =   "NETTING";
      Conto_Hedging = false;
      }
   if (AccountMarginMode == 1 ){  //ACCOUNT_MARGIN_MODE_EXCHANGE
      TipoConto =  "EXCHANGE";
      }
   if (AccountMarginMode == 2 ){  //ACCOUNT_MARGIN_MODE_RETAIL_HEDGING
      TipoConto =   "HEDGING";
      Conto_Hedging  = true;
      }
   
   Visualizza_comment();
// controllo Timeframe corretto
   if( ChartPeriod(0) !=PERIOD_M5 ) {
      Alert("Non hai aperto il timeframe corretto che è M5"); 
      return(INIT_FAILED);
      }
   else
   {
      Print("TimeFrame corretto.");
   }
   
   if(open==-1) open=GetPositionOpenPrice();
   

// handle indicatori
   
   MHull = iCustom(Symbol(),PERIOD_CURRENT,"Hullaverage ",Periodo_Hull,Deviazione_Hull,PRICE_CLOSE);
   if(MHull ==INVALID_HANDLE) Print("MHull invalid handle");
   MHull_2 = iCustom(Symbol(),PERIOD_CURRENT,"Hullaverage ",Periodo_Hull_2,Deviazione_Hull_2,PRICE_CLOSE);
   if(MHull_2 ==INVALID_HANDLE) Print("MHull_2 invalid handle");
      
// controllo valuta
   if (StringFind(_Symbol,"JPY",0) == -1)pipDivisor = 100000; //controllo decimali del titolo
   if (StringFind(_Symbol,"JPY",0) ==  3)pipDivisor =   1000; //controllo decimali del titolo

return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//|                Funzione di DE-INIZIALIZZAZIONE                   |
//+------------------------------------------------------------------+
void OnDeinit(const int reason){

   IndicatorRelease  (MHull);
   IndicatorRelease  (MHull_2);
                          
   if(debug) Print("Cancello variabili globali"); 
   if(MQL5InfoInteger(MQL5_TESTING)) fDeleteGV();  // Delete global variables when working in tester
   Comment("");
}

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick(){

   BID= NormalizeDouble(SymbolInfoDouble(NULL,SYMBOL_BID),_Digits);

// Toglie EA dal grafico   
   if(CloseEA){
      CK_Chiusura_EA();
      }
    
         for(int h = PositionsTotal() -1; h >= 0; h--)
           {
            ulong ticket = 0;
            if((ticket = PositionGetTicket(h)) != 0 && StringCompare(PositionGetSymbol(h),Symbol(),false)==0 && PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_BUY && PositionGetInteger(POSITION_MAGIC) ==MagicN)
              {
               GetPositionOpenPrice();
               GetAllTradingValues();
               
               if(LottiinPancia==0) { Buy_2_L=false;fGVS("_Buy_2_L",Buy_2_L);}// se lotti 0 setto Buy 2 Lotti a false
               BID= NormalizeDouble(SymbolInfoDouble(NULL,SYMBOL_BID),_Digits);
               double Valore_Ingresso_buy_2_Lotti = open-Punti_Buy_2_Lotti * _Point;
               
               if(LottiinPancia>0 && open>0)
                  {
                  if (Buy_2_L){ 
                     gestioneTakeprofit();
                     }
                  if (!Buy_2_L){ 
                     Manfrina_Uscite_a_Step();
                     }
                  //if(myLow<SL && !Buy_2_L)
                  if(BID<Valore_Ingresso_buy_2_Lotti && !Buy_2_L)
                     {
                     if(debug) Print("Entro in funzione BUY 2 LOTTI..."); 
                     FUNZION_BUY_2_LOTTI();
                     }
                  }      
              }
           }
        
   if (NewBar()) OnNewBar();
   }
//+------------------------------------------------------------------+
//| alla comparsa di una nuova barra             |
//+------------------------------------------------------------------+  
   
void OnNewBar(void)
   {  
   
   if(debug && LottiinPancia==0) { 
      Print("Seganle=",Segnale);
      }
   if(open==0)
     {
      P_StopProfit_CT_4H=0;
      fGVS("_P_StopProfit_CT_4H",P_StopProfit_CT_4H); 
      }      
   // verifico condizioni Divergenze

   ResetLastError(); if(CopyBuffer(MHull,1,0,Rates_3Barre,MediaHull)< 0)   {Print("CopyBuffer MediaHull error =",GetLastError());}
   ResetLastError(); if(CopyBuffer(MHull_2,0,0,Rates_3Barre,MediaHull_2)< 0)  {Print("CopyBuffer MediaHull_2 error =",GetLastError());}
   GetAllTradingValues();
   
   if(LottiinPancia==0)
      {                               
  
                                    bool SMAcross=  false;
                                    SMAcross = MediaHull[2]==2 && MediaHull[1]==1;
                                    if(debugSMAcross ) Print("SMA cross=",SMAcross);               
                                    if(   
                                       SMAcross
                                       ) 
                                          { // se avviene l'incrocio dal basso verso l'alto della media veloce sulla media lenta

                                             
                                             PrimoIngresso();
                                          }          
                             }     //fine if(Pos_barra<=N_Barre  )
         
   Visualizza_comment();
   
   }   //fine if(Segnale == 1) 

//+------------------------------------------------------------------+
//|      Funzione Per Ingesso BUY                                    |
//+------------------------------------------------------------------+
void PrimoIngresso(){
   ASK= NormalizeDouble(SymbolInfoDouble(NULL,SYMBOL_ASK),_Digits);
   BID= NormalizeDouble(SymbolInfoDouble(NULL,SYMBOL_BID),_Digits);
   Spread=NormalizeDouble(ASK-BID,_Digits);

   
// controllo se non ci sono posizioni aperte entro in BUY      
//   if(NumberOfPosition==0){
if(LottiinPancia   == 0 ){
         if(debug) Print("non ci sono posizioni aperte entro in BUY"); 
         if(debug) Print("ASK=",ASK);
         if(debug) Print("BID=",BID);
         
         if ( TimeCheck() == false ) {
            myAlert("Operazione BUY NEGATA per Orario Vietato");
            return;
         }
         ResetLastError();
         double Numero_Lotti_buy= PrimaEntrata*8; 
         trade.SetExpertMagicNumber(MagicN);
         if(!trade.Buy(Numero_Lotti_buy,NULL,ASK,0,0, Notifica_4H)) PrintError("Entrata high_frequency");
         else{
              //Pos++;                       // Incremento Pos per non aprire altre posizioni
               GetPositionOpenPrice();
               GetAllTradingValues();
               long TK= PositionGetInteger(POSITION_TICKET);
               Ticket= TK; // Memorizzo numero del Ticket
               if(debug) Print("Ticket=",Ticket);
               if(debug) Print("open=",open);
               P_StopProfit_CT_4H=1;
               CloseEA=true;
               fGVS("_CloseEA",CloseEA);
               Buy_2_L=false;
               fGVS("_Buy_2_L",Buy_2_L); 
               fGVS("_P_StopProfit_CT_4H",P_StopProfit_CT_4H);
               Print( "BUY Ticket: "+IntegerToString(Ticket)+" | "+"PriceOpen: "+DoubleToString(open));
               myAlert ("Entrata a Mercato --- Lotti=" + DoubleToString(LottiinPancia));
            }
         }   
}

//+------------------------------------------------------------------+
//|                  Funzione Per NewBar                             |
//+------------------------------------------------------------------+
bool NewBar(){

   // Assegno a prevBar Orario Ultima Candela
   prevBar=lastbar; 
   
   // Aggiorno orario Candela 0   
   lastbar= iTime(NULL,PERIOD_CURRENT,0); 
      
   // Verifica e ritorna true se pervBar è diverso da lastBar
   return prevBar!=lastbar; 
}

//+------------------------------------------------------------------+
//|                  Funzione Per Stampa Errore                      |
//+------------------------------------------------------------------+
void PrintError(string error){

   Print("Errore in "+error+": "+IntegerToString(GetLastError()));
}


//+------------------------------------------------------------------+
//|               Funzione Per Invio Mail e Notifiche                |
//+------------------------------------------------------------------+
void myAlert(string message)
   {
   if(Audible_Alerts) Alert( message + " --- " + Symbol() + " --- " + Notifica_4H );
   if(Send_Email) SendMail(message  , Symbol() + " --- " + Notifica_4H );
   if(Push_Notifications) SendNotification(message + " --- " + Symbol() + " --- "+ Notifica_4H);
   //Print(message  + " --- " + Symbol() + " --- " + Notifica_4H);
   } 

 

//+------------------------------------------------------------------+
//|   crea il path da usare per le variabili d'ambiente          |
//+------------------------------------------------------------------+
void fCreateGVP()  
  {
   gvp=MQL5InfoString(MQL5_PROGRAM_NAME)+"_"+_Symbol+"_"+IntegerToString(MagicN)+"_";
   Commom_gvp="COMMOM_";
   if(AccountInfoInteger(ACCOUNT_TRADE_MODE)==ACCOUNT_TRADE_MODE_DEMO)
     {
      gvp=gvp+"d_";
     }
   if(AccountInfoInteger(ACCOUNT_TRADE_MODE)==ACCOUNT_TRADE_MODE_REAL)
     {
      gvp=gvp+"r_";
     }
   if(MQL5InfoInteger(MQL5_TESTING))
     {
      gvp=gvp+"t_";
      Commom_gvp=gvp;
     }
  }
//+------------------------------------------------------------------+
//|  cancella le variabili d'ambiente                                |
//+------------------------------------------------------------------+
void fDeleteGV()
  {
  
  if(debug) Print("son in Delete global variable");
   //if(MQL5InfoInteger(MQL5_TESTING))
   int GVnum= GlobalVariablesTotal();
   if(debug) Print("numero variabili globali=",GVnum);
   if(debug) Print("path=",gvp);
     {
      for(int i=GVnum-1;i>=0;i--)
        {
        if(debug) Print("name",i,"=",GlobalVariableName(i));
         if(StringFind(GlobalVariableName(i),gvp,0)==0)
           {
            if(debug) Print("Cancello ",GlobalVariableName(i), " che valeva:",fGVG(GlobalVariableName(i)));
            ResetLastError();
            GlobalVariableDel(GlobalVariableName(i));
            int erroreCanc= GetLastError();
            if(erroreCanc!=0) Print("Errore cancellazione ",GlobalVariableName(i)," ",erroreCanc);
           }
        }
     }
  }
//+------------------------------------------------------------------+
//|  setta la variabile d'ambiente                                   |
//+------------------------------------------------------------------+
void fGVS(string aName,double aValue)
  {
  GlobalVariableSet(gvp+aName,aValue);
  }
//+------------------------------------------------------------------+
//|  recupera la variabile d'ambiente                                |
//+------------------------------------------------------------------+
double fGVG(string aName)
  {
   return(GlobalVariableGet(gvp+aName));
  }
//+------------------------------------------------------------------+
//|  cancella la variabile d'ambiente                                |
//+------------------------------------------------------------------+
void fGVD(string aName)
  {
   GlobalVariableDel(gvp+aName);
  }
//+------------------------------------------------------------------+
//| crea la variabile d'ambiente                                     |
//+------------------------------------------------------------------+
bool fGVC(string aName) 
  {
   return(GlobalVariableCheck(gvp+aName));
  }

void OnTradeTransaction(const MqlTradeTransaction& trans,
                        const MqlTradeRequest& request,
                        const MqlTradeResult& result)
  {
//---
  

   
   ulong last_=-1;
   long magicNumberRicavato=-1;
   ResetLastError();
   if( trans.type == TRADE_TRANSACTION_DEAL_ADD && trans.symbol == _Symbol) {
                                       //DescriviTransazione(trans);
                                       last_ = trans.deal;
                                       //controllo se la transazione corrente appartiene al nostro EA (ha lo stesso magic)
                                       if(HistoryDealSelect(last_))
                                             {
	                                             magicNumberRicavato = HistoryDealGetInteger(last_,DEAL_MAGIC);
	                                             Print("MAGIC=",magicNumberRicavato);
	                                             if (magicNumberRicavato != MagicN) Print("ATTENZIONE!!!!,\nDEAL lanciato da altro EA");		                                             
	                                             
                                              }
                                       else // notifica di fallimento 
                                             PrintFormat("HistoryDealSelect() fallito per #%d. Codice Errore=%d",last_,GetLastError());
                                       }
  
                                       
 //se è stata chiusa a mano una posizione da qualcuno faccio partire lo smazzarsi dello storico da questo istante
   if ( magicNumberRicavato!= MagicN && trans.symbol == Symbol() && trans.type==  TRADE_TRANSACTION_DEAL_ADD  &&  trans.deal_type==DEAL_TYPE_SELL   )
                  {
                  //se è stato chiusa a mano una posizione
                  Print("E' stata chiusa la posizione ma non da questo EA");  
                  }  
                  
  if (magicNumberRicavato== MagicN  && trans.symbol == Symbol() && trans.type==  TRADE_TRANSACTION_DEAL_ADD  &&  trans.deal_type==DEAL_TYPE_SELL   )
                  {
                  
                   string Messaggio= "vendita al prezzo "+(string)trans.price+" di "+(string)trans.volume+ " lotti del deal n."+(string)trans.deal+" sl="+(string)trans.price_sl+" tp="+(string)trans.price_tp;
                   Print(Messaggio);

                  if(Send_Email==true ) myAlert(Messaggio);
                  

                   }   
                   
                                                      
     
  }
  
  
  double GetPositionOpenPrice(){  //nel conto Hedging restituisco le posizioni aperte, mentre nel conto netting restituisco il numero di deal che hanno portato a una posizione
 //Print("\nGIOOOOOO");
 double prezzoApertura=0;
  //if(debugPosTOT) Print("\n sono in GetPositionOpenPrice");
  
  if(Conto_Hedging) { //se heging
                       int NPt=PositionsTotal();                      
                        for(int h=0;h<NPt;h++)  {   
                                                         if(StringCompare(PositionGetSymbol(h),Symbol(),false)==0 && PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_BUY
                                                          && PositionGetInteger(POSITION_MAGIC) == MagicN
                                                          ) 
                                                                           {                                                                            
                                          		                              prezzoApertura= PositionGetDouble(POSITION_PRICE_OPEN);
                                          		                              //Print("prezzo apertura pos=",prezzoApertura);
                                          		                              
                                          		                              //mi interessa open price dell'ultima posizione
                                                                            }                      		                 
                                                      }  
                       
                     }
  else {   //if netting
                        int NPt=PositionsTotal();                      
                        for(int h=0;h<NPt;h++)  {   
                                                         if(StringCompare(PositionGetSymbol(h),Symbol(),false)==0 && PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_BUY
                                                          && PositionGetInteger(POSITION_MAGIC) == MagicN
                                                          ) 
                                                                           {                                                                            
                                          		                              long IdentificativoDiPos= PositionGetInteger(POSITION_IDENTIFIER);
                                          		                              
                                          		                              //recupero la cronistoria degli affari che hanno portato a quella posizione
                                          		                              HistorySelectByPosition(IdentificativoDiPos);
                                          		                              int DimLista=HistoryDealsTotal();  //dimensione della lista degli affari che hanno portato a quella particolare posizione
                                          		                              for(int hhh=0;hhh<DimLista;hhh++)  
                                          		                                             { 
                                          		                                              ulong ti=HistoryDealGetTicket(hhh);
                                          		                                              //bool trovato=HistoryDealSelect(ti);
                                          		                                             // if(trovato) {
                                          		                                             // }
                                          		                                             // else Print("Non trovato Deal per ",IdentificativoDiPos);
                                          		                                             prezzoApertura=HistoryDealGetDouble(ti,DEAL_PRICE);
                                          		                                             //Print("prezzo apertura pos=",prezzoApertura);                                          		                                             
                                          		                                             } 

                                                                            }                      		                 
                                                      }  
                        
  
  }
  open=prezzoApertura;
  fGVS("_open",open);
  return(prezzoApertura);
}
//+------------------------------------------------------------------+
//|  recupero posizioni, affari,  prezzo medio di carico e lotti per |
//|  la posizione corrente                                           |
//+------------------------------------------------------------------+
void GetAllTradingValues(){  //nel conto Hedging restituisco le posizioni aperte, mentre nel conto netting restituisco il numero di deal che hanno portato a una posizione
  int n=0; ulong u=0;
  if(debugPosTOT) Print("\n sono in GetAllTradingValues");
  int NPt=PositionsTotal();
  if(debugPosTOT) Print("tot posizioni per tutti i simboli=",NPt);
  if(debugPosTOT) Print("Hedging=",Conto_Hedging);
  double Sum_positions_lots=0,Pondered_openPrice=0;
   for(int h=0;h<NPt;h++)  {   
                                    if(StringCompare(PositionGetSymbol(h),Symbol(),false)==0 && PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_BUY
                                     && PositionGetInteger(POSITION_MAGIC) == MagicN
                                     ) 
                                                      {                                                                            
                                                         n++;
                      		                              if(debugPosTOT) Print("trovato 1 nuova posizione ", n," aperta per il simbolo ",Symbol() );
                     		                              double vol= PositionGetDouble(POSITION_VOLUME);
                     		                              if(debugPosTOT) Print("calcolo lotti parziali pos=",vol);
                     		                              Sum_positions_lots=Sum_positions_lots+ vol;
                     		                              double prez= PositionGetDouble(POSITION_PRICE_OPEN);
                     		                              //if(debugPosTOT) Print("prezzo apertura pos=",prez);
                     		                              Pondered_openPrice  = Pondered_openPrice+ prez*vol;             		         

                                                       }                      		                 
                                 }  
                                 
  //if( Conto_Hedging ==true ) {
  if(Sum_positions_lots>0) { 
               LottiinPancia=NormalizeDouble(Sum_positions_lots,_Digits);
               PrezzoMedioCarico=NormalizeDouble(Pondered_openPrice/Sum_positions_lots,_Digits);
               u=n;
               n=1;
            }
   else {
   LottiinPancia=NormalizeDouble(0.0,_Digits); 
   PrezzoMedioCarico=NormalizeDouble(0,_Digits);u=0; 
                                  //if(debug) Print("\n\n\n\n*****ATTANZIONE\n\n\n\n");
                                  }
   
   //if(debug) Print("Lotti=",LottiinPancia);
  //}
  //else if( Conto_Hedging !=true ) {
  //                                  //necessario perchè se son scarico nella piattaforma "netting" non passo da GetDealCount per aggiornare LottiinPancia ecc...
  //                                  if(n==0) {LottiinPancia=0; PrezzoMedioCarico=0;u=0;}
  //                                  }
if(debugPosTOT) Print("restituisco ",n," in GetAllTradingValues come valore di return\n");
//NumberOfPosition=n;
NumberOfDeals=(int)u;   //number of deals non li calcoliamo perchè rallenterebbero troppo il calcolo. Sarebbe da scommentare la riga sopra:  //u= GetDealCount(POSID);   

}
//+------------------------------------------------------------------+
//| Time Check Function                                              |
//+------------------------------------------------------------------+   
bool TimeCheck()
 {
   bool Result_Time_CK = false;
   //bool CheckDay = false;
   bool CheckHour = false;
   MqlDateTime TimeNow;
   TimeToStruct(TimeCurrent(),TimeNow);
   /*
   // Check day
   if (  ( TimeNow.day_of_week == 1 && TradeOnMonday ) ||
         ( TimeNow.day_of_week == 2 && TradeOnTuesday ) ||
         ( TimeNow.day_of_week == 3 && TradeOnWednesday ) ||
         ( TimeNow.day_of_week == 4 && TradeOnThursday ) ||
         ( TimeNow.day_of_week == 5 && TradeOnFriday ) )
            CheckDay = true;
   */
   // Check hour
   if ( StartHour < EndHour )
      if (  TimeNow.hour > StartHour &&
         TimeNow.hour < EndHour )  CheckHour = true;
   if ( StartHour > EndHour )
      if (  TimeNow.hour > StartHour ||
         TimeNow.hour < EndHour )  CheckHour = true;
   if ( StartHour == EndHour )
      if (  TimeNow.hour == StartHour )  CheckHour = true;
   // Check All
   if ( UsingTradingHour &&   CheckHour ) Result_Time_CK = true; // if ( UsingTradingHour && CheckDay && CheckHour ) Result = true;
   if ( !UsingTradingHour ) Result_Time_CK = true; //if ( !UsingTradingHour && CheckDay ) Result = true;
   return(Result_Time_CK);
 }



//+------------------------------------------------------------------+
//|                        FUNZION_BUY_2LOTTI                        |
//+------------------------------------------------------------------+
void FUNZION_BUY_2_LOTTI (){

   ASK= NormalizeDouble(SymbolInfoDouble(NULL,SYMBOL_ASK),_Digits);
   
   for(int h = PositionsTotal() -1; h >= 0; h--)
      {
      ulong ticket = 0;
      if((ticket = PositionGetTicket(h)) != 0 && StringCompare(PositionGetSymbol(h),Symbol(),false)==0 && PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_BUY && PositionGetInteger(POSITION_MAGIC) ==MagicN)
         {
         volume_inpancia = PositionGetDouble( POSITION_VOLUME) ;
         if (debug_CK_posizione) {Print("Volume in pancia x MagicN: " + IntegerToString(MagicN) + " --- " + DoubleToString(volume_inpancia) + " --- " + Notifica_4H);}
         trade.SetExpertMagicNumber(MagicN);
         if(!trade.Buy(volume_inpancia*2,NULL,ASK,0,0, Notifica_4H)) PrintError("Entrata " + Notifica_4H);
         else{
         
            Ticket= trade.ResultOrder(); // Memorizzo numero del Ticket
            open  = trade.ResultPrice(); // Memorizzo Prezzo di apertura
            Buy_2_L=true;
            GetAllTradingValues();            
            fGVS("_Buy_2_L",Buy_2_L);
            myAlert ("BUY 2 LOTTI --- Lotti=" + DoubleToString(LottiinPancia));
            }
               trade.SetExpertMagicNumber(MagicN);
               int n=0;
               int NumeroPosizioni=PositionsTotal();
               for(int h=0; h<NumeroPosizioni; h++)
                 {
                  if(StringCompare(PositionGetSymbol(h),Symbol(),false)==0 && PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_BUY && PositionGetInteger(POSITION_MAGIC) ==MagicN)
                    {
                     long TK= PositionGetInteger(POSITION_TICKET);
                     ResetLastError();
                     if(SL_2_L>0)
                       {
                        if(!trade.PositionModify(TK,NormalizeDouble((PrezzoMedioCarico-SL_2_L*_Point),_Digits),NormalizeDouble((PrezzoMedioCarico + TP_2_L*_Point),_Digits)))
                           {
                           PrintError("Modifica BreakEven per 2° Entrata");
                           }
                        else
                          {
                           myAlert("impostato take profit a BreakEven per 2° Entrata");
                           }                  
                       }
                     else
                        {
                     }  
                  }
               }
            }
         GetPositionOpenPrice();      
      }
   }
//+------------------------------------------------------------------+
//|                Manfrina_Uscite_a_Stepp                           |
//+------------------------------------------------------------------+
void Manfrina_Uscite_a_Step()
  {
   ASK= NormalizeDouble(SymbolInfoDouble(NULL,SYMBOL_ASK),_Digits);
   BID= NormalizeDouble(SymbolInfoDouble(NULL,SYMBOL_BID),_Digits);
   Spread=NormalizeDouble(ASK-BID,_Digits);

   GetAllTradingValues();
   GetPositionOpenPrice();
   
         for(int h = PositionsTotal() -1; h >= 0; h--)
           {
            ulong ticket = 0;
            if(Spread <= (SpreadValue*_Point) )
               {           
            if((ticket = PositionGetTicket(h)) != 0 && StringCompare(PositionGetSymbol(h),Symbol(),false)==0 && PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_BUY && PositionGetInteger(POSITION_MAGIC) ==MagicN)
              {

               if(LottiinPancia>0)
                  {
                  //Print("Manfrina_Uscite_a_Step" + P_StopProfit_CT_4H);
                  if(BID >= NormalizeDouble((open + (TralingStop*_Point)),_Digits) && P_StopProfit_CT_4H==1 ){
                     ChiusuraPosizioniMultiple_A();
                     P_StopProfit_CT_4H++;
                     if(debug_Uscita_Step) {Print("P_StopProfit_CT_4H >>> " + IntegerToString(P_StopProfit_CT_4H));}
                     fGVS("_P_StopProfit_CT_4H",P_StopProfit_CT_4H);}
                     
                  if(BID >= NormalizeDouble((open + ((TralingStop*2)*_Point)),_Digits) && P_StopProfit_CT_4H==2 ){
                     ChiusuraPosizioniMultiple_A();
                     P_StopProfit_CT_4H++;
                     if(debug_Uscita_Step) {Print("P_StopProfit_CT_4H >>> " + IntegerToString(P_StopProfit_CT_4H));}
                     fGVS("_P_StopProfit_CT_4H",P_StopProfit_CT_4H);}
                     
                  if(BID >= NormalizeDouble((open + ((TralingStop*3)*_Point)),_Digits) && P_StopProfit_CT_4H==3 ){
                     ChiusuraPosizioniMultiple_A();
                     P_StopProfit_CT_4H++;
                     if(debug_Uscita_Step) {Print("P_StopProfit_CT_4H >>> " + IntegerToString(P_StopProfit_CT_4H));}
                     fGVS("_P_StopProfit_CT_4H",P_StopProfit_CT_4H);}
                     
                  if(BID >= NormalizeDouble((open + ((TralingStop*4)*_Point)),_Digits) && P_StopProfit_CT_4H==4 ){
                     ChiusuraPosizioniMultiple_B(1);
                     P_StopProfit_CT_4H++;
                     if(debug_Uscita_Step) {Print("P_StopProfit_CT_4H >>> " + IntegerToString(P_StopProfit_CT_4H));}
                     fGVS("_P_StopProfit_CT_4H",P_StopProfit_CT_4H);}
                     
                  if(BID >= NormalizeDouble((open + ((TralingStop*5)*_Point)),_Digits) && P_StopProfit_CT_4H==5 ){
                     ChiusuraPosizioniMultiple_B(1);
                     P_StopProfit_CT_4H++;
                     if(debug_Uscita_Step) {Print("P_StopProfit_CT_4H >>> " + IntegerToString(P_StopProfit_CT_4H));}
                     fGVS("_P_StopProfit_CT_4H",P_StopProfit_CT_4H);}
                     
                  if(BID >= NormalizeDouble((open + ((TralingStop*6)*_Point)),_Digits) && P_StopProfit_CT_4H==6 ){
                     ChiusuraPosizioniMultiple_B(2);
                     P_StopProfit_CT_4H++;
                     if(debug_Uscita_Step) {Print("P_StopProfit_CT_4H >>> " + IntegerToString(P_StopProfit_CT_4H));}
                     fGVS("_P_StopProfit_CT_4H",P_StopProfit_CT_4H);}
                     
                  if(BID >= NormalizeDouble((open + ((TralingStop*7)*_Point)),_Digits) && P_StopProfit_CT_4H==7 ){
                     ChiusuraPosizioniMultiple_B(3);
                     P_StopProfit_CT_4H++;
                     if(debug_Uscita_Step) {Print("P_StopProfit_CT_4H >>> " + IntegerToString(P_StopProfit_CT_4H));}
                     fGVS("_P_StopProfit_CT_4H",P_StopProfit_CT_4H);}
                     
                  if(BID >= NormalizeDouble((open + ((TralingStop*8)*_Point)),_Digits) && P_StopProfit_CT_4H==8 ){
                     ChiusuraPosizioniMultiple_A();
                     P_StopProfit_CT_4H++;
                     if(debug_Uscita_Step) {Print("P_StopProfit_CT_4H >>> " + IntegerToString(P_StopProfit_CT_4H));}
                     fGVS("_P_StopProfit_CT_4H",P_StopProfit_CT_4H); }
                      
               }      
            }
         }
      }
   }

//+------------------------------------------------------------------+
//|               Funzione per StopProfit Protettivo                 |
//+------------------------------------------------------------------+
void ModificaStopProfitProtettivo(int ValoreTraling)
{
   
   int NumeroPosizioni=PositionsTotal();
   for(int h=0; h<NumeroPosizioni; h++)
   {
      if(StringCompare(PositionGetSymbol(h),Symbol(),false)==0 && PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_BUY && PositionGetInteger(POSITION_MAGIC) ==MagicN)
      {
      long TK= PositionGetInteger(POSITION_TICKET);
      ResetLastError();
      trade.SetExpertMagicNumber(MagicN);
      if(!trade.PositionModify(TK,open + (TralingStop * ValoreTraling)*_Point,0))
         {
         PrintError("Modifica BreakEven per 2° Entrata");
         Print("Modificato Stoploss protettivo >>> " + DoubleToString(open + TralingStop*_Point));}      
      else
         {
         myAlert("impostato StopProfit Protettivo >>> " + DoubleToString(open + TralingStop*_Point));
         }
      }
   }

}
//+------------------------------------------------------------------+
//|          Funzione per Chiusura Posizioni Multiple                |
//+------------------------------------------------------------------+
void ChiusuraPosizioniMultiple_A()
{
   int NumeroPosizioni=PositionsTotal();
   for(int h=0; h<NumeroPosizioni; h++)
   {
      if(StringCompare(PositionGetSymbol(h),Symbol(),false)==0 && PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_BUY && PositionGetInteger(POSITION_MAGIC) ==MagicN)
      {
      long TK= PositionGetInteger(POSITION_TICKET);
      ResetLastError();
      ChiusuraPosizioni(TK,PrimaEntrata);
      }
   }
}
//+------------------------------------------------------------------+
//|          Funzione per Chiusura Posizioni Multiple CON STOPROFIT  |
//+------------------------------------------------------------------+
void ChiusuraPosizioniMultiple_B(int Valore)
{
   int NumeroPosizioni=PositionsTotal();
   for(int h=0; h<NumeroPosizioni; h++)
   {
      if(StringCompare(PositionGetSymbol(h),Symbol(),false)==0 && PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_BUY && PositionGetInteger(POSITION_MAGIC) ==MagicN)
      {
      long TK= PositionGetInteger(POSITION_TICKET);
      ResetLastError();
      ChiusuraPosizioni(TK,PrimaEntrata);
      Print("Entro in modifica Stoprofit");
      ModificaStopProfitProtettivo(Valore);
      }
   }
}

//+------------------------------------------------------------------+
//|             Funzione per Chiusura Totale Ordini                  |
//+------------------------------------------------------------------+
void ChiusuraPosizioni(ulong Ticket_Chiusura_Ordine, double Numero_Lotti){

   //trade.SetExpertMagicNumber(MagicN);
if(!Conto_Hedging){
   //--- dichiara ed inizializza la richiesta e il risultato di trade 
   MqlTradeRequest request={};
   MqlTradeResult  result ={};
   
   string errore; // Dichiaro string errore
   
   //--- parametri della richiesta
   request.position=PositionGetTicket((int)Ticket_Chiusura_Ordine);
   request.position_by=PositionGetInteger(POSITION_TICKET);
   request.action   =TRADE_ACTION_DEAL;                 // Tipo di operazione di trade
   request.symbol   =Symbol();                          // Simbolo
   request.volume   =Numero_Lotti;                             // Volume di lotti con variabile globale da prendere nel Bottone2
   request.type     =ORDER_TYPE_SELL;                        // Tipo di ordine ORDER_TYPE_BUY / ORDER_TYPE_SELL
   request.price    =SymbolInfoDouble(_Symbol,SYMBOL_BID); // Prezzo per l'apertura: ASK per il BUY / BID per il SELL
   request.sl       =0;                                 // Impostazione StopLoss
   request.tp       =0;                                 // IMpostazione TakeProfit
   request.deviation=0;
   request.magic    =MagicN;                            // MagicNumber dell'ordine   
   
//--- Invio richiesta Ordine
         
   if(!OrderSend(request,result)){
       PrintError(errore); // Se false stampa il codice dell'errore
       return; // Esci dalla funzione se c'è un errore
      }
//--- Info sull'Ordine Eseguito
   Print("Codice Operazione(retcode): "+IntegerToString(result.retcode)+" | Codice Operazione: "+IntegerToString(result.deal)+" | Codice Ordine: "+IntegerToString(result.order));  
   }

   
if(Conto_Hedging){
   trade.SetExpertMagicNumber(MagicN);
   if(!trade.PositionClosePartial(Ticket_Chiusura_Ordine,Numero_Lotti,-1)){
      PrintError("ChiusuraPosizioni Ticket: " + (string)Ticket_Chiusura_Ordine );
      }
   else{
      myAlert ("Chiusa lotti: " + DoubleToString(Numero_Lotti) + "---Ticket: " + string(Ticket_Chiusura_Ordine)); 
       } 
   }         
 
 }// Chiusura funzione CloseAllTrades
   
//+------------------------------------------------------------------+
//| Imposta Stoploss                                                 |
//+------------------------------------------------------------------+
void impostaStoplossTakeprofit( double _stoploss, double _takeprofit, ulong _ticket, ulong _magic,
                      string _commento )
{
   MqlTradeRequest ordine = {};
   ZeroMemory( ordine );
   MqlTradeResult risposta = {};
   
   ordine.action = TRADE_ACTION_SLTP;
   ordine.symbol = _Symbol;
   ordine.sl = _stoploss;
   ordine.tp = _takeprofit;
   ordine.magic = _magic;
   ordine.position = _ticket;
  
   if( !OrderSend( ordine, risposta ) )
   {
      if(debug) {Alert(_commento, "", GetLastError() );}
   }
   else 
   {  
      if(debug) {Alert( _commento, "" );}  
   }  
}


//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void gestioneTakeprofit()
{
   double pmc = 0.0;
   double sommaSize = 0.0;
   
   for( int i = PositionsTotal() -1; i >= 0; i-- )
   {
      ulong ticket = 0;
      
      if((ticket = PositionGetTicket(i)) != 0 &&
          PositionGetInteger(POSITION_MAGIC) == MagicN )
      {
         pmc += PositionGetDouble(POSITION_PRICE_OPEN) * PositionGetDouble(POSITION_VOLUME );
         sommaSize += PositionGetDouble( POSITION_VOLUME) ;
      }
   }
   
   if( sommaSize != 0 )
   {
      pmc /= sommaSize;
      
      pmc = NormalizeDouble( pmc, _Digits );
      
      double valoreTakeprofit = pmc + TP_2_L * _Point;
      
      valoreTakeprofit = NormalizeDouble( valoreTakeprofit, _Digits );
      
      for( int i = PositionsTotal() -1; i >= 0; i-- )
      {
         ulong ticket = 0;
      
         if((ticket = PositionGetTicket(i)) != 0 &&
          PositionGetInteger(POSITION_MAGIC) == MagicN)
         {
            if( NormalizeDouble( PositionGetDouble( POSITION_TP), _Digits ) != 
               valoreTakeprofit )
            {   
               //Print( "Aggiorno takeprofit : " + DoubleToString( valoreTakeprofit, _Digits ) );
           
               impostaStoplossTakeprofit( PositionGetDouble( POSITION_SL ), 
                                          valoreTakeprofit,
                                          ticket, MagicN, PositionGetString(POSITION_COMMENT) );
            
             }   
         }
      }
   }
}

//+------------------------------------------------------------------+
//|                      Visualizza_comment                          |
//+------------------------------------------------------------------+

void Visualizza_comment()
{
   Comment("\n" + Notifica_4H +
   "\nMagicN: " + IntegerToString(MagicN) +   
   "\nTipo di Conto: " + TipoConto +
   "\nVersione: " + propVersion +
   "\nControllo Spread: " + IntegerToString(SpreadValue) +
   "\nHull 1: " + IntegerToString(Periodo_Hull) +
   "\nHull 2: " + IntegerToString(Periodo_Hull_2) +
   "\nOpen: " + DoubleToString(open) + " >>> " + IntegerToString(P_StopProfit_CT_4H)+
   "\nLotti: " + DoubleToString(PrimaEntrata,2));
}

//+------------------------------------------------------------------+
//|                      Elimina EA dal grafico                      |
//+------------------------------------------------------------------+

void CK_Chiusura_EA()
{
   GetAllTradingValues();
   
   if(PositionGetInteger(POSITION_MAGIC) ==MagicN && LottiinPancia==0)
      {
      Print("EA Tolto x chiusura totale posizini...");
      ExpertRemove();   
      }
}