#property copyright "Copyright (C) 2025 NAYA +237674724684"
#property link      "https://forexsb.com"
#property version   "1.0"
#property strict

#include <Forexsb.com/Indicator.mqh>
#include <Forexsb.com/Enumerations.mqh>

class SessionVWAPStochasticStepped : public Indicator
{
public:
                     SessionVWAPStochasticStepped(SlotTypes slotType)
     {
      SlotType          = slotType;
      IndicatorName     = "SessionVWAPStochasticStepped";
      WarningMessage    = "Stochastic calculated from SessionVWAPStepped price with stepped reset periods.";
      IsAllowLTF        = true;
      ExecTime          = ExecutionTime_DuringTheBar;
      IsSeparateChart   = true;
      IsDiscreteValues  = false;
      IsDefaultGroupAll = false;
     }

   virtual void Calculate(DataSet &dataSet);

private:
   void     CalculateVWAP(double &vwapBuffer[], int anchorHour, int anchorMinute, int resetPeriod);
   void     CalculateStochastic(const double &price[], int periodK, int periodDFast, int periodDSlow, 
                               double &adK[], double &adDFast[], double &adDSlow[]);
   datetime GetLastResetTime(datetime currentTime, int anchorHour, int anchorMinute, int resetPeriod);
};

//+------------------------------------------------------------------+
void SessionVWAPStochasticStepped::Calculate(DataSet &dataSet)
{
   Data = GetPointer(dataSet);

   // 1) Read parameters
   int    anchorHour   = (int)StringToInteger(ListParam[1].Text);
   int    anchorMinute = (int)StringToInteger(ListParam[2].Text);
   int    resetPeriod  = (int)StringToInteger(ListParam[3].Text);
   int    periodK      = (int)NumParam[0].Value;
   int    periodDFast  = (int)NumParam[1].Value;
   int    periodDSlow  = (int)NumParam[2].Value;
   double level        = NumParam[3].Value;
   int    previous     = CheckParam[0].Checked ? 1 : 0;
   int    bars         = Data.Bars;
   int    firstBar     = periodK + periodDFast + periodDSlow + 3;

   // 2) Compute stepped VWAP
   double vwapPrice[];
   ArrayResize(vwapPrice, bars);
   ArrayInitialize(vwapPrice, 0.0);
   CalculateVWAP(vwapPrice, anchorHour, anchorMinute, resetPeriod);

   // 3) Compute Stochastic on VWAP
   double adK[], adDFast[], adDSlow[];
   ArrayResize(adK, bars); ArrayInitialize(adK, 0.0);
   ArrayResize(adDFast, bars); ArrayInitialize(adDFast, 0.0);
   ArrayResize(adDSlow, bars); ArrayInitialize(adDSlow, 0.0);
   CalculateStochastic(vwapPrice, periodK, periodDFast, periodDSlow, adK, adDFast, adDSlow);

   // 4) Prepare components
   ArrayResize(Component, 5);

   // %K line
   ArrayResize(Component[0].Value, bars);
   Component[0].CompName = "%K";
   Component[0].DataType = IndComponentType_IndicatorValue;
   Component[0].FirstBar = firstBar;
   ArrayCopy(Component[0].Value, adK);

   // Fast %D line
   ArrayResize(Component[1].Value, bars);
   Component[1].CompName = "Fast %D";
   Component[1].DataType = IndComponentType_IndicatorValue;
   Component[1].FirstBar = firstBar;
   ArrayCopy(Component[1].Value, adDFast);

   // Slow %D line
   ArrayResize(Component[2].Value, bars);
   Component[2].CompName = "Slow %D";
   Component[2].DataType = IndComponentType_IndicatorValue;
   Component[2].FirstBar = firstBar;
   ArrayCopy(Component[2].Value, adDSlow);

   // Two filter buffers (no chart)
   for(int i=3; i<=4; i++)
     {
      ArrayResize(Component[i].Value, bars);
      ArrayInitialize(Component[i].Value, 0.0);
      Component[i].FirstBar = firstBar;
     }

   // Assign filter types
   if(SlotType == SlotTypes_OpenFilter)
     {
      Component[3].DataType = IndComponentType_AllowOpenLong;
      Component[3].CompName = "Is long entry allowed";
      Component[4].DataType = IndComponentType_AllowOpenShort;
      Component[4].CompName = "Is short entry allowed";
     }
   else // CloseFilter
     {
      Component[3].DataType = IndComponentType_ForceCloseLong;
      Component[3].CompName = "Close out long position";
      Component[4].DataType = IndComponentType_ForceCloseShort;
      Component[4].CompName = "Close out short position";
     }

   // 5) Apply logic
   IndicatorLogic indLogic = IndicatorLogic_It_does_not_act_as_a_filter;
   string logic = ListParam[0].Text;

   if(logic == "%K crosses Slow %D upward")
      IndicatorCrossesAnotherIndicatorUpwardLogic(firstBar, previous, adK, adDSlow, Component[3], Component[4]);
   else if(logic == "%K crosses Slow %D downward")
      IndicatorCrossesAnotherIndicatorDownwardLogic(firstBar, previous, adK, adDSlow, Component[3], Component[4]);
   else if(logic == "%K is higher than Slow %D")
      IndicatorIsHigherThanAnotherIndicatorLogic(firstBar, previous, adK, adDSlow, Component[3], Component[4]);
   else if(logic == "%K is lower than Slow %D")
      IndicatorIsLowerThanAnotherIndicatorLogic(firstBar, previous, adK, adDSlow, Component[3], Component[4]);
   else
     {
      if(logic == "Slow %D rises")
         indLogic = IndicatorLogic_The_indicator_rises;
      else if(logic == "Slow %D falls")
         indLogic = IndicatorLogic_The_indicator_falls;
      else if(logic == "Slow %D is higher than Level line")
         indLogic = IndicatorLogic_The_indicator_is_higher_than_the_level_line;
      else if(logic == "Slow %D is lower than Level line")
         indLogic = IndicatorLogic_The_indicator_is_lower_than_the_level_line;
      else if(logic == "Slow %D crosses Level line upward")
         indLogic = IndicatorLogic_The_indicator_crosses_the_level_line_upward;
      else if(logic == "Slow %D crosses Level line downward")
         indLogic = IndicatorLogic_The_indicator_crosses_the_level_line_downward;
      else if(logic == "Slow %D changes its direction upward")
         indLogic = IndicatorLogic_The_indicator_changes_its_direction_upward;
      else if(logic == "Slow %D changes its direction downward")
         indLogic = IndicatorLogic_The_indicator_changes_its_direction_downward;

      OscillatorLogic(firstBar, previous, adDSlow, level, 100.0 - level, Component[3], Component[4], indLogic);
     }
}

//+------------------------------------------------------------------+
void SessionVWAPStochasticStepped::CalculateVWAP(double &vwapBuffer[], int anchorHour, int anchorMinute, int resetPeriod)
{
   const int firstStepped = 3;
   double cumPV = 0.0, cumV = 0.0;
   datetime currentReset = 0;
   int bars = Data.Bars;

   for(int bar = firstStepped; bar < bars; bar++)
     {
      // CHANGED: Removed Period()*60 adjustment to use raw bar opening time
      datetime barTime = Data.Time[bar];
      datetime lastReset = GetLastResetTime(barTime, anchorHour, anchorMinute, resetPeriod);

      if(lastReset != currentReset)
        {
         cumPV        = 0.0;
         cumV         = 0.0;
         currentReset = lastReset;
        }

      double tp  = (Data.Open[bar] + Data.High[bar] + Data.Low[bar] + Data.Close[bar]) / 4.0;
      double vol = (double)Data.Volume[bar];

      cumPV += tp * vol;
      cumV  += vol;

      vwapBuffer[bar] = (cumV > 0.0) ? (cumPV / cumV) : 0.0;
     }
}

//+------------------------------------------------------------------+
void SessionVWAPStochasticStepped::CalculateStochastic(const double &price[], int periodK, int periodDFast, int periodDSlow, 
                                                     double &adK[], double &adDFast[], double &adDSlow[])
{
   int bars = ArraySize(price);
   double highs[], lows[];
   ArrayResize(highs, bars); ArrayInitialize(highs, 0.0);
   ArrayResize(lows, bars);  ArrayInitialize(lows, 0.0);

   // Calculate highs and lows for %K period
   for(int bar = 0; bar < periodK; bar++)
     {
      double min = DBL_MAX;
      double max = DBL_MIN;
      for(int i = 0; i < bar; i++)
        {
         if(price[bar - i] > max) max = price[bar - i];
         if(price[bar - i] < min) min = price[bar - i];
        }
      highs[bar] = max;
      lows[bar]  = min;
     }

   for(int bar = periodK; bar < bars; bar++)
     {
      double min = DBL_MAX;
      double max = DBL_MIN;
      for(int i = 0; i < periodK; i++)
        {
         if(price[bar - i] > max) max = price[bar - i];
         if(price[bar - i] < min) min = price[bar - i];
        }
      highs[bar] = max;
      lows[bar]  = min;
     }

   // Calculate %K
   for(int bar = periodK; bar < bars; bar++)
     {
      if(highs[bar] == lows[bar])
         adK[bar] = 50;
      else
         adK[bar] = 100 * (price[bar] - lows[bar]) / (highs[bar] - lows[bar]);
     }

   // Calculate Fast %D (simple moving average of %K)
   for(int bar = periodDFast; bar < bars; bar++)
     {
      double sum = 0;
      for(int i = 0; i < periodDFast; i++)
        {
         sum += adK[bar - i];
        }
      adDFast[bar] = sum / periodDFast;
     }

   // Calculate Slow %D (simple moving average of Fast %D)
   for(int bar = periodDFast + periodDSlow - 1; bar < bars; bar++)
     {
      double sum = 0;
      for(int i = 0; i < periodDSlow; i++)
        {
         sum += adDFast[bar - i];
        }
      adDSlow[bar] = sum / periodDSlow;
     }
}

//+------------------------------------------------------------------+
datetime SessionVWAPStochasticStepped::GetLastResetTime(datetime currentTime,
                                                int anchorHour,
                                                int anchorMinute,
                                                int resetPeriod)
{
   MqlDateTime tm; TimeToStruct(currentTime, tm);
   int currentMinutes = tm.hour*60 + tm.min;
   int anchorMinutes  = anchorHour*60 + anchorMinute;

   datetime lastReset;
   if(currentMinutes >= anchorMinutes)
     {
      tm.hour = anchorHour; tm.min = anchorMinute; tm.sec = 0;
      datetime anchorToday = StructToTime(tm);
      int periods = (currentMinutes - anchorMinutes) / resetPeriod;
      lastReset = anchorToday + (datetime)(periods * resetPeriod * 60);
     }
   else
     {
      tm.hour = anchorHour; tm.min = anchorMinute; tm.sec = 0;
      datetime anchorPrev = StructToTime(tm) - 86400;
      int minutesSincePrev = (1440 - anchorMinutes) + currentMinutes;
      int periods = minutesSincePrev / resetPeriod;
      lastReset = anchorPrev + (datetime)(periods * resetPeriod * 60);
     }
   return(lastReset);
}
//+------------------------------------------------------------------+