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

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

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

   // 3) Compute CCI on VWAP
   double cci[];
   ArrayResize(cci, bars);
   ArrayInitialize(cci, 0.0);
   CalculateCCI(vwapPrice, cci, cciPeriod, multiplier);

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

   // Main CCI line
   ArrayResize(Component[0].Value, bars);
   Component[0].CompName = "SessionVWAPCCI";
   Component[0].DataType = IndComponentType_IndicatorValue;
   Component[0].FirstBar = firstBar;
   ArrayCopy(Component[0].Value, cci);

   // 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 == "SessionVWAPCCI rises")
      logicRule = IndicatorLogic_The_indicator_rises;
   else if(logic == "SessionVWAPCCI falls")
      logicRule = IndicatorLogic_The_indicator_falls;
   else if(logic == "SessionVWAPCCI is higher than the Level line")
      logicRule = IndicatorLogic_The_indicator_is_higher_than_the_level_line;
   else if(logic == "SessionVWAPCCI is lower than the Level line")
      logicRule = IndicatorLogic_The_indicator_is_lower_than_the_level_line;
   else if(logic == "SessionVWAPCCI crosses the Level line upward")
      logicRule = IndicatorLogic_The_indicator_crosses_the_level_line_upward;
   else if(logic == "SessionVWAPCCI crosses the Level line downward")
      logicRule = IndicatorLogic_The_indicator_crosses_the_level_line_downward;
   else if(logic == "SessionVWAPCCI changes its direction upward")
      logicRule = IndicatorLogic_The_indicator_changes_its_direction_upward;
   else if(logic == "SessionVWAPCCI changes its direction downward")
      logicRule = IndicatorLogic_The_indicator_changes_its_direction_downward;

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

//+------------------------------------------------------------------+
void SessionVWAPCCIStepped::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 SessionVWAPCCIStepped::CalculateCCI(const double &price[], double &cci[], int period, double multiplier)
{
   int bars = ArraySize(price);
   double sma[], meanDev[];
   ArrayResize(sma, bars); ArrayInitialize(sma, 0.0);
   ArrayResize(meanDev, bars); ArrayInitialize(meanDev, 0.0);

   // 1) Calculate SMA
   for(int bar = period; bar < bars; bar++)
     {
      double sum = 0;
      for(int i = 0; i < period; i++)
         sum += price[bar - i];
      sma[bar] = sum / period;
     }

   // 2) Calculate Mean Deviation
   for(int bar = period; bar < bars; bar++)
     {
      double sum = 0;
      for(int i = 0; i < period; i++)
         sum += MathAbs(price[bar - i] - sma[bar]);
      meanDev[bar] = sum / period;
     }

   // 3) Calculate CCI
   ArrayResize(cci, bars);
   ArrayInitialize(cci, 0.0);
   for(int bar = period; bar < bars; bar++)
     {
      if(MathAbs(meanDev[bar]) > 0.0000001) // Epsilon
         cci[bar] = (price[bar] - sma[bar]) / (multiplier * meanDev[bar]);
      else
         cci[bar] = 0;
     }
}

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