//+------------------------------------------------------------------+
//| UnifiedHullMA.mq5                                                |
//|                                                                  |
//| Hull Moving Average calculation built around the work of         |
//| Mladen Rakic.                                                    |
//|                                                                  |
//| This implementation extends that foundation with multiple Hull   |
//| periods, directional colouring, configurable Hull lines, stable   |
//| buffer layout, and ring-buffer based memory management.          |
//|                                                                  |
//| Copyright © 2026 Alfonso Golden Trader                            |
//+------------------------------------------------------------------+
#property copyright "Copyright 2026, C.J. Weekes"
#property copyright "Copyright 2026, Alfonso Golden Trader"
#property version   "1.00"
#property description "Hull Moving Average indicator with four periods on a single chart."
#property description "Colour-coded by direction. Ring-buffer memory management."
#property description "Buffer layout: 0/1=Hull1, 2/3=Hull2, 4/5=Hull3, 6/7=Hull4."

#property indicator_chart_window
#property indicator_buffers 8
#property indicator_plots   4

//--- Hull Line 1 (Buffer 0/1)
#property indicator_type1   DRAW_COLOR_LINE
#property indicator_color1  clrGray, clrLime, clrRed
#property indicator_width1  2
#property indicator_label1  "Hull1"

//--- Hull Line 2 (Buffer 2/3)
#property indicator_type2   DRAW_COLOR_LINE
#property indicator_color2  clrGray, clrDodgerBlue, clrOrangeRed
#property indicator_width2  2
#property indicator_label2  "Hull2"

//--- Hull Line 3 (Buffer 4/5)
#property indicator_type3   DRAW_COLOR_LINE
#property indicator_color3  clrGray, clrAqua, clrMagenta
#property indicator_width3  2
#property indicator_label3  "Hull3"

//--- Hull Line 4 (Buffer 6/7)
#property indicator_type4   DRAW_COLOR_LINE
#property indicator_color4  clrGray, clrGold, clrDarkOrchid
#property indicator_width4  2
#property indicator_label4  "Hull4"

//--- Input parameters
input int InpPeriod1   = 8;    // Hull 1 Period
input int InpPeriod2   = 20;   // Hull 2 Period
input int InpPeriod3   = 50;   // Hull 3 Period
input int InpPeriod4   = 200;  // Hull 4 Period
input int InpDivisor   = 2;    // Hull Divisor
input int InpMaxBars   = 5000; // Max bars to retain (0 = unlimited)

//--- Indicator buffers
double hull1Buffer[], color1Buffer[];
double hull2Buffer[], color2Buffer[];
double hull3Buffer[], color3Buffer[];
double hull4Buffer[], color4Buffer[];

//+------------------------------------------------------------------+
//| CHull class - memory-optimized Hull MA calculator                |
//+------------------------------------------------------------------+
class CHull
{
private:
   int m_fullPeriod;
   int m_halfPeriod;
   int m_sqrtPeriod;
   int m_maxBars;
   int m_arraySize;
   double m_weight1;
   double m_weight2;
   double m_weight3;
   double m_divisor;

   struct sHullArrayStruct
   {
      double value;
      double value3;
      double wsum1;
      double wsum2;
      double wsum3;
      double lsum1;
      double lsum2;
      double lsum3;
   };

   sHullArrayStruct m_array[];

   void ZeroArray()
   {
      for(int i = 0; i < m_arraySize; i++)
      {
         m_array[i].value  = 0;
         m_array[i].value3 = 0;
         m_array[i].wsum1  = 0;
         m_array[i].wsum2  = 0;
         m_array[i].wsum3  = 0;
         m_array[i].lsum1  = 0;
         m_array[i].lsum2  = 0;
         m_array[i].lsum3  = 0;
      }
   }

public:
   CHull() : m_fullPeriod(1), m_halfPeriod(1), m_sqrtPeriod(1),
             m_maxBars(0), m_arraySize(0), m_divisor(2.0) { }
   ~CHull() { ArrayFree(m_array); }

   bool init(int period, double divisor, int maxBars=0)
   {
      m_divisor    = (divisor > 1.0) ? divisor : 2.0;
      m_fullPeriod = (int)(period > 1 ? period : 1);
      m_halfPeriod = (int)(m_fullPeriod > 1 ? m_fullPeriod / m_divisor : 1);
      m_sqrtPeriod = (int)MathSqrt(m_fullPeriod);
      m_maxBars    = (maxBars > m_fullPeriod * 2) ? maxBars : 0;
      m_arraySize  = 0;
      m_weight1    = m_weight2 = m_weight3 = 1;

      if(m_maxBars > 0)
      {
         m_arraySize = ArrayResize(m_array, m_maxBars);
         if(m_arraySize < m_maxBars) return false;
         ZeroArray();
      }
      return true;
   }

   double calculate(double value, int i, int bars)
   {
      if(m_maxBars <= 0)
      {
         if(m_arraySize < bars)
         {
            m_arraySize = ArrayResize(m_array, bars + 500);
            if(m_arraySize < bars) return 0;
         }
         return CalculateUnlimited(value, i);
      }
      return CalculateRingBuffer(value, i);
   }

private:
   double CalculateUnlimited(double value, int i)
   {
      m_array[i].value = value;

      if(i > m_fullPeriod)
      {
         m_array[i].wsum1 = m_array[i-1].wsum1 + value * m_halfPeriod - m_array[i-1].lsum1;
         m_array[i].lsum1 = m_array[i-1].lsum1 + value - m_array[i-m_halfPeriod].value;
         m_array[i].wsum2 = m_array[i-1].wsum2 + value * m_fullPeriod - m_array[i-1].lsum2;
         m_array[i].lsum2 = m_array[i-1].lsum2 + value - m_array[i-m_fullPeriod].value;
      }
      else
      {
         m_array[i].wsum1 = m_array[i].wsum2 =
         m_array[i].lsum1 = m_array[i].lsum2 = m_weight1 = m_weight2 = 0;
         for(int k=0, w1=m_halfPeriod, w2=m_fullPeriod; w2>0 && i>=k; k++, w1--, w2--)
         {
            if(w1>0)
            {
               m_array[i].wsum1 += m_array[i-k].value * w1;
               m_array[i].lsum1 += m_array[i-k].value;
               m_weight1        += w1;
            }
            m_array[i].wsum2 += m_array[i-k].value * w2;
            m_array[i].lsum2 += m_array[i-k].value;
            m_weight2        += w2;
         }
      }

      m_array[i].value3 = 2.0 * m_array[i].wsum1 / m_weight1 - m_array[i].wsum2 / m_weight2;

      if(i > m_sqrtPeriod)
      {
         m_array[i].wsum3 = m_array[i-1].wsum3 + m_array[i].value3 * m_sqrtPeriod - m_array[i-1].lsum3;
         m_array[i].lsum3 = m_array[i-1].lsum3 + m_array[i].value3 - m_array[i-m_sqrtPeriod].value3;
      }
      else
      {
         m_array[i].wsum3 =
         m_array[i].lsum3 = m_weight3 = 0;
         for(int k=0, w3=m_sqrtPeriod; w3>0 && i>=k; k++, w3--)
         {
            m_array[i].wsum3 += m_array[i-k].value3 * w3;
            m_array[i].lsum3 += m_array[i-k].value3;
            m_weight3        += w3;
         }
      }

      return(m_array[i].wsum3 / m_weight3);
   }

   double CalculateRingBuffer(double value, int i)
   {
      int idx     = i % m_maxBars;
      int prevIdx = (i > 0) ? (i-1) % m_maxBars : idx;

      m_array[idx].value = value;

      if(i > m_fullPeriod)
      {
         int halfBackIdx = (i - m_halfPeriod) % m_maxBars;
         int fullBackIdx = (i - m_fullPeriod) % m_maxBars;

         m_array[idx].wsum1 = m_array[prevIdx].wsum1 + value * m_halfPeriod - m_array[prevIdx].lsum1;
         m_array[idx].lsum1 = m_array[prevIdx].lsum1 + value - m_array[halfBackIdx].value;
         m_array[idx].wsum2 = m_array[prevIdx].wsum2 + value * m_fullPeriod - m_array[prevIdx].lsum2;
         m_array[idx].lsum2 = m_array[prevIdx].lsum2 + value - m_array[fullBackIdx].value;
      }
      else
      {
         m_array[idx].wsum1 = m_array[idx].wsum2 =
         m_array[idx].lsum1 = m_array[idx].lsum2 = m_weight1 = m_weight2 = 0;
         for(int k=0, w1=m_halfPeriod, w2=m_fullPeriod; w2>0 && i>=k; k++, w1--, w2--)
         {
            int backIdx = (i - k) % m_maxBars;
            if(w1>0)
            {
               m_array[idx].wsum1 += m_array[backIdx].value * w1;
               m_array[idx].lsum1 += m_array[backIdx].value;
               m_weight1          += w1;
            }
            m_array[idx].wsum2 += m_array[backIdx].value * w2;
            m_array[idx].lsum2 += m_array[backIdx].value;
            m_weight2          += w2;
         }
      }

      m_array[idx].value3 = 2.0 * m_array[idx].wsum1 / m_weight1 - m_array[idx].wsum2 / m_weight2;

      if(i > m_sqrtPeriod)
      {
         int sqrtBackIdx = (i - m_sqrtPeriod) % m_maxBars;
         m_array[idx].wsum3 = m_array[prevIdx].wsum3 + m_array[idx].value3 * m_sqrtPeriod - m_array[prevIdx].lsum3;
         m_array[idx].lsum3 = m_array[prevIdx].lsum3 + m_array[idx].value3 - m_array[sqrtBackIdx].value3;
      }
      else
      {
         m_array[idx].wsum3 =
         m_array[idx].lsum3 = m_weight3 = 0;
         for(int k=0, w3=m_sqrtPeriod; w3>0 && i>=k; k++, w3--)
         {
            int backIdx = (i - k) % m_maxBars;
            m_array[idx].wsum3 += m_array[backIdx].value3 * w3;
            m_array[idx].lsum3 += m_array[backIdx].value3;
            m_weight3          += w3;
         }
      }

      return(m_array[idx].wsum3 / m_weight3);
   }
};

CHull iHull1, iHull2, iHull3, iHull4;

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
{
   SetIndexBuffer(0, hull1Buffer,   INDICATOR_DATA);
   SetIndexBuffer(1, color1Buffer,  INDICATOR_COLOR_INDEX);
   SetIndexBuffer(2, hull2Buffer,   INDICATOR_DATA);
   SetIndexBuffer(3, color2Buffer,  INDICATOR_COLOR_INDEX);
   SetIndexBuffer(4, hull3Buffer,   INDICATOR_DATA);
   SetIndexBuffer(5, color3Buffer,  INDICATOR_COLOR_INDEX);
   SetIndexBuffer(6, hull4Buffer,   INDICATOR_DATA);
   SetIndexBuffer(7, color4Buffer,  INDICATOR_COLOR_INDEX);

   iHull1.init(InpPeriod1, InpDivisor, InpMaxBars);
   iHull2.init(InpPeriod2, InpDivisor, InpMaxBars);
   iHull3.init(InpPeriod3, InpDivisor, InpMaxBars);
   iHull4.init(InpPeriod4, InpDivisor, InpMaxBars);

   IndicatorSetString(INDICATOR_SHORTNAME,
      StringFormat("UnifiedHullMA(%d,%d,%d,%d)",
                   InpPeriod1, InpPeriod2, InpPeriod3, InpPeriod4));
   IndicatorSetInteger(INDICATOR_DIGITS, _Digits);

   return INIT_SUCCEEDED;
}

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
{
   int i = prev_calculated - 1;
   if(i < 0) i = 0;

   for(; i < rates_total && !_StopFlag; i++)
   {
      double price = close[i];

      hull1Buffer[i] = iHull1.calculate(price, i, rates_total);
      hull2Buffer[i] = iHull2.calculate(price, i, rates_total);
      hull3Buffer[i] = iHull3.calculate(price, i, rates_total);
      hull4Buffer[i] = iHull4.calculate(price, i, rates_total);

      if(i > 0)
      {
         color1Buffer[i] = (hull1Buffer[i] > hull1Buffer[i-1]) ? 1 :
                           ((hull1Buffer[i] < hull1Buffer[i-1]) ? 2 : color1Buffer[i-1]);
         color2Buffer[i] = (hull2Buffer[i] > hull2Buffer[i-1]) ? 1 :
                           ((hull2Buffer[i] < hull2Buffer[i-1]) ? 2 : color2Buffer[i-1]);
         color3Buffer[i] = (hull3Buffer[i] > hull3Buffer[i-1]) ? 1 :
                           ((hull3Buffer[i] < hull3Buffer[i-1]) ? 2 : color3Buffer[i-1]);
         color4Buffer[i] = (hull4Buffer[i] > hull4Buffer[i-1]) ? 1 :
                           ((hull4Buffer[i] < hull4Buffer[i-1]) ? 2 : color4Buffer[i-1]);
      }
      else
      {
         color1Buffer[i] = color2Buffer[i] = color3Buffer[i] = color4Buffer[i] = 0;
      }
   }
   return rates_total;
}
//+------------------------------------------------------------------+