//+------------------------------------------------------------------+
//|                  AdvancedSessionVWAPCrossoverStepped.mqh         |
//|                        Copyright (C) 2025 NAYA +237674724684     |
//|                                     NAYA +237674724684           |
//+------------------------------------------------------------------+
#property copyright "Copyright (C) 2025 NAYA +237674724684"
#property link      "NAYA +237674724684"
#property version   "1.0"
#property strict

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

//+------------------------------------------------------------------+
//| Class AdvancedSessionVWAPCrossoverStepped                        |
//+------------------------------------------------------------------+
class AdvancedSessionVWAPCrossoverStepped : public Indicator
{
public:
    AdvancedSessionVWAPCrossoverStepped(SlotTypes slotType);
    virtual void Calculate(DataSet &dataSet);
    
private:
    void CalculateAdvancedVWAP(int anchorPeriodIndex, int anchorHour, int anchorMinute, int resetPeriod, double &vwap[]);
    datetime GetAnchorStartTime(datetime currentTime, int anchorType);
    datetime GetLastResetTimeStepped(datetime currentTime, int anchorHour, int anchorMinute, int resetPeriod);
    int TimeDayCount(const MqlDateTime &dt);
};

//+------------------------------------------------------------------+
//| Constructor                                                      |
//+------------------------------------------------------------------+
AdvancedSessionVWAPCrossoverStepped::AdvancedSessionVWAPCrossoverStepped(SlotTypes slotType)
{
    SlotType = slotType;
    IndicatorName = "AdvancedSessionVWAPCrossoverStepped";
    WarningMessage = "Crossover between two SessionVWAP lines (Fast vs. Slow) with stepped parameters.";
    IsAllowLTF = true;
    ExecTime = ExecutionTime_DuringTheBar;
    IsSeparateChart = false;
    IsDiscreteValues = false;
    IsDefaultGroupAll = false;
}
//+------------------------------------------------------------------+
//| Calculate indicator values                                       |
//+------------------------------------------------------------------+
void AdvancedSessionVWAPCrossoverStepped::Calculate(DataSet &dataSet)
{
    Data = GetPointer(dataSet);

    // 1) Read parameters
    int fastAnchorPeriodIndex = (int)ListParam[1].Index;
    int fastResetPeriod = (int)StringToInteger(ListParam[2].Text);
    int slowAnchorPeriodIndex = (int)ListParam[3].Index;
    int slowResetPeriod = (int)StringToInteger(ListParam[4].Text);

    int fastAnchorHour = (int)NumParam[0].Value;
    int fastAnchorMinute = (int)NumParam[1].Value;
    int slowAnchorHour = (int)NumParam[2].Value;
    int slowAnchorMinute = (int)NumParam[3].Value;

    // 2) "Use previous bar's value?" checkbox
    int previous = CheckParam[0].Checked ? 1 : 0;

    // 3) Compute the Fast and Slow VWAP arrays
    double fastVWAP[];
    CalculateAdvancedVWAP(fastAnchorPeriodIndex, fastAnchorHour, fastAnchorMinute, fastResetPeriod, fastVWAP);

    double slowVWAP[];
    CalculateAdvancedVWAP(slowAnchorPeriodIndex, slowAnchorHour, slowAnchorMinute, slowResetPeriod, slowVWAP);

    // 4) Build an oscillator = fastVWAP - slowVWAP for crossover logic
    int firstBar = 3 + previous + 2;

    double oscillator[];
    ArrayResize(oscillator, Data.Bars);
    ArrayInitialize(oscillator, 0.0);

    for(int bar = firstBar; bar < Data.Bars; bar++)
    {
        oscillator[bar] = fastVWAP[bar] - slowVWAP[bar];
    }

    // 5) Create 4 components:
    //    [0] = Fast VWAP line
    //    [1] = Slow VWAP line
    //    [2] = "Allow Long" or "Force Close Long" (depending on slot)
    //    [3] = "Allow Short" or "Force Close Short"
    Component[0].CompName = "Fast VWAP";
    Component[0].DataType = IndComponentType_IndicatorValue;
    Component[0].FirstBar = firstBar;
    ArrayResize(Component[0].Value, Data.Bars);
    ArrayCopy(Component[0].Value, fastVWAP);

    Component[1].CompName = "Slow VWAP";
    Component[1].DataType = IndComponentType_IndicatorValue;
    Component[1].FirstBar = firstBar;
    ArrayResize(Component[1].Value, Data.Bars);
    ArrayCopy(Component[1].Value, slowVWAP);

    // The two "signal" / "filter" components
    ArrayResize(Component[2].Value, Data.Bars);
    ArrayInitialize(Component[2].Value, 0.0);
    Component[2].FirstBar = firstBar;
    
    ArrayResize(Component[3].Value, Data.Bars);
    ArrayInitialize(Component[3].Value, 0.0);
    Component[3].FirstBar = firstBar;

    // 6) Assign DataType & CompName for the two filter/signal components
    if(SlotType == SlotTypes_OpenFilter)
    {
        Component[2].DataType = IndComponentType_AllowOpenLong;
        Component[2].CompName = "Is long entry allowed";
        Component[3].DataType = IndComponentType_AllowOpenShort;
        Component[3].CompName = "Is short entry allowed";
    }
    else if(SlotType == SlotTypes_CloseFilter)
    {
        Component[2].DataType = IndComponentType_ForceCloseLong;
        Component[2].CompName = "Close out long position";
        Component[3].DataType = IndComponentType_ForceCloseShort;
        Component[3].CompName = "Close out short position";
    }

    // 7) Determine which logic rule to use
    int logicIndex = (int)ListParam[0].Index;
    switch(logicIndex)
    {
        // 0: "Fast SessionVWAP crosses Slow SessionVWAP upward"
        case 0:
            for(int bar = firstBar + previous; bar < Data.Bars; bar++)
            {
                bool longCondition = (oscillator[bar - previous] > 0 && 
                                    oscillator[bar - previous - 1] <= 0);
                Component[2].Value[bar] = longCondition ? 1.0 : 0.0;
                
                bool shortCondition = (oscillator[bar - previous] < 0 && 
                                     oscillator[bar - previous - 1] >= 0);
                Component[3].Value[bar] = shortCondition ? 1.0 : 0.0;
            }
            break;

        // 1: "Fast SessionVWAP crosses Slow SessionVWAP downward"
        case 1:
            for(int bar = firstBar + previous; bar < Data.Bars; bar++)
            {
                bool longCondition = (oscillator[bar - previous] < 0 && 
                                    oscillator[bar - previous - 1] >= 0);
                Component[2].Value[bar] = longCondition ? 1.0 : 0.0;
                
                bool shortCondition = (oscillator[bar - previous] > 0 && 
                                     oscillator[bar - previous - 1] <= 0);
                Component[3].Value[bar] = shortCondition ? 1.0 : 0.0;
            }
            break;

        // 2: "Fast SessionVWAP is higher than Slow SessionVWAP"
        case 2:
            for(int bar = firstBar + previous; bar < Data.Bars; bar++)
            {
                Component[2].Value[bar] = (oscillator[bar - previous] > 0) ? 1.0 : 0.0;
                Component[3].Value[bar] = (oscillator[bar - previous] < 0) ? 1.0 : 0.0;
            }
            break;

        // 3: "Fast SessionVWAP is lower than Slow SessionVWAP"
        case 3:
            for(int bar = firstBar + previous; bar < Data.Bars; bar++)
            {
                Component[2].Value[bar] = (oscillator[bar - previous] < 0) ? 1.0 : 0.0;
                Component[3].Value[bar] = (oscillator[bar - previous] > 0) ? 1.0 : 0.0;
            }
            break;

        // 4: "Fast SessionVWAP rises, Slow SessionVWAP falls"
        case 4:
            for(int bar = firstBar + previous; bar < Data.Bars; bar++)
            {
                bool longCond = (fastVWAP[bar - previous] > fastVWAP[bar - previous - 1] + Sigma() &&
                               slowVWAP[bar - previous] < slowVWAP[bar - previous - 1] - Sigma());
                bool shortCond = (fastVWAP[bar - previous] < fastVWAP[bar - previous - 1] - Sigma() &&
                                slowVWAP[bar - previous] > slowVWAP[bar - previous - 1] + Sigma());
                Component[2].Value[bar] = longCond ? 1.0 : 0.0;
                Component[3].Value[bar] = shortCond ? 1.0 : 0.0;
            }
            break;

        // 5: "Fast SessionVWAP falls, Slow SessionVWAP rises"
        case 5:
            for(int bar = firstBar + previous; bar < Data.Bars; bar++)
            {
                bool longCond = (fastVWAP[bar - previous] < fastVWAP[bar - previous - 1] - Sigma() &&
                               slowVWAP[bar - previous] > slowVWAP[bar - previous - 1] + Sigma());
                bool shortCond = (fastVWAP[bar - previous] > fastVWAP[bar - previous - 1] + Sigma() &&
                                slowVWAP[bar - previous] < slowVWAP[bar - previous - 1] - Sigma());
                Component[2].Value[bar] = longCond ? 1.0 : 0.0;
                Component[3].Value[bar] = shortCond ? 1.0 : 0.0;
            }
            break;

        // 6: "Fast SessionVWAP rises, Slow SessionVWAP rises"
        case 6:
            for(int bar = firstBar + previous; bar < Data.Bars; bar++)
            {
                bool longCond = (fastVWAP[bar - previous] > fastVWAP[bar - previous - 1] + Sigma() &&
                               slowVWAP[bar - previous] > slowVWAP[bar - previous - 1] + Sigma());
                bool shortCond = (fastVWAP[bar - previous] < fastVWAP[bar - previous - 1] - Sigma() &&
                                slowVWAP[bar - previous] < slowVWAP[bar - previous - 1] - Sigma());
                Component[2].Value[bar] = longCond ? 1.0 : 0.0;
                Component[3].Value[bar] = shortCond ? 1.0 : 0.0;
            }
            break;

        // 7: "Fast SessionVWAP falls, Slow SessionVWAP falls"
        case 7:
            for(int bar = firstBar + previous; bar < Data.Bars; bar++)
            {
                bool longCond = (fastVWAP[bar - previous] < fastVWAP[bar - previous - 1] - Sigma() &&
                               slowVWAP[bar - previous] < slowVWAP[bar - previous - 1] - Sigma());
                bool shortCond = (fastVWAP[bar - previous] > fastVWAP[bar - previous - 1] + Sigma() &&
                                slowVWAP[bar - previous] > slowVWAP[bar - previous - 1] + Sigma());
                Component[2].Value[bar] = longCond ? 1.0 : 0.0;
                Component[3].Value[bar] = shortCond ? 1.0 : 0.0;
            }
            break;

        default:
            break;
    }
}

//+------------------------------------------------------------------+
//| Calculate Advanced VWAP                                          |
//+------------------------------------------------------------------+
void AdvancedSessionVWAPCrossoverStepped::CalculateAdvancedVWAP(int anchorPeriodIndex, int anchorHour, int anchorMinute, int resetPeriod, double &vwap[])
{
    int bars = Data.Bars;
    ArrayResize(vwap, bars);
    ArrayInitialize(vwap, 0.0);
    
    double cumPV = 0.0;
    double cumV = 0.0;
    datetime currentPeriodTime = 0;

    // We start at bar index = 3
    for(int iBar = 3; iBar < bars; iBar++)
    {
        datetime barTime = Data.Time[iBar];
        datetime periodStart;

        if(anchorPeriodIndex < 3) // Daily, Weekly, Monthly
        {
            // Use AVWAP logic for Daily/Weekly/Monthly
            periodStart = GetAnchorStartTime(barTime, anchorPeriodIndex + 1);
        }
        else // Session
        {
            // Use Session VWAP with stepped times
            datetime adjustedTime = barTime + (Period() * 60);
            periodStart = GetLastResetTimeStepped(adjustedTime, anchorHour, anchorMinute, resetPeriod);
        }

        // If new anchor/reset period → reset cumulatives
        if(periodStart != currentPeriodTime)
        {
            cumPV = 0.0;
            cumV = 0.0;
            currentPeriodTime = periodStart;
        }

        // Typical price = (Open + High + Low + Close) / 4
        double typicalPrice = (Data.Open[iBar] + Data.High[iBar] + Data.Low[iBar] + Data.Close[iBar]) / 4.0;
        double volume = Data.Volume[iBar];

        cumPV += typicalPrice * volume;
        cumV += volume;

        vwap[iBar] = (cumV > 0.0) ? (cumPV / cumV) : 0.0;
    }
}

//+------------------------------------------------------------------+
//| Get Anchor Start Time                                            |
//+------------------------------------------------------------------+
datetime AdvancedSessionVWAPCrossoverStepped::GetAnchorStartTime(datetime currentTime, int anchorType)
{
    // 1 = Daily, 2 = Weekly (Monday), 3 = Monthly
    MqlDateTime s;
    TimeToStruct(currentTime, s);

    switch(anchorType)
    {
        case 1: // Daily
            s.hour = s.min = s.sec = 0;
            break;
        case 2: // Weekly (Monday)
            while(s.day_of_week != 1) // Monday==1
            {
                currentTime -= 86400;
                TimeToStruct(currentTime, s);
            }
            s.hour = s.min = s.sec = 0;
            break;
        case 3: // Monthly
            s.day = 1;
            s.hour = s.min = s.sec = 0;
            break;
        default:
            s.hour = s.min = s.sec = 0;
            break;
    }
    return StructToTime(s);
}

//+------------------------------------------------------------------+
//| Get Last Reset Time Stepped                                      |
//+------------------------------------------------------------------+
datetime AdvancedSessionVWAPCrossoverStepped::GetLastResetTimeStepped(datetime currentTime, int anchorHour, int anchorMinute, int resetPeriod)
{
    MqlDateTime currentMqlTime;
    TimeToStruct(currentTime, currentMqlTime);
    
    // Calculate minutes since midnight for currentTime
    int currentMinutes = currentMqlTime.hour * 60 + currentMqlTime.min;
    int anchorMinutes = anchorHour * 60 + anchorMinute;
    
    datetime lastReset;
    
    if(currentMinutes >= anchorMinutes)
    {
        // Today's anchor has passed
        int minutesSinceAnchor = currentMinutes - anchorMinutes;
        int periodsSinceAnchor = minutesSinceAnchor / resetPeriod;
        int totalOffsetInMinutes = periodsSinceAnchor * resetPeriod;
        
        MqlDateTime resetTime = currentMqlTime;
        resetTime.hour = anchorHour;
        resetTime.min = anchorMinute;
        resetTime.sec = 0;
        lastReset = StructToTime(resetTime) + (totalOffsetInMinutes * 60);
    }
    else
    {
        // Today's anchor hasn't occurred → look back to the previous day
        int minutesSinceMidnight = currentMinutes;
        int minutesSincePrevDayAnchor = (1440 - anchorMinutes) + minutesSinceMidnight;
        int periodsSincePrevDayAnchor = minutesSincePrevDayAnchor / resetPeriod;
        int totalOffsetFromPrevDayAnchorMin = periodsSincePrevDayAnchor * resetPeriod;
        
        MqlDateTime prevDay = currentMqlTime;
        prevDay.day--;
        if(prevDay.day == 0)
        {
            prevDay.mon--;
            if(prevDay.mon == 0)
            {
                prevDay.mon = 12;
                prevDay.year--;
            }
            prevDay.day = TimeDayCount(prevDay);
        }
        MqlDateTime resetTime = prevDay;
        resetTime.hour = anchorHour;
        resetTime.min = anchorMinute;
        resetTime.sec = 0;
        lastReset = StructToTime(resetTime) + (totalOffsetFromPrevDayAnchorMin * 60);
    }
    
    return lastReset;
}

//+------------------------------------------------------------------+
//| Helper function to get days in month                             |
//+------------------------------------------------------------------+
int AdvancedSessionVWAPCrossoverStepped::TimeDayCount(const MqlDateTime &dt)
{
    if(dt.mon == 2)
    {
        // February
        if((dt.year % 4 == 0 && dt.year % 100 != 0) || dt.year % 400 == 0)
            return 29; // Leap year
        else
            return 28;
    }
    else if(dt.mon == 4 || dt.mon == 6 || dt.mon == 9 || dt.mon == 11)
    {
        return 30;
    }
    return 31;
}