#property copyright "Copyright (C) 2024 Forex Software Ltd."
#property link      "http://forexsb.com"
#property version   "1.00"
#property strict

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

//----------------------------------------------------------------------------------
// Class: AVWAPCrossover
//   - This version fixes the indexing mismatch by marking all arrays as “series”.
//   - Any loop that in FSB went from bar=1→Bars–1 is now in MQL from Bars–2→0.
//   - Shift / previous-bar logic is applied in series coordinates.
//----------------------------------------------------------------------------------

class AVWAPCrossover : public Indicator
{
public:
                     AVWAPCrossover(SlotTypes slotType)
     {
      SlotType         = slotType;
      IndicatorName    = "AVWAP Crossover";
      WarningMessage   = "";
      IsAllowLTF       = true;
      ExecTime         = ExecutionTime_DuringTheBar;
      IsSeparateChart  = false;
      IsDiscreteValues = false;
      IsDefaultGroupAll= false;
     }

   virtual void      Calculate(DataSet &dataSet);

private:
   void              CalculateAVWAP(int anchorPeriod, int shift, double &avwap[]);
   datetime          GetAnchorTime(datetime currentTime, int anchorPeriod);
};

//+------------------------------------------------------------------+
//| Main calculation (MQL “series” indexing)                        |
//+------------------------------------------------------------------+
void AVWAPCrossover::Calculate(DataSet &dataSet)
{
   // Grab FSB DataSet pointer; in MQL we’ll only read Data.Open[], Data.Time[], Data.Volume[], etc.
   Data = GetPointer(dataSet);

   // --- 1) Read input parameters exactly as in FSB:
   int fastAnchorPeriod = ListParam[1].Index;      // 0=Daily,1=Weekly,2=Monthly
   int fastShift        = (int)NumParam[0].Value;  // number of bars to shift
   int slowAnchorPeriod = ListParam[2].Index;      // 0=Daily,1=Weekly,2=Monthly
   int slowShift        = (int)NumParam[1].Value;
   int previous         = CheckParam[0].Checked ? 1 : 0;

   // --- 2) Calculate what the “first valid bar” is (still in FSB’s forward‐index sense):
   int firstBarFSB = MathMax(fastShift, slowShift) + previous + 2;
   // We'll convert that to a series index in a moment.

   // --- 3) Build both AVWAP series in FSB‐style (0= oldest, Bars–1= newest):
   double fastAVWAP[];  CalculateAVWAP(fastAnchorPeriod, fastShift, fastAVWAP);
   double slowAVWAP[];  CalculateAVWAP(slowAnchorPeriod, slowShift, slowAVWAP);

   // --- 4) Allocate and mark MQL arrays as “series” so index 0=MOST RECENT bar:
   ArraySetAsSeries(fastAVWAP, true);
   ArraySetAsSeries(slowAVWAP, true);

   //  We also need price/volume arrays in series order:
   ArraySetAsSeries(Data.Open,   true);
   ArraySetAsSeries(Data.High,   true);
   ArraySetAsSeries(Data.Low,    true);
   ArraySetAsSeries(Data.Close,  true);
   ArraySetAsSeries(Data.Volume, true);
   ArraySetAsSeries(Data.Time,   true);

   // --- 5) Create an oscillator buffer (also in series order):
   double oscillator[];
   ArrayResize(oscillator, Data.Bars);
   ArraySetAsSeries(oscillator, true);
   ArrayInitialize(oscillator, 0.0);

   //  We must convert firstBarFSB (FSB’s “forward index”) into a series index:
   //  In FSB: forward index i ↔ MQL series index (si) where si = (Bars–1 – i).
   int firstBarSeries = (Data.Bars - 1) - firstBarFSB;

   //  Compute oscillator = fastAVWAP – slowAVWAP, bar by bar in series order:
   //  iSeries runs 0 = today, 1 = 1 bar ago, …, up to Bars–1 = oldest.
   for(int iSeries = 0; iSeries <= firstBarSeries; iSeries++)
   {
      // nothing to do for iSeries > firstBarSeries, those older bars remain zero.
      break;
   }
   for(int iSeries = firstBarSeries; iSeries >= 0; iSeries--)
   {
      oscillator[iSeries] = fastAVWAP[iSeries] - slowAVWAP[iSeries];
   }

   // --- 6) Populate the indicator’s four components (all in series order):
   // [0] = Fast AVWAP line, [1] = Slow AVWAP line, [2] = Long‐filter, [3] = Short‐filter
   ArrayResize(Component[0].Value, Data.Bars);
   ArraySetAsSeries(Component[0].Value, true);
   Component[0].CompName = "Fast AVWAP";
   Component[0].DataType = IndComponentType_IndicatorValue;
   Component[0].FirstBar = firstBarSeries; // in series indexing
   ArrayCopy(Component[0].Value, fastAVWAP);

   ArrayResize(Component[1].Value, Data.Bars);
   ArraySetAsSeries(Component[1].Value, true);
   Component[1].CompName = "Slow AVWAP";
   Component[1].DataType = IndComponentType_IndicatorValue;
   Component[1].FirstBar = firstBarSeries;
   ArrayCopy(Component[1].Value, slowAVWAP);

   ArrayResize(Component[2].Value, Data.Bars);
   ArraySetAsSeries(Component[2].Value, true);
   Component[2].FirstBar = firstBarSeries;

   ArrayResize(Component[3].Value, Data.Bars);
   ArraySetAsSeries(Component[3].Value, true);
   Component[3].FirstBar = firstBarSeries;

   // Assign DataType/CompName for the two filter buffers:
   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 // 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) Now apply the chosen logic. Each “cross/above/below” condition expects
   //     a level line of 0.0 on the oscillator (series indexing).
   IndicatorLogic indLogic = IndicatorLogic_It_does_not_act_as_a_filter;
   string        logic    = ListParam[0].Text;

   if(logic == "Fast AVWAP crosses Slow AVWAP upward")
      indLogic = IndicatorLogic_The_indicator_crosses_the_level_line_upward;
   else if(logic == "Fast AVWAP crosses Slow AVWAP downward")
      indLogic = IndicatorLogic_The_indicator_crosses_the_level_line_downward;
   else if(logic == "Fast AVWAP is higher than Slow AVWAP")
      indLogic = IndicatorLogic_The_indicator_is_higher_than_the_level_line;
   else if(logic == "Fast AVWAP is lower than Slow AVWAP")
      indLogic = IndicatorLogic_The_indicator_is_lower_than_the_level_line;
   else if(logic == "Fast AVWAP rises, Slow AVWAP falls")
   {
      // Since everything is already in series order, “bar–1” means “one older bar”:
      for(int iSeries = firstBarSeries - previous; iSeries >= 1; iSeries--)
      {
         bool fastRises = fastAVWAP[iSeries - previous] > fastAVWAP[iSeries - previous - 1] + Sigma();
         bool slowFalls = slowAVWAP[iSeries - previous] < slowAVWAP[iSeries - previous - 1] - Sigma();
         Component[2].Value[iSeries] = (fastRises && slowFalls) ? 1.0 : 0.0;

         bool fastFalls = fastAVWAP[iSeries - previous] < fastAVWAP[iSeries - previous - 1] - Sigma();
         bool slowRises = slowAVWAP[iSeries - previous] > slowAVWAP[iSeries - previous - 1] + Sigma();
         Component[3].Value[iSeries] = (fastFalls && slowRises) ? 1.0 : 0.0;
      }
   }
   else if(logic == "Fast AVWAP falls, Slow AVWAP rises")
   {
      for(int iSeries = firstBarSeries - previous; iSeries >= 1; iSeries--)
      {
         bool fastFalls = fastAVWAP[iSeries - previous] < fastAVWAP[iSeries - previous - 1] - Sigma();
         bool slowRises = slowAVWAP[iSeries - previous] > slowAVWAP[iSeries - previous - 1] + Sigma();
         Component[2].Value[iSeries] = (fastFalls && slowRises) ? 1.0 : 0.0;

         bool fastRises = fastAVWAP[iSeries - previous] > fastAVWAP[iSeries - previous - 1] + Sigma();
         bool slowFalls = slowAVWAP[iSeries - previous] < slowAVWAP[iSeries - previous - 1] - Sigma();
         Component[3].Value[iSeries] = (fastRises && slowFalls) ? 1.0 : 0.0;
      }
   }
   else if(logic == "Fast AVWAP rises, Slow AVWAP rises")
   {
      for(int iSeries = firstBarSeries - previous; iSeries >= 1; iSeries--)
      {
         bool fastRises = fastAVWAP[iSeries - previous] > fastAVWAP[iSeries - previous - 1] + Sigma();
         bool slowRises = slowAVWAP[iSeries - previous] > slowAVWAP[iSeries - previous - 1] + Sigma();
         Component[2].Value[iSeries] = (fastRises && slowRises) ? 1.0 : 0.0;

         bool fastFalls = fastAVWAP[iSeries - previous] < fastAVWAP[iSeries - previous - 1] - Sigma();
         bool slowFalls = slowAVWAP[iSeries - previous] < slowAVWAP[iSeries - previous - 1] - Sigma();
         Component[3].Value[iSeries] = (fastFalls && slowFalls) ? 1.0 : 0.0;
      }
   }
   else if(logic == "Fast AVWAP falls, Slow AVWAP falls")
   {
      for(int iSeries = firstBarSeries - previous; iSeries >= 1; iSeries--)
      {
         bool fastFalls = fastAVWAP[iSeries - previous] < fastAVWAP[iSeries - previous - 1] - Sigma();
         bool slowFalls = slowAVWAP[iSeries - previous] < slowAVWAP[iSeries - previous - 1] - Sigma();
         Component[2].Value[iSeries] = (fastFalls && slowFalls) ? 1.0 : 0.0;

         bool fastRises = fastAVWAP[iSeries - previous] > fastAVWAP[iSeries - previous - 1] + Sigma();
         bool slowRises = slowAVWAP[iSeries - previous] > slowAVWAP[iSeries - previous - 1] + Sigma();
         Component[3].Value[iSeries] = (fastRises && slowRises) ? 1.0 : 0.0;
      }
   }

   // --- 8) If the selected logic was one of the first four (“crosses” / “higher” / “lower”), apply OscillatorLogic:
   if(indLogic != IndicatorLogic_It_does_not_act_as_a_filter)
   {
      OscillatorLogic(
         firstBarSeries,   // series‐indexed first bar
         previous,         // use previous bar value
         oscillator,       // oscillator is already in series order
         0.0,              // level‐line = zero (series)
         0.0,              // unused
         Component[2],     // long‐filter buffer (series)
         Component[3],     // short‐filter buffer (series)
         indLogic
      );
   }
}

//+------------------------------------------------------------------+
//| Calculate a single AVWAP buffer, in FSB “forward” indexing.      |
//| After computing, we flip to series order at caller.             |
//+------------------------------------------------------------------+
void AVWAPCrossover::CalculateAVWAP(int anchorPeriod, int shift, double &avwap[])
{
   int totalBars = Data.Bars;
   ArrayResize(avwap, totalBars);
   ArrayInitialize(avwap, 0.0);

   double cumPV           = 0.0;
   double cumVol          = 0.0;
   datetime currentAnchor = 0;

   // FSB “forward” loop: 0=oldest, Bars–1=newest
   for(int bar = 1; bar < totalBars; bar++)
   {
      datetime barTime    = Data.Time[bar];
      datetime anchorTime = GetAnchorTime(barTime, anchorPeriod);

      if(anchorTime != currentAnchor)
      {
         cumPV           = 0.0;
         cumVol          = 0.0;
         currentAnchor   = anchorTime;
      }

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

      cumPV  += typicalPrice * volume;
      cumVol += volume;

      avwap[bar] = (cumVol > 0.0) ? (cumPV / cumVol) : 0.0;
   }

   // Apply the FSB‐style “shift” in forward indexing,
   // then at caller we’ll flip the entire array to series.
   double temp[];
   ArrayResize(temp, totalBars);
   ArrayCopy(temp, avwap);

   for(int bar = 0; bar < totalBars; bar++)
   {
      int src = bar - shift;
      if(src >= 0 && src < totalBars)
         avwap[bar] = temp[src];
      else
         avwap[bar] = 0.0;
   }
}

//+------------------------------------------------------------------+
//| Get the anchor‐start time (daily, weekly, or monthly) in forward |
//| indexing. Returns a datetime that changes whenever a new period  |
//| begins (FSB style).                                              |
//+------------------------------------------------------------------+
datetime AVWAPCrossover::GetAnchorTime(datetime currentTime, int anchorPeriod)
{
   MqlDateTime dt;
   TimeToStruct(currentTime, dt);

   switch(anchorPeriod)
   {
      case 0: // Daily
         dt.hour = 0; dt.min = 0; dt.sec = 0;
         break;

      case 1: // Weekly (Monday)
         while(dt.day_of_week != 1)  // Monday == 1
         {
            currentTime -= 86400;   // subtract one day
            TimeToStruct(currentTime, dt);
         }
         dt.hour = 0; dt.min = 0; dt.sec = 0;
         break;

      case 2: // Monthly
         dt.day  = 1; dt.hour = 0; dt.min = 0; dt.sec = 0;
         break;
   }

   return StructToTime(dt);
}