//+------------------------------------------------------------------+
//| ICT + SMC ALL IN ONE FINAL EA (MT5)                               |
//+------------------------------------------------------------------+
#property strict
#include <Trade/Trade.mqh>
CTrade trade;

//================ INPUTS ===================
input double LotSize = 0.1;
input double RR = 2.0;
input int MaxSpreadPoints = 300;
input int BufferPoints = 20;
input bool UseKillZones = true;
input int MaxTradesPerDay = 1;

//================ GLOBAL ===================
bool PartialDone=false;
int TradesToday=0;
datetime TradeDay=0;

//================ UTILS ====================
bool IsTradeOpen(){ return PositionSelect(_Symbol); }

bool SpreadOK(){
       return SymbolInfoInteger(_Symbol,SYMBOL_SPREAD)<=MaxSpreadPoints;
}

bool KillZoneOK(){
       if(!UseKillZones) return true;
          int h=TimeHour(TimeCurrent());
             return (h>=7 && h<=10)||(h>=13 && h<=16);
}

bool DailyLimitOK(){
       datetime d=Date();
          if(d!=TradeDay){ TradesToday=0; TradeDay=d; }
             return TradesToday<MaxTradesPerDay;
}

//================ HTF ======================
bool HTFBullish(){
       return iClose(_Symbol,PERIOD_H1,1)>
                 iOpen(_Symbol,PERIOD_H1,1);
}
bool HTFBearish(){
       return iClose(_Symbol,PERIOD_H1,1)<
                 iOpen(_Symbol,PERIOD_H1,1);
}

//================ PD =======================
bool InDiscount(){
       double h=iHigh(_Symbol,PERIOD_H1,1);
          double l=iLow(_Symbol,PERIOD_H1,1);
             return SymbolInfoDouble(_Symbol,SYMBOL_BID)<(h+l)/2;
}
bool InPremium(){
       double h=iHigh(_Symbol,PERIOD_H1,1);
          double l=iLow(_Symbol,PERIOD_H1,1);
             return SymbolInfoDouble(_Symbol,SYMBOL_ASK)>(h+l)/2;
}

//================ LIQUIDITY ================
bool EqualHighs(){
       return MathAbs(iHigh(_Symbol,PERIOD_M5,1)-
                         iHigh(_Symbol,PERIOD_M5,2))<=10*_Point;
}
bool EqualLows(){
       return MathAbs(iLow(_Symbol,PERIOD_M5,1)-
                         iLow(_Symbol,PERIOD_M5,2))<=10*_Point;
}
bool SweepHigh(){
       return iHigh(_Symbol,PERIOD_M5,0)>
                 iHigh(_Symbol,PERIOD_M5,1);
}
bool SweepLow(){
       return iLow(_Symbol,PERIOD_M5,0)<
                 iLow(_Symbol,PERIOD_M5,1);
}

//================ CHOCH ====================
bool BullishCHoCH(){
       return iClose(_Symbol,PERIOD_M5,1)>
                 iHigh(_Symbol,PERIOD_M5,2);
}
bool BearishCHoCH(){
       return iClose(_Symbol,PERIOD_M5,1)<
                 iLow(_Symbol,PERIOD_M5,2);
}

//================ FVG ======================
bool BullishFVG(double &lvl){
       if(iHigh(_Symbol,PERIOD_M5,3)<
             iLow(_Symbol,PERIOD_M5,1)){
                      lvl=iHigh(_Symbol,PERIOD_M5,3);
                            return true;
             }
                return false;
}
bool BearishFVG(double &lvl){
       if(iLow(_Symbol,PERIOD_M5,3)>
             iHigh(_Symbol,PERIOD_M5,1)){
                      lvl=iLow(_Symbol,PERIOD_M5,3);
                            return true;
             }
                return false;
}

//================ MANAGEMENT ===============
void ManageTrade(){
       if(!PositionSelect(_Symbol)) return;
          double entry=PositionGetDouble(POSITION_PRICE_OPEN);
             double sl=PositionGetDouble(POSITION_SL);
                double tp=PositionGetDouble(POSITION_TP);
                   double price=SymbolInfoDouble(_Symbol,SYMBOL_BID);
                      double vol=PositionGetDouble(POSITION_VOLUME);
                         long type=PositionGetInteger(POSITION_TYPE);

                            if(type==POSITION_TYPE_BUY){
                                      double rr1=entry+(entry-sl);
                                            if(price>=rr1 && !PartialDone){
                                                         trade.PositionClosePartial(_Symbol,vol/2);
                                                                  trade.PositionModify(_Symbol,entry,tp);
                                                                           PartialDone=true;
                                            }
                            }else{
                                      double rr1=entry-(sl-entry);
                                            if(price<=rr1 && !PartialDone){
                                                         trade.PositionClosePartial(_Symbol,vol/2);
                                                                  trade.PositionModify(_Symbol,entry,tp);
                                                                           PartialDone=true;
                                            }
                            }
}

//================ MAIN =====================
void OnTick(){
       ManageTrade();
          if(IsTradeOpen()) return;
             if(!SpreadOK()||!KillZoneOK()||!DailyLimitOK()) return;

                double bid=SymbolInfoDouble(_Symbol,SYMBOL_BID);
                   double ask=SymbolInfoDouble(_Symbol,SYMBOL_ASK);

                      // BUY
                         if(HTFBullish()&&InDiscount()&&
                               EqualLows()&&SweepLow()&&BullishCHoCH()){
                                      double fvg;
                                            if(BullishFVG(fvg)&&bid<=fvg+BufferPoints*_Point){
                                                         double sl=fvg-BufferPoints*_Point;
                                                                  double tp=bid+(bid-sl)*RR;
                                                                           if(trade.Buy(LotSize,_Symbol,ask,sl,tp)){
                                                                                        TradesToday++; PartialDone=false;
                                                                           }
                                            }
                               }

                                  // SELL
                                     if(HTFBearish()&&InPremium()&&
                                           EqualHighs()&&SweepHigh()&&BearishCHoCH()){
                                                  double fvg;
                                                        if(BearishFVG(fvg)&&ask>=fvg-BufferPoints*_Point){
                                                                     double sl=fvg+BufferPoints*_Point;
                                                                              double tp=ask-(sl-ask)*RR;
                                                                                       if(trade.Sell(LotSize,_Symbol,bid,sl,tp)){
                                                                                                    TradesToday++; PartialDone=false;
                                                                                       }
                                                        }
                                           }
}
                                                                                       }
                                                        }
                                           }
                                                                           }
                                            }
                               }
}
                                            }
                            }
                                            }
                            }
}
             }
}
             }
}
}
}
}
}
}
}
}
}
}
}
}
}
}