//+------------------------------------------------------------------+
//|                           SmartShadowScanner.mq5                 |
//|            Advanced Shadow Scanner with 3-Step Checklist Filter  |
//+------------------------------------------------------------------+
#property copyright "Professional Trader Setup 2026"
#property version   "3.00"
#property description "Scans for large rejection shadows filtered by Sweep, POI, and Session"

//--- User Inputs
input group "=== Base Shadow Settings ==="
input double   ShadowMultiplier    = 2.0;       // Shadow to Body Multiplier (e.g., 2.0 means shadow is 2x body)
input double   MinRangeATR_Multi   = 0.5;       // Min Candle Range as ATR Multiplier (0.5 = 50% of ATR)
input int      MinCandleSizePoints = 30;        // Min Absolute Candle Size in Points (Filters micro-candles)
input ENUM_TIMEFRAMES Timeframe    = PERIOD_H4; // Timeframe to Analyze

input group "=== Filter 1: Liquidity Sweep ==="
input bool     EnableSweepFilter   = true;      // Enable Liquidity Sweep Filter
input int      SwingLookback       = 10;        // Swing Lookback Period (Left & Right candles)

input group "=== Filter 2: Point of Interest (POI) ==="
input bool     EnablePOIFilter     = true;      // Enable POI Filter
input int      POI_ProximityPoints = 50;        // Allowed Distance to POI in Points
input bool     CheckPDH_PDL        = true;      // Check Previous Day High/Low
input bool     CheckOrderBlock     = true;      // Check Recent Order Blocks

input group "=== Filter 3: Trading Session ==="
input bool     EnableSessionFilter = true;      // Enable Session Time Filter
input int      LondonStartHour     = 8;         // London Start Hour (Server Time)
input int      LondonEndHour       = 12;        // London End Hour (Server Time)
input int      NYStartHour         = 13;        // New York Start Hour (Server Time)
input int      NYEndHour           = 18;        // New York End Hour (Server Time)

input group "=== Display & Alert Settings ==="
input bool     DrawArrows          = true;      // Draw Arrows on Chart
input bool     ShowAlerts          = true;      // Show Popup Alerts
input bool     SendPush            = false;     // Send Push Notifications
input color    BullishArrowColor   = clrLime;   // Bullish Arrow Color (Lower Shadow)
input color    BearishArrowColor   = clrRed;    // Bearish Arrow Color (Upper Shadow)
input int      ArrowDistancePoints = 10;        // Arrow Distance from Shadow Tip (Points)

//--- Global Variables
datetime lastBarTime = 0;
int atrHandle = INVALID_HANDLE;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
   // Initialize ATR indicator handle for volatility filtering
   atrHandle = iATR(_Symbol, Timeframe, 14);
   if(atrHandle == INVALID_HANDLE)
   {
      Print("Error creating ATR indicator handle!");
      return(INIT_FAILED);
   }
   
   Print("=== Smart Shadow Scanner v3.0 Initialized ===");
   Print("Sweep Filter: ", EnableSweepFilter ? "Enabled" : "Disabled");
   Print("POI Filter: ", EnablePOIFilter ? "Enabled" : "Disabled");
   Print("Session Filter: ", EnableSessionFilter ? "Enabled" : "Disabled");
   return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   // Clean up chart objects and release indicator memory
   ObjectsDeleteAll(0, "ShadowArrow_");
   IndicatorRelease(atrHandle);
   ChartRedraw();
}

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
   // Process only on new bar close to avoid redundant calculations
   datetime currentBarTime = iTime(_Symbol, Timeframe, 0);
   if(currentBarTime == lastBarTime) return;
   lastBarTime = currentBarTime;

   // Copy required bars (Need enough history for Swing Lookback)
   int barsNeeded = SwingLookback * 2 + 10;
   MqlRates rates[];
   ArraySetAsSeries(rates, true);
   if(CopyRates(_Symbol, Timeframe, 0, barsNeeded, rates) < barsNeeded) return;

   // Copy ATR value for the closed candle (index 1)
   double atrBuffer[];
   ArraySetAsSeries(atrBuffer, true);
   if(CopyBuffer(atrHandle, 0, 1, 1, atrBuffer) < 1) return;
   double currentATR = atrBuffer[0];

   // Extract OHLC data for the target candle (index 1)
   double openPrice  = rates[1].open;
   double highPrice  = rates[1].high;
   double lowPrice   = rates[1].low;
   double closePrice = rates[1].close;
   datetime barTime  = rates[1].time;
   
   // Calculate candle metrics
   double body        = MathAbs(openPrice - closePrice);
   double upperShadow = highPrice - MathMax(openPrice, closePrice);
   double lowerShadow = MathMin(openPrice, closePrice) - lowPrice;
   double totalRange  = highPrice - lowPrice;

   // ==========================================
   // Base Filters (Volatility & Size)
   // ==========================================
   // Filter 1: Absolute minimum size (ignores dead-market micro candles)
   if(totalRange < MinCandleSizePoints * _Point) return;
   
   // Filter 2: Dynamic ATR filter (candle must be at least X% of average range)
   if(totalRange < (currentATR * MinRangeATR_Multi)) return;

   // Identify shadow type
   bool isBullishShadow = (lowerShadow >= (ShadowMultiplier * body) && lowerShadow > upperShadow);
   bool isBearishShadow = (upperShadow >= (ShadowMultiplier * body) && upperShadow > lowerShadow);
   
   if(!isBullishShadow && !isBearishShadow) return;

   // ==========================================
   // Advanced 3-Step Checklist
   // ==========================================
   bool passedSweep   = !EnableSweepFilter   || CheckLiquiditySweep(rates, isBullishShadow);
   bool passedPOI     = !EnablePOIFilter     || CheckNearPOI(rates, isBullishShadow, barTime);
   bool passedSession = !EnableSessionFilter || CheckSession(barTime);

   // Trigger final signal only if ALL enabled filters are passed
   if(passedSweep && passedPOI && passedSession)
   {
      ProcessSignal(isBullishShadow, barTime, isBullishShadow ? lowPrice : highPrice);
   }
}

//+------------------------------------------------------------------+
//| Filter 1: Check for Liquidity Sweep                              |
//+------------------------------------------------------------------+
bool CheckLiquiditySweep(const MqlRates &rates[], bool isBullish)
{
   int targetIndex = 1; // Target candle is at index 1
   
   if(isBullish) // For lower shadow, it must have swept a previous Swing Low
   {
      for(int i = targetIndex + 2; i < ArraySize(rates) - SwingLookback; i++)
      {
         if(IsSwingLow(rates, i, SwingLookback))
         {
            double swingLow = rates[i].low;
            // Sweep condition: Wick pierces the swing low, but body closes above it
            if(rates[targetIndex].low < swingLow && rates[targetIndex].close > swingLow)
            {
               return true; // Valid liquidity sweep detected
            }
         }
      }
   }
   else // For upper shadow, it must have swept a previous Swing High
   {
      for(int i = targetIndex + 2; i < ArraySize(rates) - SwingLookback; i++)
      {
         if(IsSwingHigh(rates, i, SwingLookback))
         {
            double swingHigh = rates[i].high;
            // Sweep condition: Wick pierces the swing high, but body closes below it
            if(rates[targetIndex].high > swingHigh && rates[targetIndex].close < swingHigh)
            {
               return true; // Valid liquidity sweep detected
            }
         }
      }
   }
   
   return false; // No valid sweep found
}

//+------------------------------------------------------------------+
//| Identify Swing High                                              |
//+------------------------------------------------------------------+
bool IsSwingHigh(const MqlRates &rates[], int index, int lookback)
{
   if(index - lookback < 0 || index + lookback >= ArraySize(rates)) return false;
   
   double high = rates[index].high;
   for(int i = 1; i <= lookback; i++)
   {
      if(rates[index - i].high >= high) return false;
      if(rates[index + i].high >= high) return false;
   }
   return true;
}

//+------------------------------------------------------------------+
//| Identify Swing Low                                               |
//+------------------------------------------------------------------+
bool IsSwingLow(const MqlRates &rates[], int index, int lookback)
{
   if(index - lookback < 0 || index + lookback >= ArraySize(rates)) return false;
   
   double low = rates[index].low;
   for(int i = 1; i <= lookback; i++)
   {
      if(rates[index - i].low <= low) return false;
      if(rates[index + i].low <= low) return false;
   }
   return true;
}

//+------------------------------------------------------------------+
//| Filter 2: Check Proximity to Point of Interest (POI)             |
//+------------------------------------------------------------------+
bool CheckNearPOI(const MqlRates &rates[], bool isBullish, datetime barTime)
{
   double currentPrice = isBullish ? rates[1].low : rates[1].high;
   double proximity = POI_ProximityPoints * _Point;
   
   // POI Type 1: Previous Day High / Previous Day Low (PDH/PDL)
   if(CheckPDH_PDL)
   {
      MqlRates dayRates[];
      ArraySetAsSeries(dayRates, true);
      
      // Fetch previous daily candle data
      if(CopyRates(_Symbol, PERIOD_D1, 1, 1, dayRates) >= 1)
      {
         double pdh = dayRates[0].high;
         double pdl = dayRates[0].low;
         
         if(isBullish && MathAbs(currentPrice - pdl) <= proximity) return true; // Near PDL
         if(!isBullish && MathAbs(currentPrice - pdh) <= proximity) return true; // Near PDH
      }
   }
   
   // POI Type 2: Recent Order Blocks (OB)
   if(CheckOrderBlock)
   {
      // Scan the last 20 candles for Order Blocks
      for(int i = 2; i < MathMin(20, ArraySize(rates) - 1); i++)
      {
         // Bullish OB: Bearish candle followed by a strong bullish displacement
         if(isBullish && IsBullishOrderBlock(rates, i))
         {
            double obLow = rates[i].low;
            double obHigh = rates[i].high;
            if(currentPrice >= (obLow - proximity) && currentPrice <= (obHigh + proximity))
               return true;
         }
         
         // Bearish OB: Bullish candle followed by a strong bearish displacement
         if(!isBullish && IsBearishOrderBlock(rates, i))
         {
            double obLow = rates[i].low;
            double obHigh = rates[i].high;
            if(currentPrice >= (obLow - proximity) && currentPrice <= (obHigh + proximity))
               return true;
         }
      }
   }
   
   return false; // Not near any valid POI
}

//+------------------------------------------------------------------+
//| Identify Bullish Order Block                                     |
//+------------------------------------------------------------------+
bool IsBullishOrderBlock(const MqlRates &rates[], int index)
{
   // Current candle must be bearish
   if(rates[index].close >= rates[index].open) return false;
   
   if(index - 1 < 0) return false;
   
   // Next candle (index-1) must be a strong bullish displacement
   double nextBody = MathAbs(rates[index-1].close - rates[index-1].open);
   double nextRange = rates[index-1].high - rates[index-1].low;
   
   if(rates[index-1].close <= rates[index-1].open) return false; // Must be bullish
   if(nextBody < (nextRange * 0.6)) return false; // Body must be at least 60% of total range
   
   return true;
}

//+------------------------------------------------------------------+
//| Identify Bearish Order Block                                     |
//+------------------------------------------------------------------+
bool IsBearishOrderBlock(const MqlRates &rates[], int index)
{
   // Current candle must be bullish
   if(rates[index].close <= rates[index].open) return false;
   
   if(index - 1 < 0) return false;
   
   // Next candle (index-1) must be a strong bearish displacement
   double nextBody = MathAbs(rates[index-1].close - rates[index-1].open);
   double nextRange = rates[index-1].high - rates[index-1].low;
   
   if(rates[index-1].close >= rates[index-1].open) return false; // Must be bearish
   if(nextBody < (nextRange * 0.6)) return false;
   
   return true;
}

//+------------------------------------------------------------------+
//| Filter 3: Check Trading Session Time                             |
//+------------------------------------------------------------------+
bool CheckSession(datetime barTime)
{
   MqlDateTime dt;
   TimeToStruct(barTime, dt);
   int hour = dt.hour;
   
   // London Session
   if(hour >= LondonStartHour && hour < LondonEndHour) return true;
   
   // New York Session
   if(hour >= NYStartHour && hour < NYEndHour) return true;
   
   return false; // Outside active sessions (e.g., Asian session)
}

//+------------------------------------------------------------------+
//| Process Final Signal (Draw, Alert, Push)                         |
//+------------------------------------------------------------------+
void ProcessSignal(bool isBullish, datetime barTime, double extremePrice)
{
   string direction = isBullish ? "BULLISH" : "BEARISH";
   string message = StringFormat("✅ Golden %s Signal | %s | Price: %s", 
                                 direction, 
                                 TimeToString(barTime, TIME_DATE|TIME_MINUTES),
                                 DoubleToString(extremePrice, _Digits));

   // 1. Draw Arrow on Chart
   if(DrawArrows)
   {
      string objName = "ShadowArrow_" + IntegerToString(barTime);
      int arrowCode = isBullish ? 233 : 234; // 233: Up arrow, 234: Down arrow
      color arrowColor = isBullish ? BullishArrowColor : BearishArrowColor;
      double arrowPrice = isBullish ? 
                          (extremePrice - ArrowDistancePoints * _Point) : 
                          (extremePrice + ArrowDistancePoints * _Point);

      ObjectCreate(0, objName, OBJ_ARROW, 0, barTime, arrowPrice);
      ObjectSetInteger(0, objName, OBJPROP_ARROWCODE, arrowCode);
      ObjectSetInteger(0, objName, OBJPROP_COLOR, arrowColor);
      ObjectSetInteger(0, objName, OBJPROP_WIDTH, 3);
      ObjectSetInteger(0, objName, OBJPROP_ANCHOR, isBullish ? ANCHOR_TOP : ANCHOR_BOTTOM);
   }

   // 2. Trigger Alerts
   if(ShowAlerts) Alert(message);
   if(SendPush) SendNotification(message);
   
   // 3. Print to Experts Log
   Print(message);
}
//+------------------------------------------------------------------+