#property copyright   ""                                                                  // copyright
#property version     ""                                                                  // Version
#property description "This Expert Advisor is strength of symbols & trade accordingly"    // Description
#property strict

//--- input parameters
extern double xx=0.3;
extern double aa=0.1;


extern double TradingLots=0.01;
extern int  TakeProfit= 10; //Take Profit (in Pips)
extern int  StopLoss= 150; //StopLoss (in Pips)
extern bool UseSLTP = true;
extern bool TradeOnce=true; // Trade Once (per Day)
extern string prefix="";
extern string postfix="";
 // Difference Between Two Currencies Percentage
extern int Magic=135999; // Magic Number
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+


int start()
{
RefreshRates();
/*
USDCHF, GBPUSD, EURUSD, USDJPY, USDCAD, NZDUSD, AUDUSD, AUDNZD, AUDCAD, AUDCHF, AUDJPY, CHFJPY, EURGBP, EURAUD,

EURCHF, EURJPY, EURNZD, EURCAD, GBPCHF, GBPAUD, GBPCAD, GBPJPY, CADJPY, NZDJPY, GBPNZD, CADCHF
*/

   double USDJPY = perch(prefix+"USDJPY"+postfix);
   double USDCAD = perch(prefix+"USDCAD"+postfix);
   double AUDUSD = perch(prefix+"AUDUSD"+postfix);
   double USDCHF = perch(prefix+"USDCHF"+postfix);
   double GBPUSD = perch(prefix+"GBPUSD"+postfix);
   double EURUSD = perch(prefix+"EURUSD"+postfix);
   double NZDUSD = perch(prefix+"NZDUSD"+postfix);
   double EURJPY = perch(prefix+"EURJPY"+postfix);
   double EURCAD = perch(prefix+"EURCAD"+postfix);
   double EURGBP = perch(prefix+"EURGBP"+postfix);
   double EURCHF = perch(prefix+"EURCHF"+postfix);
   double EURAUD = perch(prefix+"EURAUD"+postfix);
   double EURNZD = perch(prefix+"EURNZD"+postfix);
   double AUDNZD = perch(prefix+"AUDNZD"+postfix);
   double AUDCAD = perch(prefix+"AUDCAD"+postfix);
   double AUDCHF = perch(prefix+"AUDCHF"+postfix);
   double AUDJPY = perch(prefix+"AUDJPY"+postfix);
   double CHFJPY = perch(prefix+"CHFJPY"+postfix);
   double GBPCHF = perch(prefix+"GBPCHF"+postfix);
   double GBPAUD = perch(prefix+"GBPAUD"+postfix);
   double GBPCAD = perch(prefix+"GBPCAD"+postfix);
   double GBPJPY = perch(prefix+"GBPJPY"+postfix);
   double CADJPY = perch(prefix+"CADJPY"+postfix);
   double NZDJPY = perch(prefix+"NZDJPY"+postfix);
   double GBPNZD = perch(prefix+"GBPNZD"+postfix);
   double CADCHF = perch(prefix+"CADCHF"+postfix);

double eur = (EURJPY+EURCAD+EURGBP+EURCHF+EURAUD+EURUSD+EURNZD)/7;
   double usd = (USDJPY+USDCAD-AUDUSD+USDCHF-GBPUSD-EURUSD-NZDUSD)/7;
   double jpy = (-1*(USDJPY+EURJPY+AUDJPY+CHFJPY+GBPJPY+CADJPY+NZDJPY))/7;
   double cad = (CADCHF+CADJPY-(GBPCAD+AUDCAD+EURCAD+USDCAD))/6;
   double aud = (AUDUSD+AUDNZD+AUDCAD+AUDCHF+AUDJPY-(EURAUD+GBPAUD))/7;
   double nzd = (NZDUSD+NZDJPY-(EURNZD+AUDNZD+GBPNZD))/5;
   double gbp = (GBPUSD-EURGBP+GBPCHF+GBPAUD+GBPCAD+GBPJPY+GBPNZD)/7;
   double chf = (CHFJPY-(USDCHF+EURCHF+AUDCHF+GBPCHF+CADCHF))/6;
   
  

   eur = NormalizeDouble(eur,2);
   usd = NormalizeDouble(usd,2);
   jpy = NormalizeDouble(jpy,2);
   cad = NormalizeDouble(cad,2);
   aud = NormalizeDouble(aud,2);
   nzd = NormalizeDouble(nzd,2);
   gbp = NormalizeDouble(gbp,2);
   chf = NormalizeDouble(chf,2);

   Comment("\n\n\n\n\n\n\n\n\n\n\nEUR: "+DoubleToStr(eur,2)+"\nUSD: "+DoubleToStr(usd,2)+"\nJPY: "+DoubleToStr(jpy,2)+"\nCAD: "+DoubleToStr(cad,2)+"\nAUD: "+DoubleToStr(aud,2)+"\nNZD: "+DoubleToStr(nzd,2)+"\nGBP: "+DoubleToStr(gbp,2)+"\nCHF: "+DoubleToStr(chf,2));

   
   
   
   if(eur>=xx)
    if(usd<=-aa)
        
   {
     Trade("Buy",prefix+"EURUSD"+postfix);
     }
     if(eur>=xx)
     if(jpy<=-aa)
     {
     Trade("Buy",prefix+"EURJPY"+postfix);
     }
     if(eur>=xx)
     if(gbp<=-aa)
     {
     Trade("Buy",prefix+"EURGBP"+postfix);
     }
     if(eur>=xx)
     if(nzd<=-aa)
     {
     Trade("Buy",prefix+"EURNZD"+postfix);
     }
     if(eur>=xx)
     if(cad<=-aa)
     {
     Trade("Buy",prefix+"EURCAD"+postfix);
     }
     if(eur>=xx)
     if(chf<=-aa)
     {
     Trade("Buy",prefix+"EURCHF"+postfix);
     }
     if(eur>=xx)
     if(aud<=-aa)
     {
     Trade("Buy",prefix+"EURAUD"+postfix);
  
  
   }
 
  
    if(eur<=-xx)
    
    if(usd>=aa)
        
      
   {
     Trade("Sell",prefix+"EURUSD"+postfix);
      }
     if(eur<=-xx)
     if(jpy>=aa)
    {
     Trade("Sell",prefix+"EURJPY"+postfix);
     }
     if(eur<=-xx)
     if(gbp>=aa)
     {
     Trade("Sell",prefix+"EURGBP"+postfix);
     }
     if(eur<=-xx)
     if(nzd>=aa)
     {
     Trade("Sell",prefix+"EURNZD"+postfix);
     }
     if(eur<=-xx)
     if(cad>=aa)
     {
     Trade("Sell",prefix+"EURCAD"+postfix);
     }
     if(eur<=-xx)
     if(chf>=aa)
     {
     Trade("Sell",prefix+"EURCHF"+postfix);
     }
     if(eur<=-xx)
     if(aud>=aa)
     {
     Trade("Sell",prefix+"EURAUD"+postfix);
  
   }
  
  
   
    if(gbp>=xx)
    if(usd<=-aa)
    
   {
     Trade("Buy",prefix+"GBPUSD"+postfix);
     }
     if(gbp>=xx)
     if(jpy<=-aa)
     {
     Trade("Buy",prefix+"GBPJPY"+postfix);
     }
     
     if(gbp>=xx)
     if(nzd<=-aa)
     {
     Trade("Buy",prefix+"GBPNZD"+postfix);
     }
     if(gbp>=xx)
     if(cad<=-aa)
     {
     Trade("Buy",prefix+"GBPCAD"+postfix);
     }
     if(gbp>=xx)
     if(chf<=-aa)
     {
     Trade("Buy",prefix+"GBPCHF"+postfix);
     }
     if(gbp>=xx)
     if(aud<=-aa)
     {
     Trade("Buy",prefix+"GBPAUD"+postfix);
  
   }
  
    if(gbp<=-xx)
    if(usd>=aa)
   {
     Trade("Sell",prefix+"GBPUSD"+postfix);
     }
     if(gbp<=-xx)
     if(jpy>=aa)
     {
     Trade("Sell",prefix+"GBPJPY"+postfix);
     }
     
     if(gbp<=-xx)
     if(nzd>=aa)
     {
     Trade("Sell",prefix+"GBPNZD"+postfix);
     }
     if(gbp<=-xx)
     if(cad>=aa)
     {
     Trade("Sell",prefix+"GBPCAD"+postfix);
     }
     if(gbp<=-xx)
     if(chf>=aa)
     {
     Trade("Sell",prefix+"GBPCHF"+postfix);
     }
     if(gbp<=-xx)
     if(aud>=aa)
     {
     Trade("Sell",prefix+"GBPAUD"+postfix);
  
   }
   
   if(usd>=xx)
   if(chf<=-aa)
   
   {
   
   Trade("Buy",prefix+"USDCHF"+postfix);
   }
   if(usd>=xx)
   if(jpy<=-aa)
   {
     Trade("Buy",prefix+"USDJPY"+postfix);
     }
     if(usd>=xx)
     if(cad<=-aa)
     {
     Trade("Buy",prefix+"USDCAD"+postfix);
     }
     if(usd>=xx)
     if(eur<=-aa)
     {
     Trade("Sell",prefix+"EURUSD"+postfix);
     }
     if(usd>=xx)
     if(gbp<=-aa)
     {
     Trade("Sell",prefix+"GBPUSD"+postfix);
     }
     if(usd>=xx)
     if(nzd<=-aa)
     {
     Trade("Sell",prefix+"NZDUSD"+postfix);
     }
     if(usd>=xx)
     if(aud<=-aa)
     {
     Trade("Sell",prefix+"AUDUSD"+postfix);
   
    }
   
   
   
  if(usd<=-xx)
  if(chf>=aa)
  
 
   {
   
   Trade("Sell",prefix+"USDCHF"+postfix);
   }
   
   if(usd<=-xx)
   if(jpy>=aa)
   
   {
     Trade("Sell",prefix+"USDJPY"+postfix);
     }
     if(usd<=-xx)
     if(cad>=aa)
     {
     Trade("Sell",prefix+"USDCAD"+postfix);
     }
     if(usd<=-xx)
     if(eur>=xx)
     {
     Trade("Buy",prefix+"EURUSD"+postfix);
     }
     if(usd<=-xx)
     if(gbp>=aa)
     {
     Trade("Buy",prefix+"GBPUSD"+postfix);
     }
     if(usd<=-xx)
     if(nzd>=aa)
     {
     Trade("Buy",prefix+"NZDUSD"+postfix);
     }
     if(usd<=-xx)
     if(aud>=aa)
     {
     Trade("Buy",prefix+"AUDUSD"+postfix);
   
    }
    
    
     
     
     if(aud<=-xx)
     if(usd>=aa)
     {
     
     Trade("Sell",prefix+"AUDUSD"+postfix);
     }
     
     if(nzd>=xx)
     if(usd<=-aa)
     
     {
     Trade("Buy",prefix+"NZDUSD"+postfix);
     
     
     }
     
     if(nzd<=-xx)
       if(usd>=aa)
     
     {
     Trade("Sell",prefix+"NZDUSD"+postfix);
     }
     if(cad<=-xx)
     
     if(usd>=aa)
     
     {     
     Trade("Buy",prefix+"USDCAD"+postfix);
     }
     
    if(cad>=aa)
    
     if(usd<=-xx)
     {
     Trade("Sell",prefix+"USDCAD"+postfix);
     }
     
     
     
     
     
     
   
     
     
     

   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   return(0);
  }
//+------------------------------------------------------------------+
//|            CALCULATING PERCENTAGE Of SYMBOLS                                                      |
//+------------------------------------------------------------------+
double perch(string sym)
  {RefreshRates();
   double op = iOpen(sym,PERIOD_D1,0);
   double cl = iClose(sym,PERIOD_D1,0);

   double per=0;
   if(op!=0 && cl!=0) //This solves the problem of Zero Divide
   {
      per = (cl-op)/op*100;
   }

   per=NormalizeDouble(per,2);
   
   return(per);
  }
//+------------------------------------------------------------------+
//|               TRADE EXECUTION FUNCTION
//+------------------------------------------------------------------+
int Trade(string signal,string symbol)
  {
   int Magic2=Magic+1;
   int count,count2=0;
   for(int pos=0; pos<=OrdersTotal(); pos++)
     {
      if(OrderSelect(pos,SELECT_BY_POS)
         && OrderMagicNumber()==Magic       //When Magic number is correct      
         && OrderSymbol()==symbol) // Only When Its of Chart Symbol
        {              // and my pair.
         count++; // Count the number of Positions in Order List Of Chart Symbol
        } //if ended

      if(OrderSelect(pos,SELECT_BY_POS)
         && OrderMagicNumber()==Magic2
         && OrderSymbol()==symbol)
        {              // and my pair.
         count2++; // Count the number of Positions in Order List Of Chart Symbol
        } //if ended
     }//for ended

   double bid = MarketInfo(symbol,MODE_BID);
   double ask = MarketInfo(symbol,MODE_ASK);
   double point=MarketInfo(symbol,MODE_POINT);
   double digits=MarketInfo(symbol,MODE_DIGITS);

   double op = iOpen(symbol,PERIOD_D1,0);
   double cl = iClose(symbol,PERIOD_D1,0);

   int    Cur_Hour=Hour();             // Server time in hours
   double Cur_Min =Minute();           // Server time in minutes
   double Cur_time=Cur_Hour+(Cur_Min)/100; // Current time

   bool TradeTime=Cur_time>0.10 && Cur_time<23;

   int TodaySeconds=(Hour()*3600)+(Minute()*60)+Seconds();
   int YesterdayEnd=TimeCurrent()-TodaySeconds;
   int YesterdayStart=YesterdayEnd-86400;

   if(TradeOnce==true)
     {
      for(int h=OrdersHistoryTotal()-1;h>=0;h--) // Trade Once per Pair
        {
         if(OrderSelect(h,SELECT_BY_POS,MODE_HISTORY)==true) // select next
           {
            if(OrderCloseTime()>YesterdayEnd && OrderSymbol()==symbol && OrderMagicNumber()==Magic)
              {
               signal="NoTrade";
              }

            if(OrderCloseTime()>YesterdayEnd && OrderSymbol()==symbol && OrderMagicNumber()==Magic2)
              {
               signal="NoTrade";
              }
           }
        }
     }
     
bool result_buy, result_sell=false;

   if(!count && TradeTime)
     {

      if(signal=="Buy" && op<cl && CheckVolumeValue(TradingLots,symbol))
        {
         result_buy=OrderSend(symbol,OP_BUY,TradingLots,ask,0,0,0,"Buy-ss1",Magic,0,Green);
         if(result_buy==true)
         {
            //Alert(symbol+"-Buy Order ss.1");
         }
        }
     }

   if(!count2 && TradeTime)
     {
      if(signal=="Sell" && op>cl && CheckVolumeValue(TradingLots,symbol))
        {
         result_sell=OrderSend(symbol,OP_SELL,TradingLots,bid,0,0,0,"Sell-ss2",Magic2,0,Red);
         if(result_sell==true)
         {
            //Alert(symbol+"-Buy Order ss.2");
         }
        }

     }// If Ended

   if(OrdersTotal()>0)
     {
      for(int i=1; i<=OrdersTotal(); i++) // Cycle searching in orders
        {
         if(OrderSelect(i-1,SELECT_BY_POS)==true && OrderSymbol()==symbol)
           {
            double tpb=NormalizeDouble(OrderOpenPrice()+TakeProfit*point*10,digits);
            double tps=NormalizeDouble(OrderOpenPrice()-TakeProfit*point*10,digits);
            
            double slb=NormalizeDouble(OrderOpenPrice()-StopLoss*point*10,digits);
            double sls=NormalizeDouble(OrderOpenPrice()+StopLoss*point*10,digits);
            
            if(TakeProfit==0)
            {
               tpb = 0;
               tps = 0;
            }
            if(StopLoss==0)
            {
               slb = 0;
               sls = 0;
            }

            if(OrderMagicNumber()==Magic && OrderType()==OP_BUY && (OrderTakeProfit()!=tpb || OrderStopLoss()!=slb) && OrderSymbol()==symbol && UseSLTP==true)
              {
               OrderModify(OrderTicket(),0,slb,tpb,0,CLR_NONE);
               Alert(symbol+"-Buy ==> TP: "+DoubleToStr(tpb,5)+" || SL: "+DoubleToStr(slb,5)+" <==");
              }

            if(OrderMagicNumber()==Magic2 && OrderType()==OP_SELL && (OrderTakeProfit()!=tps || OrderStopLoss()!=sls) && OrderSymbol()==symbol && UseSLTP==true)
              {
               OrderModify(OrderTicket(),0,sls,tps,0,CLR_NONE);
               Alert(symbol+"-Sell ==> TP: "+DoubleToStr(tps,5)+" || SL: "+DoubleToStr(sls,5)+" <==");
              }
           }//Nested-if Ended
        }//for loop ended
     }//if Ended

   return(0);

  }
//+------------------------------------------------------------------+
bool CheckVolumeValue(double volume,string sym)
  {
//--- minimal allowed volume for trade operations
   double min_volume=SymbolInfoDouble(sym,SYMBOL_VOLUME_MIN);
   if(volume<min_volume)
     {
      return(false);
     }

//--- maximal allowed volume of trade operations
   double max_volume=SymbolInfoDouble(sym,SYMBOL_VOLUME_MAX);
   if(volume>max_volume)
     {
      return(false);
     }

//--- get minimal step of volume changing
   double volume_step=SymbolInfoDouble(sym,SYMBOL_VOLUME_STEP);

   int ratio=(int)MathRound(volume/volume_step);
   if(MathAbs(ratio*volume_step-volume)>0.0000001)
     {
      return(false);
     }
   return(true);
  }