refactor: Upgraded with dynamic high-performance Standard/MTF support

Indicators/MyIndicators/SMI_Pro.mq5

@@ -1,9 +1,9 @@
 //+------------------------------------------------------------------+
 //|                                                       SMI_Pro.mq5|
-//|                                          Copyright 2025, xxxxxxxx|
+//|                                          Copyright 2026, xxxxxxxx|
 //+------------------------------------------------------------------+
-#property copyright "Copyright 2025, xxxxxxxx"
+#property copyright "Copyright 2026, xxxxxxxx"
-#property version   "3.01" // Optimized for incremental calculation
+#property version   "3.10" // Upgraded with dynamic high-performance Standard/MTF support
 #property description "Professional Stochastic Momentum Index (SMI) with a signal line and"
 #property description "selectable candle source (Standard or Heikin Ashi)."
 
@@ -38,6 +38,7 @@
 
 //--- Include the calculator engine ---
 #include <MyIncludes\SMI_Calculator.mqh>
+#include <MyIncludes\DataSync_Tools.mqh> // Centralized MTF synchronization daemon
 
 //--- Enum for selecting the candle source for calculation ---
 enum ENUM_CANDLE_SOURCE
@@ -47,6 +48,10 @@ enum ENUM_CANDLE_SOURCE
   };
 
 //--- Input Parameters ---
+input group "--- Timeframe Settings ---"
+input ENUM_TIMEFRAMES           InpTimeframe      = PERIOD_CURRENT;       // Target Higher Timeframe
+
+input group "--- SMI Settings ---"
 input int                InpLengthK      = 10; // %K Length
 input int                InpLengthD      = 3;  // %D Length (for double smoothing)
 input int                InpLengthEMA    = 3;  // EMA Length (for signal line)
@@ -56,45 +61,88 @@ input ENUM_CANDLE_SOURCE InpCandleSource = CANDLE_STANDARD;
 double    BufferSMI[];
 double    BufferSignal[];
 
-//--- Global calculator object (as a base class pointer) ---
+//--- Internal HTF Data Caches
+double    h_open[], h_high[], h_low[], h_close[];
+double    h_res_smi[], h_res_sig[];
+datetime  h_time[];
+
+//--- Global Objects & Synchronizer State
 CSMICalculator *g_calculator;
 
+bool            g_is_mtf_mode         = false;
+ENUM_TIMEFRAMES g_calc_timeframe;
+bool            g_data_ready          = false;
+bool            g_data_synced         = false;
+int             g_htf_count           = 0;
+datetime        g_last_htf_time       = 0;
+
 //+------------------------------------------------------------------+
 //| Custom indicator initialization function.                        |
 //+------------------------------------------------------------------+
 int OnInit()
   {
-//--- Map the buffers and set as non-timeseries
+   g_data_ready    = false;
+   g_data_synced   = false;
+   g_htf_count     = 0;
+   g_last_htf_time = 0;
+
+//--- 1. Resolve Timeframe and validate direction
+   g_calc_timeframe = InpTimeframe;
+   if(g_calc_timeframe == PERIOD_CURRENT)
+      g_calc_timeframe = (ENUM_TIMEFRAMES)Period();
+
+   if(g_calc_timeframe < Period())
+     {
+      PrintFormat("Critical Error: Target timeframe (%s) must be >= current timeframe (%s).",
+                  EnumToString(g_calc_timeframe), EnumToString(Period()));
+      return(INIT_FAILED);
+     }
+   g_is_mtf_mode = (g_calc_timeframe > Period());
+
+//--- 2. Map the buffers and set as non-timeseries
    SetIndexBuffer(0, BufferSMI,    INDICATOR_DATA);
    SetIndexBuffer(1, BufferSignal, INDICATOR_DATA);
    ArraySetAsSeries(BufferSMI,    false);
    ArraySetAsSeries(BufferSignal, false);
 
-//--- Dynamically create the appropriate calculator instance
+//--- 3. Factory Logic for Heikin Ashi price routing
    switch(InpCandleSource)
      {
       case CANDLE_HEIKIN_ASHI:
          g_calculator = new CSMICalculator_HA();
-         IndicatorSetString(INDICATOR_SHORTNAME, StringFormat("SMI HA(%d,%d,%d)", InpLengthK, InpLengthD, InpLengthEMA));
          break;
       default: // CANDLE_STANDARD
          g_calculator = new CSMICalculator();
-         IndicatorSetString(INDICATOR_SHORTNAME, StringFormat("SMI(%d,%d,%d)", InpLengthK, InpLengthD, InpLengthEMA));
          break;
      }
 
-//--- Check if creation was successful and initialize
    if(CheckPointer(g_calculator) == POINTER_INVALID || !g_calculator.Init(InpLengthK, InpLengthD, InpLengthEMA))
      {
-      Print("Failed to create or initialize SMI Calculator object.");
+      Print("Critical Error: Failed to create or initialize SMI Calculator object.");
       return(INIT_FAILED);
      }
 
-//--- Set indicator display properties
+//--- 4. Dynamic Setup of Indicator Shortname and Plots
-   IndicatorSetInteger(INDICATOR_DIGITS, 2);
+   string type = (InpCandleSource == CANDLE_HEIKIN_ASHI) ? " HA" : "";
+   string tf_str = g_is_mtf_mode ? (" " + EnumToString(g_calc_timeframe)) : "";
+   IndicatorSetString(INDICATOR_SHORTNAME, StringFormat("SMI%s%s(%d,%d,%d)", type, tf_str, InpLengthK, InpLengthD, InpLengthEMA));
+
+//--- Drawing offset configuration
    int smi_draw_begin = InpLengthK + InpLengthD + InpLengthD - 3;
+   int sig_draw_begin = smi_draw_begin + InpLengthEMA - 1;
+   if(g_is_mtf_mode)
+     {
+      smi_draw_begin = 0;
+      sig_draw_begin = 0;
+     }
+
    PlotIndexSetInteger(0, PLOT_DRAW_BEGIN, smi_draw_begin);
-   PlotIndexSetInteger(1, PLOT_DRAW_BEGIN, smi_draw_begin + InpLengthEMA - 1);
+   PlotIndexSetInteger(1, PLOT_DRAW_BEGIN, sig_draw_begin);
+   IndicatorSetInteger(INDICATOR_DIGITS, 2);
+
+//--- 5. Initialize Background Synchronization Timer Daemon (Only if MTF is active)
+   if(g_is_mtf_mode)
+      EventSetTimer(1);
 
    return(INIT_SUCCEEDED);
   }
@@ -104,16 +152,16 @@ int OnInit()
 //+------------------------------------------------------------------+
 void OnDeinit(const int reason)
   {
-//--- Free the calculator object to prevent memory leaks
+   EventKillTimer();
    if(CheckPointer(g_calculator) != POINTER_INVALID)
       delete g_calculator;
   }
 
 //+------------------------------------------------------------------+
-//| Custom indicator calculation function.                           |
+//| Custom indicator calculation function                            |
 //+------------------------------------------------------------------+
 int OnCalculate(const int rates_total,
-                const int prev_calculated, // <--- Now used!
+                const int prev_calculated,
                 const datetime &time[],
                 const double &open[],
                 const double &high[],
@@ -123,14 +171,169 @@ int OnCalculate(const int rates_total,
                 const long &volume[],
                 const int &spread[])
   {
+   int required_bars = InpLengthK + InpLengthD + InpLengthD + InpLengthEMA + 10;
+   if(rates_total < required_bars)
+      return 0;
+
    if(CheckPointer(g_calculator) == POINTER_INVALID)
       return 0;
 
-//--- Delegate calculation with prev_calculated optimization
+//--- Force chronological indexing on current timeframe arrays
-   g_calculator.Calculate(rates_total, prev_calculated, open, high, low, close,
+   ArraySetAsSeries(time,  false);
-                          BufferSMI, BufferSignal);
+   ArraySetAsSeries(open,  false);
+   ArraySetAsSeries(high,  false);
+   ArraySetAsSeries(low,   false);
+   ArraySetAsSeries(close, false);
+
+//===================================================================
+// MODE 1: Current Timeframe calculation (Standard ultra-high speed)
+//===================================================================
+   if(!g_is_mtf_mode)
+     {
+      g_calculator.Calculate(rates_total, prev_calculated, open, high, low, close, BufferSMI, BufferSignal);
+      return(rates_total);
+     }
+
+//===================================================================
+// MODE 2: Multi-Timeframe Engine (Warp-free step synchronization)
+//===================================================================
+   if(!CDataSync::EnsureHTFDataReady(_Symbol, g_calc_timeframe, required_bars))
+     {
+      g_data_synced = false;
+      return 0; // Wait for next tick to let history synchronize
+     }
+
+   g_data_synced = true;
+
+//--- Check if a new HTF candle has opened
+   datetime htf_time_current = iTime(_Symbol, g_calc_timeframe, 0);
+   bool htf_updated = (htf_time_current != g_last_htf_time);
+
+   if(htf_updated || prev_calculated == 0)
+     {
+      g_last_htf_time = htf_time_current;
+
+      int htf_bars = iBars(_Symbol, g_calc_timeframe);
+      if(htf_bars < required_bars)
+        {
+         g_data_ready = false;
+         return 0;
+        }
+
+      g_htf_count = MathMin(htf_bars, 3000); // Guard rails to prevent memory overload
+
+      // Resize all HTF caching arrays
+      ArrayResize(h_time,    g_htf_count);
+      ArrayResize(h_open,    g_htf_count);
+      ArrayResize(h_high,    g_htf_count);
+      ArrayResize(h_low,     g_htf_count);
+      ArrayResize(h_close,   g_htf_count);
+      ArrayResize(h_res_smi,  g_htf_count);
+      ArrayResize(h_res_sig,  g_htf_count);
+
+      // Force chronological structure on high-level arrays
+      ArraySetAsSeries(h_time,    false);
+      ArraySetAsSeries(h_open,    false);
+      ArraySetAsSeries(h_high,    false);
+      ArraySetAsSeries(h_low,     false);
+      ArraySetAsSeries(h_close,   false);
+      ArraySetAsSeries(h_res_smi,  false);
+      ArraySetAsSeries(h_res_sig,  false);
+
+      // Copy basic pricing data
+      if(CopyTime(_Symbol,  g_calc_timeframe, 0, g_htf_count, h_time)  != g_htf_count ||
+         CopyOpen(_Symbol,  g_calc_timeframe, 0, g_htf_count, h_open)  != g_htf_count ||
+         CopyHigh(_Symbol,  g_calc_timeframe, 0, g_htf_count, h_high)  != g_htf_count ||
+         CopyLow(_Symbol,   g_calc_timeframe, 0, g_htf_count, h_low)   != g_htf_count ||
+         CopyClose(_Symbol, g_calc_timeframe, 0, g_htf_count, h_close) != g_htf_count)
+        {
+         g_data_ready = false;
+         return 0;
+        }
+
+      //--- Calculate core indicators directly on high timeframe (Initial setup)
+      g_calculator.Calculate(g_htf_count, 0, h_open, h_high, h_low, h_close, h_res_smi, h_res_sig);
+
+      g_data_ready = true;
+     }
+
+   if(!g_data_ready)
+      return 0;
+
+//--- 5. Real-Time Update for the active forming HTF candle (Index: g_htf_count - 1) on every tick
+   int live_idx = g_htf_count - 1;
+   if(live_idx >= required_bars)
+     {
+      double o[1], h[1], l[1], c[1];
+      int shift = iBarShift(_Symbol, g_calc_timeframe, htf_time_current, false);
+      if(shift >= 0 &&
+         CopyOpen(_Symbol,  g_calc_timeframe, shift, 1, o) == 1 &&
+         CopyHigh(_Symbol,  g_calc_timeframe, shift, 1, h) == 1 &&
+         CopyLow(_Symbol,   g_calc_timeframe, shift, 1, l) == 1 &&
+         CopyClose(_Symbol, g_calc_timeframe, shift, 1, c) == 1)
+        {
+         h_open[live_idx]  = o[0];
+         h_high[live_idx]  = h[0];
+         h_low[live_idx]   = l[0];
+         h_close[live_idx] = c[0];
+
+         // Stateful, O(1) mock update for the live bar
+         g_calculator.Calculate(g_htf_count, g_htf_count, h_open, h_high, h_low, h_close, h_res_smi, h_res_sig);
+        }
+     }
+
+//--- 6. Warp-free step force (Staircase Solution anchor determination)
+   int start = (prev_calculated > 0) ? prev_calculated - 1 : 0;
+
+   int first_bar_of_forming_htf = rates_total - 1;
+   while(first_bar_of_forming_htf > 0 &&
+         iBarShift(_Symbol, g_calc_timeframe, time[first_bar_of_forming_htf], false) == 0)
+     {
+      first_bar_of_forming_htf--;
+     }
+   first_bar_of_forming_htf++; // Anchor set to start of current HTF period block
+
+   if(start > first_bar_of_forming_htf)
+      start = first_bar_of_forming_htf;
+
+//--- 7. Map HTF Calculated results cleanly to the lower chart timeframe (O(1) complexity)
+   for(int i = start; i < rates_total; i++)
+     {
+      datetime t = time[i];
+      int shift_htf = iBarShift(_Symbol, g_calc_timeframe, t, false);
+
+      if(shift_htf >= 0)
+        {
+         int idx_htf = g_htf_count - 1 - shift_htf;
+         if(idx_htf >= 0 && idx_htf < g_htf_count)
+           {
+            BufferSMI[i]    = h_res_smi[idx_htf];
+            BufferSignal[i] = h_res_sig[idx_htf];
+           }
+         else
+           {
+            BufferSMI[i]    = EMPTY_VALUE;
+            BufferSignal[i] = EMPTY_VALUE;
+           }
+        }
+      else
+        {
+         BufferSMI[i]    = EMPTY_VALUE;
+         BufferSignal[i] = EMPTY_VALUE;
+        }
+     }
 
    return(rates_total);
   }
+
+//+------------------------------------------------------------------+
+//| OnTimer Event Handler                                            |
+//+------------------------------------------------------------------+
+void OnTimer()
+  {
+//--- Delegate asynchronous history checking and forced redraws to DataSync daemon using correct lookback period
+   int required_bars = InpLengthK + InpLengthD + InpLengthD + InpLengthEMA + 10;
+   CDataSync::OnTimerUpdate(_Symbol, g_calc_timeframe, required_bars, g_data_synced);
+  }
 //+------------------------------------------------------------------+
 //+------------------------------------------------------------------+