//+------------------------------------------------------------------+
//|                                                nikosmakris89.mq4 |
//|                               CopyRight 2023 Author Daniel Makau |
//|                                              dmakas306@gmail.com |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//|                                                     Template.mq4 |
//|                                    Copyright 2022, Daniel Makau. |
//|                                              dmakas306@gmail.com |
//+------------------------------------------------------------------+
#property copyright "WhatsApp Programmer +254770848068"
#property link      "dmakas306@gmail.com"
#property version   "1.00"
#property strict
enum LOTSTYPE
  {
   FixedLots,//Fixed Lots
   DynamicLots,//Dynamic Lots
  };
enum TRADETYPE
  {
   BuySell,//Buys and Sells
   Buys,Sells
  };
input             string EA ="=============EXPERT ADVISOR SETTINGS=============";//============================
input             int MagicNo=329;//Magic Number
input             int MaxTrades=1;//Maximum Trades
input             TRADETYPE TradeType=BuySell;//TradeType
input             LOTSTYPE LotsType=FixedLots;
input             double Lots=0.01;//Fixed Lots 
input             double Risk=2;//Risk % for Dynamic Lots
input             double SL=10;//SL in Pips
input             double TP=5;//TP Multiple
input             string BuyTradeOpenTime="22:59:58";//Buy Trade Open Time
input             string SellTradeOpenTime="22:59:56";//Sell Trade Close Time
input             string TradeCloseTime="10:00:00";//Trade Closing Time
input             bool Trail=false;//Use Trail SL
input             double trailstep=2;//Trail Step Multiple

input             string EA2 ="=============EXPERT ADVISOR SETTINGS=============";//============================
input             bool TradeMon=true;//Trade on Monday
input             bool TradeTue=true;//Trade on Tuesday
input             bool TradeWed=true;//Trade on Wednesday
input             bool TradeThur=true;//Trade on Thursday
input             bool TradeFri=true;//Trade on Friday
input             bool TradeSat=true;//Trade on Sat
input             bool TradeSun=true;//Trade on Sun

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
double pt;
int Shift=0;
datetime LastCheck;
bool AllowBuy,AllowSells;

int OnInit()
  {
//---
   pt=Point();
   if(Digits==1||Digits==3||Digits==5)
      pt=Point()*10;
   EventSetMillisecondTimer(500);
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---
   EventKillTimer(); 
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTimer()
  {
   string nowtime=TimeToString(TimeCurrent(),TIME_MINUTES|TIME_SECONDS);
   
   bool allowtrade=AllowTrade();
   if(AllowBuy&&(TradeType==BuySell||TradeType==Buys)&&nowtime==SubtractSeconds(BuyTradeOpenTime))
     {
      if((TradeSun&&DayOfWeek()==0)||(TradeMon&&DayOfWeek()==1)||(TradeTue&&DayOfWeek()==2)||(TradeWed&&DayOfWeek()==3)||(TradeThur&&DayOfWeek()==4)||
      (TradeFri&&DayOfWeek()==5)||(TradeSat&&DayOfWeek()==6)||(TradeSun&&DayOfWeek()==7))
        {
         TradeOpen(1);
        }
     }
   if(AllowSells&&(TradeType==BuySell||TradeType==Sells)&&nowtime==SubtractSeconds(SellTradeOpenTime))
     {
      if((TradeSun&&DayOfWeek()==0)||(TradeMon&&DayOfWeek()==1)||(TradeTue&&DayOfWeek()==2)||(TradeWed&&DayOfWeek()==3)||(TradeThur&&DayOfWeek()==4)||
      (TradeFri&&DayOfWeek()==5)||(TradeSat&&DayOfWeek()==6)||(TradeSun&&DayOfWeek()==7))
        {
         TradeOpen(-1);
        }
     }
   
   if(nowtime==tradeclosingtime())
     {
      TradeClose(0);
     }
  }

/*void OnTick()
  {
   if(IsTesting())
     {
      datetime NOW=TimeCurrent();
      if(NOW>=AllowedUntil) {Comment("AM SORRY THE EA HAS EXPIRED. PLEASE CONTACT THE PROGRAMMER,DANIEL, FOR ASSISTANCE"); return;}
      
      int hours = TimeHour(TimeCurrent());
      int minutes = TimeMinute(TimeCurrent());
      int seconds = TimeSeconds(TimeCurrent());
      
      string nowtime=TimeToString(TimeCurrent(),TIME_MINUTES);
      
      if(AllowTrade()&&nowtime>=SubtractSeconds(SecBeforeClose))
        {
         TradeOpen(1);
         TradeOpen(-1);
        }
     }
  }*/
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool AllowTrade()
  {
   int Orders=0;
   bool OpenTrade=true;
   AllowBuy=true; AllowSells=true;
   
   for(int i=OrdersTotal()-1; i>=0; i--)
     {
      if(OrderSelect(i,SELECT_BY_POS))
        {
         if(OrderSymbol()==Symbol()&&OrderMagicNumber()==MagicNo)
           {
            Orders++;
            if(OpenTrade&&OrderOpenTime()>=Time[0]) 
               {
                OpenTrade=false;
                if(OrderType()==OP_BUY) AllowBuy=false;
                if(OrderType()==OP_SELL) AllowSells=false;
               }
            int ticket=OrderTicket();
            
            if(OrderType()==OP_BUY&&Trail)
              {
               trail(OrderTicket(),1);
               
              }
              else if(OrderType()==OP_SELL&&Trail)
                     {
                      trail(OrderTicket(),-1);
                      
                     }
           }
        }
     }
   for(int i=OrdersHistoryTotal()-1; i>=0; i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_HISTORY))
        {
         if(OrderSymbol()==Symbol()&&OrderMagicNumber()==MagicNo)
           {
            int t=OrderTicket();
            if(OpenTrade&&OrderOpenTime()>=Time[0])
              {
               OpenTrade=false;
               if(OrderType()==OP_BUY) AllowBuy=false;
               if(OrderType()==OP_SELL) AllowSells=false;
               break;
              }
            else if(OrderOpenTime()<Time[0]) break;

           }
        }
     }
   if(Orders>=MaxTrades) OpenTrade=false;
   
   return OpenTrade;
  }

void TradeOpen(int Pos)
  {
   if(Pos==1)
     {
      double sl=Ask-(SL*pt), slrange=MathAbs(Ask-sl),tp=0;
      if(SL==0) { sl=0; slrange=0;}
      if(slrange!=0&&TP!=0) tp=Ask+(slrange*TP);
      
      int t=OrderSend(Symbol(),OP_BUY,GetLots(slrange),Ask,3,sl,tp,NULL,MagicNo,0,clrBlue);
     }
     else
       {
        double sl=Bid+(SL*pt), slrange=MathAbs(Bid-sl), tp=0;
        if(SL==0) { sl=0; slrange=0;  }
        if(slrange!=0&&TP!=0) tp=Bid-(TP*slrange);
        
        int t=OrderSend(Symbol(),OP_SELL,GetLots(slrange),Bid,3,sl,tp,NULL,MagicNo,0,clrRed);
       }
  }
string SubtractSeconds(string opentime)
{
   // Parse the input time string
   int hours = StringToInteger(StringSubstr(opentime, 0, 2));
   int minutes = StringToInteger(StringSubstr(opentime, 3, 2));
   int seconds = StringToInteger(StringSubstr(opentime, 6, 2));

   // Format the result as HH:MM:SS
   return StringFormat("%02d:%02d:%02d", hours, minutes, seconds);
}

string tradeclosingtime()
{
   // Parse the input time string
   int hours = StringToInteger(StringSubstr(TradeCloseTime, 0, 2));
   int minutes = StringToInteger(StringSubstr(TradeCloseTime, 3, 2));
   int seconds = StringToInteger(StringSubstr(TradeCloseTime, 6, 2));

   // Format the result as HH:MM:SS
   return StringFormat("%02d:%02d:%02d", hours, minutes, seconds);
}

double GetLots(double stopl)
  {
   if(LotsType==FixedLots) return(Lots);
   if(SL==0||stopl==0) return(Lots);
   double LotSize=MarketInfo(Symbol(),MODE_MINLOT); int lotdavid=0;
   double acRisk=0;
   
   if(LotSize==0.1) lotdavid=1;
   else if(LotSize==0.01) lotdavid=2;
   acRisk=(Risk*AccountBalance())/100;
   
   double units=MarketInfo(Symbol(),MODE_TICKVALUE)/MarketInfo(Symbol(),MODE_TICKSIZE);
   double cbtickvalue=acRisk/(stopl*units);
   LotSize=NormalizeDouble(cbtickvalue,lotdavid);
   
   if(LotSize<MarketInfo(Symbol(),MODE_MINLOT)) LotSize=MarketInfo(Symbol(),MODE_MINLOT);
   if(LotSize>MarketInfo(Symbol(),MODE_MAXLOT)) LotSize=MarketInfo(Symbol(),MODE_MAXLOT);
   return(LotSize);
  }

void trail(int ticket,int Pos)
  {
   if(Pos==1&&OrderSelect(ticket,SELECT_BY_TICKET))
     {
      int Step=(int)((Bid-OrderOpenPrice())/(SL*pt));
      if(Step>=1)
        {
         Step=Step-1;
         double sldist=Step*SL*pt;
         double NewSL=NormalizeDouble(OrderOpenPrice()+sldist,Digits); 
         
         if(OrderStopLoss()<NewSL)
           {
            bool t=OrderModify(OrderTicket(),0,NewSL,OrderTakeProfit(),0,clrNONE);
           }
        }
     }
     else if(Pos==-1&&OrderSelect(ticket,SELECT_BY_TICKET))
            {
             int Step=(int)((OrderOpenPrice()-Ask)/(SL*pt));
             if(Step>=1)
               {
                Step=Step-1;
                double sldist=Step*SL*pt;
                double NewSL=NormalizeDouble(OrderOpenPrice()-sldist,Digits);
                
                if(OrderStopLoss()==0||OrderStopLoss()>NewSL)
                  {
                   bool t=OrderModify(OrderTicket(),0,NewSL,OrderTakeProfit(),0,clrNONE);
                  }
               }
            }
  }

void TradeClose(int Pos)
  {
   for(int i=OrdersTotal()-1;i>=0;i--)
     {
      if(OrderSelect(i,SELECT_BY_POS))
        {
         if(OrderMagicNumber()==MagicNo&&OrderSymbol()==Symbol())
           {
            if((Pos==1||Pos==0)&&OrderType()==OP_BUY)
              {
               bool t=OrderClose(OrderTicket(),OrderLots(),Bid,3,clrRed);
              }
              if((Pos==-1||Pos==0)&&OrderType()==OP_SELL)
                {
                 bool t=OrderClose(OrderTicket(),OrderLots(),Ask,3,clrRed);
                }
           }
        }
     }
  }