#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 SessionVWAPRSIStepped : public Indicator
{
public:
                     SessionVWAPRSIStepped(SlotTypes slotType)
     {
      SlotType          = slotType;
      IndicatorName     = "SessionVWAPRSIStepped";
      WarningMessage    = "RSI 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     CalculateRSI(const double &price[], double &rsi[], int period);
   datetime GetLastResetTime(datetime currentTime, int anchorHour, int anchorMinute, int resetPeriod);
};

//+------------------------------------------------------------------+
void SessionVWAPRSIStepped::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    rsiPeriod    = (int)NumParam[0].Value;
   double level        = NumParam[1].Value;
   int    previous     = CheckParam[0].Checked ? 1 : 0;
   int    bars         = Data.Bars;
   int    firstBar     = rsiPeriod + previous + 2;

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

   // 3) Compute RSI on VWAP
   double rsi[];
   ArrayResize(rsi, bars);
   ArrayInitialize(rsi, 0.0);
   CalculateRSI(vwapPrice, rsi, rsiPeriod);

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

   // Main RSI line
   ArrayResize(Component[0].Value, bars);
   Component[0].CompName = "SessionVWAPRSI";
   Component[0].DataType = IndComponentType_IndicatorValue;
   Component[0].FirstBar = firstBar;
   ArrayCopy(Component[0].Value, rsi);

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

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

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

   if(logic == "SessionVWAPRSI rises")
      logicRule = IndicatorLogic_The_indicator_rises;
   else if(logic == "SessionVWAPRSI falls")
      logicRule = IndicatorLogic_The_indicator_falls;
   else if(logic == "SessionVWAPRSI is higher than the Level line")
      logicRule = IndicatorLogic_The_indicator_is_higher_than_the_level_line;
   else if(logic == "SessionVWAPRSI is lower than the Level line")
      logicRule = IndicatorLogic_The_indicator_is_lower_than_the_level_line;
   else if(logic == "SessionVWAPRSI crosses the Level line upward")
      logicRule = IndicatorLogic_The_indicator_crosses_the_level_line_upward;
   else if(logic == "SessionVWAPRSI crosses the Level line downward")
      logicRule = IndicatorLogic_The_indicator_crosses_the_level_line_downward;
   else if(logic == "SessionVWAPRSI changes its direction upward")
      logicRule = IndicatorLogic_The_indicator_changes_its_direction_upward;
   else if(logic == "SessionVWAPRSI changes its direction downward")
      logicRule = IndicatorLogic_The_indicator_changes_its_direction_downward;

   OscillatorLogic(firstBar,
                   previous,
                   rsi,
                   level,
                   100.0 - level,
                   Component[1],
                   Component[2],
                   logicRule);
}

//+------------------------------------------------------------------+
void SessionVWAPRSIStepped::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 SessionVWAPRSIStepped::CalculateRSI(const double &price[], double &rsi[], int period)
{
   int bars = ArraySize(price);
   double pos[], neg[], posMa[], negMa[];
   ArrayResize(pos,   bars); ArrayInitialize(pos,   0.0);
   ArrayResize(neg,   bars); ArrayInitialize(neg,   0.0);
   ArrayResize(posMa, bars); ArrayInitialize(posMa, 0.0);
   ArrayResize(negMa, bars); ArrayInitialize(negMa, 0.0);

   // 1) Gains/Losses
   for(int bar = 1; bar < bars; bar++)
     {
      if(price[bar] > price[bar-1] + 0.0000001) // Epsilon
         pos[bar] = price[bar] - price[bar-1];
      if(price[bar] < price[bar-1] - 0.0000001) // Epsilon
         neg[bar] = price[bar-1] - price[bar];
     }

   // 2) Wilder's smoothing
   double sumPos=0.0, sumNeg=0.0;
   for(int i=1; i<=period; i++)
     {
      sumPos += pos[i];
      sumNeg += neg[i];
     }
   posMa[period] = sumPos/period;
   negMa[period] = sumNeg/period;

   for(int bar = period+1; bar < bars; bar++)
     {
      posMa[bar] = (posMa[bar-1]*(period-1) + pos[bar]) / period;
      negMa[bar] = (negMa[bar-1]*(period-1) + neg[bar]) / period;
     }

   // 3) RSI formula
   ArrayResize(rsi, bars);
   ArrayInitialize(rsi, 0.0);
   for(int bar = period; bar < bars; bar++)
     {
      if(MathAbs(negMa[bar]) > 0.0000001) // Epsilon
         rsi[bar] = 100.0 - (100.0 / (1.0 + posMa[bar]/negMa[bar]));
      else
         rsi[bar] = (MathAbs(posMa[bar]) > 0.0000001) ? 100.0 : 50.0;
     }
}

//+------------------------------------------------------------------+
datetime SessionVWAPRSIStepped::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);
}
//+------------------------------------------------------------------+