//+------------------------------------------------------------------+
//|  GOLD_AMD_Liquidity.mq5                                          |
//|  Strategy : AMD (Accumulation-Manipulation-Distribution)         |
//|             + Judas Swing + Equal Highs/Lows Liquidity Sweep     |
//|  Pair     : XAUUSD (Gold)                                        |
//|  PropFirm : FundedNext / FundingPips / The5ers / FTMO compatible |
//|  Author   : Institutional EA Framework v1.0                      |
//+------------------------------------------------------------------+
#property copyright "Institutional EA Framework"
#property version   "1.00"
#property strict

#include <Trade\Trade.mqh>
#include <Trade\PositionInfo.mqh>

CTrade        trade;
CPositionInfo posInfo;

//==========================================================================
// INPUT PARAMETERS
//==========================================================================

// --- Risk Management ---
input double   RiskPercent       = 0.5;    // Risk per trade (% of balance)
input double   DailyDrawdownLimit= 4.0;    // Max daily DD % (PropFirm safe)
input double   MaxDrawdownLimit  = 8.0;    // Max total DD % (PropFirm safe)
input double   TP1_RR            = 1.5;    // TP1 Risk:Reward ratio
input double   TP2_RR            = 3.0;    // TP2 Risk:Reward ratio
input double   TP1_ClosePct      = 50.0;   // % of position to close at TP1

// --- AMD Session Times (Server Time) ---
input int      AccumStart_Hour   = 2;      // Accumulation phase start (Asia)
input int      AccumEnd_Hour     = 7;      // Accumulation phase end
input int      ManipStart_Hour   = 7;      // Manipulation/Judas Swing (London)
input int      ManipEnd_Hour     = 9;      // Manipulation end
input int      DistribStart_Hour = 13;     // Distribution phase (NY)
input int      DistribEnd_Hour   = 16;     // Distribution end
input int      NoTradeHour_Start = 22;     // No new trades after this hour
input int      NoTradeHour_End   = 1;      // No new trades before this hour

// --- Liquidity Sweep Config ---
input int      LiqSweepLookback  = 20;     // Bars to look back for equal H/L
input double   EqualLevelTolerance= 0.5;   // Pips tolerance for "equal" levels
input int      SweepConfirmBars  = 2;      // Bars after sweep to confirm rejection

// --- News Filter ---
input bool     NewsFilter        = true;   // Enable high-impact news filter
input int      NewsMinutesBefore = 30;     // Minutes before news — no trade
input int      NewsMinutesAfter  = 30;     // Minutes after news — no trade

// --- Execution ---
input int      SlippagePoints    = 30;     // Max slippage (points)
input int      MagicNumber       = 2401;   // Unique magic number
input string   TelegramBotToken  = "";     // Telegram Bot Token
input string   TelegramChatID    = "";     // Telegram Chat ID

// --- Display ---
input bool     ShowDashboard     = true;   // Show on-chart info panel

//==========================================================================
// GLOBAL VARIABLES
//==========================================================================

double   g_DayStartBalance    = 0;
double   g_InitialBalance     = 0;
datetime g_LastTradeDay       = 0;
datetime g_LastBarTime        = 0;
bool     g_TP1Hit             = false;
ulong    g_TicketMain         = 0;

// Liquidity levels
double   g_EqualHighs[];
double   g_EqualLows[];
int      g_EqHighCount        = 0;
int      g_EqLowCount         = 0;

// AMD State
enum ENUM_AMD_PHASE { AMD_NONE, AMD_ACCUM, AMD_MANIP, AMD_DISTRIB };
ENUM_AMD_PHASE g_CurrentPhase = AMD_NONE;
bool     g_JudasSwingBullish  = false;  // true=price swept lows (bull trap), expect up
bool     g_JudasSwingBearish  = false;  // true=price swept highs (bear trap), expect down
double   g_SweptLevel         = 0;
double   g_EntryPrice         = 0;
double   g_SL                 = 0;
double   g_TP1                = 0;
double   g_TP2                = 0;
bool     g_SetupReady         = false;
string   g_SetupDirection     = "";

//==========================================================================
// INITIALIZATION
//==========================================================================

int OnInit()
{
   trade.SetExpertMagicNumber(MagicNumber);
   trade.SetDeviationInPoints(SlippagePoints);
   trade.SetTypeFilling(ORDER_FILLING_IOC);

   g_InitialBalance  = AccountInfoDouble(ACCOUNT_BALANCE);
   g_DayStartBalance = g_InitialBalance;
   g_LastTradeDay    = 0;

   Print("[AMD_EA] Initialized. Balance: ", g_InitialBalance,
         " | Magic: ", MagicNumber);
   SendTelegram("✅ GOLD AMD EA Started | Balance: $" +
                DoubleToString(g_InitialBalance, 2));
   return INIT_SUCCEEDED;
}

//==========================================================================
// TICK PROCESSING
//==========================================================================

void OnTick()
{
   // Only process on new bar (M15 chart recommended)
   datetime barTime = iTime(_Symbol, PERIOD_M15, 0);
   if(barTime == g_LastBarTime) return;
   g_LastBarTime = barTime;

   // Daily reset
   ResetDailyTracking();

   // Propfirm drawdown guardian
   if(IsDrawdownBreached()) return;

   // Session / time filter
   if(!IsTradingSessionActive()) return;

   // News filter
   if(NewsFilter && IsNewsTime()) return;

   // Update AMD phase
   UpdateAMDPhase();

   // Scan for liquidity levels
   ScanLiquidityLevels();

   // Check for Judas Swing + Sweep setup
   CheckJudasSwing();

   // If setup ready and no open position — execute
   if(g_SetupReady && !HasOpenPosition())
      ExecuteTrade();

   // Manage open positions (partial TP, trailing)
   ManageOpenPositions();

   // Dashboard update
   if(ShowDashboard) DrawDashboard();
}

//==========================================================================
// CORE: AMD PHASE DETECTION
//==========================================================================

void UpdateAMDPhase()
{
   int hour = TimeHour(TimeCurrent());

   if(hour >= AccumStart_Hour && hour < AccumEnd_Hour)
      g_CurrentPhase = AMD_ACCUM;
   else if(hour >= ManipStart_Hour && hour < ManipEnd_Hour)
      g_CurrentPhase = AMD_MANIP;
   else if(hour >= DistribStart_Hour && hour < DistribEnd_Hour)
      g_CurrentPhase = AMD_DISTRIB;
   else
      g_CurrentPhase = AMD_NONE;
}

//==========================================================================
// CORE: SCAN EQUAL HIGHS / EQUAL LOWS (Liquidity Pools)
//==========================================================================

void ScanLiquidityLevels()
{
   g_EqHighCount = 0;
   g_EqLowCount  = 0;
   ArrayResize(g_EqualHighs, 0);
   ArrayResize(g_EqualLows,  0);

   double tolerance = EqualLevelTolerance * _Point * 10;

   for(int i = LiqSweepLookback; i >= 2; i--)
   {
      double hi = iHigh(_Symbol, PERIOD_H1, i);
      double lo = iLow (_Symbol, PERIOD_H1, i);

      // Check if another bar within lookback has same high (±tolerance)
      for(int j = i - 1; j >= 1; j--)
      {
         double hi2 = iHigh(_Symbol, PERIOD_H1, j);
         double lo2 = iLow (_Symbol, PERIOD_H1, j);

         if(MathAbs(hi - hi2) <= tolerance)
         {
            ArrayResize(g_EqualHighs, g_EqHighCount + 1);
            g_EqualHighs[g_EqHighCount++] = hi;
            break;
         }
         if(MathAbs(lo - lo2) <= tolerance)
         {
            ArrayResize(g_EqualLows, g_EqLowCount + 1);
            g_EqualLows[g_EqLowCount++] = lo;
            break;
         }
      }
   }
}

//==========================================================================
// CORE: JUDAS SWING DETECTION
// Manipulation phase: price sweeps liquidity OPPOSITE to true direction
// Bull AMD: price dips below equal lows (sweeps sell-side) → then reverses UP
// Bear AMD: price spikes above equal highs (sweeps buy-side) → then reverses DOWN
//==========================================================================

void CheckJudasSwing()
{
   if(g_CurrentPhase != AMD_MANIP) return;
   if(HasOpenPosition()) return;

   g_SetupReady      = false;
   g_JudasSwingBullish = false;
   g_JudasSwingBearish = false;

   double currentLow  = iLow (_Symbol, PERIOD_M15, 1);
   double currentHigh = iHigh(_Symbol, PERIOD_M15, 1);
   double closePrice  = iClose(_Symbol, PERIOD_M15, 1);
   double openPrice   = iOpen (_Symbol, PERIOD_M15, 1);

   // --- BULLISH JUDAS: Swept sell-side liquidity (equal lows) ---
   for(int i = 0; i < g_EqLowCount; i++)
   {
      double lvl = g_EqualLows[i];
      // Price wicked below equal low (swept it) but closed ABOVE (rejection)
      if(currentLow < lvl && closePrice > lvl && closePrice > openPrice)
      {
         g_JudasSwingBullish = true;
         g_SweptLevel        = lvl;

         // Confirm: wait SweepConfirmBars bars for MSS (Market Structure Shift)
         if(IsMarketStructureShiftUp())
         {
            double sl   = currentLow - (10 * _Point * 10);
            double risk = sl > 0 ? MathAbs(closePrice - sl) : 0;
            if(risk <= 0) continue;

            g_EntryPrice    = closePrice;
            g_SL            = sl;
            g_TP1           = closePrice + risk * TP1_RR;
            g_TP2           = closePrice + risk * TP2_RR;
            g_SetupReady    = true;
            g_SetupDirection= "BUY";

            Print("[AMD_EA] BULLISH JUDAS SWING | Swept: ", lvl,
                  " | Entry: ", g_EntryPrice, " | SL: ", g_SL,
                  " | TP1: ", g_TP1, " | TP2: ", g_TP2);
            SendTelegram("🟢 BULLISH JUDAS SWING\nXAUUSD BUY\nEntry: " +
                         DoubleToString(g_EntryPrice,2) +
                         "\nSL: " + DoubleToString(g_SL,2) +
                         "\nTP1: " + DoubleToString(g_TP1,2) +
                         "\nTP2: " + DoubleToString(g_TP2,2));
         }
         break;
      }
   }

   // --- BEARISH JUDAS: Swept buy-side liquidity (equal highs) ---
   if(!g_SetupReady)
   {
      for(int i = 0; i < g_EqHighCount; i++)
      {
         double lvl = g_EqualHighs[i];
         // Price wicked above equal high but closed BELOW (rejection)
         if(currentHigh > lvl && closePrice < lvl && closePrice < openPrice)
         {
            g_JudasSwingBearish = true;
            g_SweptLevel        = lvl;

            if(IsMarketStructureShiftDown())
            {
               double sl   = currentHigh + (10 * _Point * 10);
               double risk = MathAbs(closePrice - sl);
               if(risk <= 0) continue;

               g_EntryPrice    = closePrice;
               g_SL            = sl;
               g_TP1           = closePrice - risk * TP1_RR;
               g_TP2           = closePrice - risk * TP2_RR;
               g_SetupReady    = true;
               g_SetupDirection= "SELL";

               Print("[AMD_EA] BEARISH JUDAS SWING | Swept: ", lvl,
                     " | Entry: ", g_EntryPrice, " | SL: ", g_SL,
                     " | TP1: ", g_TP1, " | TP2: ", g_TP2);
               SendTelegram("🔴 BEARISH JUDAS SWING\nXAUUSD SELL\nEntry: " +
                            DoubleToString(g_EntryPrice,2) +
                            "\nSL: " + DoubleToString(g_SL,2) +
                            "\nTP1: " + DoubleToString(g_TP1,2) +
                            "\nTP2: " + DoubleToString(g_TP2,2));
            }
            break;
         }
      }
   }
}

//==========================================================================
// MARKET STRUCTURE SHIFT CONFIRMATION
//==========================================================================

bool IsMarketStructureShiftUp()
{
   // Price must take out a previous M15 swing high (bullish BOS)
   double prevSwingHigh = iHigh(_Symbol, PERIOD_M15, 3);
   double curHigh       = iHigh(_Symbol, PERIOD_M15, 1);
   return (curHigh > prevSwingHigh);
}

bool IsMarketStructureShiftDown()
{
   double prevSwingLow = iLow(_Symbol, PERIOD_M15, 3);
   double curLow       = iLow(_Symbol, PERIOD_M15, 1);
   return (curLow < prevSwingLow);
}

//==========================================================================
// TRADE EXECUTION
//==========================================================================

void ExecuteTrade()
{
   if(!g_SetupReady) return;

   double lotSize = CalcLotSize(g_EntryPrice, g_SL);
   if(lotSize <= 0) { g_SetupReady = false; return; }

   bool result = false;

   if(g_SetupDirection == "BUY")
      result = trade.Buy(lotSize, _Symbol, 0, g_SL, g_TP2, "AMD_BUY");
   else
      result = trade.Sell(lotSize, _Symbol, 0, g_SL, g_TP2, "AMD_SELL");

   if(result)
   {
      g_TicketMain = trade.ResultOrder();
      g_TP1Hit     = false;
      g_SetupReady = false;
      Print("[AMD_EA] Trade opened: ", g_SetupDirection,
            " Lot: ", lotSize, " Ticket: ", g_TicketMain);
      SendTelegram("✅ TRADE EXECUTED\n" + g_SetupDirection +
                   " XAUUSD\nLots: " + DoubleToString(lotSize, 2) +
                   "\nTicket: " + IntegerToString(g_TicketMain));
   }
   else
   {
      Print("[AMD_EA] Trade failed: ", GetLastError());
      g_SetupReady = false;
   }
}

//==========================================================================
// POSITION MANAGEMENT: Partial TP + Trail
//==========================================================================

void ManageOpenPositions()
{
   if(!HasOpenPosition()) return;

   for(int i = PositionsTotal() - 1; i >= 0; i--)
   {
      if(!posInfo.SelectByIndex(i)) continue;
      if(posInfo.Magic() != MagicNumber) continue;

      double openPrice = posInfo.PriceOpen();
      double sl        = posInfo.StopLoss();
      double curPrice  = posInfo.PriceCurrent();
      double lots      = posInfo.Volume();
      ENUM_POSITION_TYPE ptype = posInfo.PositionType();

      // --- TP1 Partial Close ---
      if(!g_TP1Hit)
      {
         bool tp1Reached = (ptype == POSITION_TYPE_BUY  && curPrice >= g_TP1) ||
                           (ptype == POSITION_TYPE_SELL && curPrice <= g_TP1);
         if(tp1Reached)
         {
            double closeVol = NormalizeDouble(lots * TP1_ClosePct / 100.0, 2);
            if(closeVol >= SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN))
            {
               trade.PositionClosePartial(posInfo.Ticket(), closeVol);
               g_TP1Hit = true;
               // Move SL to Break Even
               trade.PositionModify(posInfo.Ticket(), openPrice, g_TP2);
               Print("[AMD_EA] TP1 hit — partial close ", closeVol, " lots. SL → BE");
               SendTelegram("🎯 TP1 HIT — Partial Close\nSL moved to Break Even\nRemaining: " +
                            DoubleToString(lots - closeVol, 2) + " lots");
            }
         }
      }

      // --- Trail after TP1 hit: trail SL by 50% of remaining range ---
      if(g_TP1Hit)
      {
         double trailDist = MathAbs(g_TP2 - openPrice) * 0.3;
         double newSL     = 0;
         if(ptype == POSITION_TYPE_BUY)
            newSL = curPrice - trailDist;
         else
            newSL = curPrice + trailDist;

         bool shouldUpdate = (ptype == POSITION_TYPE_BUY  && newSL > sl && newSL < curPrice) ||
                             (ptype == POSITION_TYPE_SELL && newSL < sl && newSL > curPrice);
         if(shouldUpdate)
            trade.PositionModify(posInfo.Ticket(), newSL, g_TP2);
      }
   }
}

//==========================================================================
// LOT SIZE CALCULATION (Risk-based)
//==========================================================================

double CalcLotSize(double entry, double sl)
{
   double balance    = AccountInfoDouble(ACCOUNT_BALANCE);
   double riskAmount = balance * RiskPercent / 100.0;
   double slPoints   = MathAbs(entry - sl) / (_Point * 10);

   if(slPoints <= 0) return 0;

   double tickValue  = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);
   double tickSize   = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);
   double lotValue   = (tickValue / tickSize) * _Point * 10;

   double lots = riskAmount / (slPoints * lotValue);
   lots = MathMax(SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN),
          MathMin(SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX),
          NormalizeDouble(lots, 2)));
   return lots;
}

//==========================================================================
// DRAWDOWN GUARDIAN (PropFirm Rule Enforcer)
//==========================================================================

bool IsDrawdownBreached()
{
   double balance  = AccountInfoDouble(ACCOUNT_BALANCE);
   double equity   = AccountInfoDouble(ACCOUNT_EQUITY);

   // Daily DD check
   double dailyDD  = (g_DayStartBalance - equity) / g_DayStartBalance * 100.0;
   if(dailyDD >= DailyDrawdownLimit)
   {
      static datetime lastWarn = 0;
      if(TimeCurrent() - lastWarn > 3600)
      {
         Print("[AMD_EA] ⛔ DAILY DD LIMIT HIT: ", dailyDD, "%");
         SendTelegram("⛔ DAILY DD LIMIT HIT: " + DoubleToString(dailyDD,2) +
                      "% — No new trades today!");
         lastWarn = TimeCurrent();
      }
      return true;
   }

   // Total DD check
   double totalDD  = (g_InitialBalance - equity) / g_InitialBalance * 100.0;
   if(totalDD >= MaxDrawdownLimit)
   {
      static datetime lastWarn2 = 0;
      if(TimeCurrent() - lastWarn2 > 3600)
      {
         Print("[AMD_EA] 🚨 MAX DD LIMIT HIT: ", totalDD, "%");
         SendTelegram("🚨 MAX DRAWDOWN BREACHED: " + DoubleToString(totalDD,2) +
                      "% — EA HALTED!");
         lastWarn2 = TimeCurrent();
      }
      // Close all positions if max DD hit
      CloseAllPositions();
      return true;
   }
   return false;
}

//==========================================================================
// SESSION / TIME FILTER
//==========================================================================

bool IsTradingSessionActive()
{
   int hour = TimeHour(TimeCurrent());
   // Block trades in dead zone
   if(NoTradeHour_Start < NoTradeHour_End)
   {
      if(hour >= NoTradeHour_Start && hour < NoTradeHour_End) return false;
   }
   else
   {
      if(hour >= NoTradeHour_Start || hour < NoTradeHour_End) return false;
   }
   return true;
}

//==========================================================================
// NEWS FILTER (basic time-based; integrate ForexFactory feed for full)
//==========================================================================

bool IsNewsTime()
{
   // This is a placeholder — integrate with DailyFX or MT5 economic calendar
   // For production: fetch from https://nfs.faireconomy.media/ff_calendar_thisweek.json
   // and parse high-impact USD/XAU events
   // For now: block Friday 12:30-13:30 GMT (NFP window) and Wed 14:00 (FOMC)
   int hour    = TimeHour(TimeCurrent());
   int minute  = TimeMinute(TimeCurrent());
   int dayOfWk = TimeDayOfWeek(TimeCurrent());

   // NFP - First Friday
   if(dayOfWk == 5 && hour == 12 && minute >= 0 && minute <= 60) return true;
   // FOMC - Wednesday
   if(dayOfWk == 3 && hour >= 18 && hour <= 19) return true;

   return false;
}

//==========================================================================
// DAILY TRACKING RESET
//==========================================================================

void ResetDailyTracking()
{
   MqlDateTime dt;
   TimeToStruct(TimeCurrent(), dt);
   datetime today = StringToTime(IntegerToString(dt.year) + "." +
                                 IntegerToString(dt.mon)  + "." +
                                 IntegerToString(dt.day));
   if(today != g_LastTradeDay)
   {
      g_DayStartBalance = AccountInfoDouble(ACCOUNT_BALANCE);
      g_LastTradeDay    = today;
   }
}

//==========================================================================
// UTILITY FUNCTIONS
//==========================================================================

bool HasOpenPosition()
{
   for(int i = 0; i < PositionsTotal(); i++)
   {
      if(posInfo.SelectByIndex(i) && posInfo.Magic() == MagicNumber &&
         posInfo.Symbol() == _Symbol)
         return true;
   }
   return false;
}

void CloseAllPositions()
{
   for(int i = PositionsTotal() - 1; i >= 0; i--)
   {
      if(posInfo.SelectByIndex(i) && posInfo.Magic() == MagicNumber)
         trade.PositionClose(posInfo.Ticket());
   }
}

int TimeHour(datetime t)   { MqlDateTime s; TimeToStruct(t,s); return s.hour; }
int TimeMinute(datetime t) { MqlDateTime s; TimeToStruct(t,s); return s.min;  }
int TimeDayOfWeek(datetime t) { MqlDateTime s; TimeToStruct(t,s); return s.day_of_week; }

//==========================================================================
// TELEGRAM ALERTS
//==========================================================================

void SendTelegram(string message)
{
   if(TelegramBotToken == "" || TelegramChatID == "") return;
   string url  = "https://api.telegram.org/bot" + TelegramBotToken +
                 "/sendMessage?chat_id=" + TelegramChatID +
                 "&text=" + message + "&parse_mode=HTML";
   char   data[];
   char   result[];
   string headers;
   int    timeout = 5000;
   WebRequest("GET", url, "", timeout, data, result, headers);
}

//==========================================================================
// ON-CHART DASHBOARD
//==========================================================================

void DrawDashboard()
{
   string phaseStr = "NONE";
   if(g_CurrentPhase == AMD_ACCUM)   phaseStr = "ACCUMULATION (Asia)";
   if(g_CurrentPhase == AMD_MANIP)   phaseStr = "MANIPULATION (Judas)";
   if(g_CurrentPhase == AMD_DISTRIB) phaseStr = "DISTRIBUTION (NY)";

   double equity  = AccountInfoDouble(ACCOUNT_EQUITY);
   double balance = AccountInfoDouble(ACCOUNT_BALANCE);
   double dailyDD = (g_DayStartBalance - equity) / g_DayStartBalance * 100.0;

   string info = "═══ AMD LIQUIDITY EA ═══\n" +
                 "Phase  : " + phaseStr + "\n" +
                 "Setup  : " + (g_SetupReady ? g_SetupDirection : "Scanning...") + "\n" +
                 "EqHighs: " + IntegerToString(g_EqHighCount) + "\n" +
                 "EqLows : " + IntegerToString(g_EqLowCount)  + "\n" +
                 "Daily DD: " + DoubleToString(dailyDD, 2) + "%\n" +
                 "Balance : $" + DoubleToString(balance, 2) + "\n" +
                 "Equity  : $" + DoubleToString(equity, 2);

   Comment(info);
}
//+------------------------------------------------------------------+