Universal_Quant_EA/Include/UQ_Symbols.mqh

//+------------------------------------------------------------------+
//|                                                  UQ_Symbols.mqh |
//|     Universal Quant EA - symbol resolution and signal engine     |
//|                                                                  |
//|  Deterministic volatility-normalised channel breakout:           |
//|    long  : completed close > highest high of the preceding       |
//|            lookback window AND completed close > EMA              |
//|    short : completed close < lowest low of the preceding          |
//|            lookback window AND completed close < EMA              |
//|  Only completed candles are used; the forming bar is never read   |
//|  for confirmation.                                               |
//|                                                                  |
//|  Resolution fails closed. An exact catalogue name is used when it  |
//|  exists; a broker prefix/suffix variant is accepted only when the  |
//|  broker convention is verified and exactly one eligible           |
//|  instrument remains; anything else is reported as an error. No    |
//|  arbitrary candidate is ever chosen.                              |
//+------------------------------------------------------------------+
#ifndef UQ_SYMBOLS_MQH
#define UQ_SYMBOLS_MQH

#include "UQ_Defs.mqh"

//+------------------------------------------------------------------+
//| Per-symbol runtime state                                         |
//+------------------------------------------------------------------+
struct UQSymbol
  {
   string            requested;      // token supplied by the operator
   string            name;           // resolved broker symbol
   bool              resolved;
   int               hEma;           // EMA trend filter handle
   int               hAtr;           // ATR handle
   datetime          lastBar;        // last observed signal-bar open time
   datetime          lastEntryBar;   // signal bar already acted upon
   datetime          lastLogTime;    // throttling for repeated diagnostics
   string            lastNote;
  };

//+------------------------------------------------------------------+
//| Split a catalogue name around a token: name = prefix+token+suffix |
//| Returns false when the token is absent or the surrounding          |
//| extension is implausibly long for a broker prefix/suffix tag.      |
//+------------------------------------------------------------------+
bool UQSymbolExtension(const string name, const string token,
                       string &extPrefix, string &extSuffix)
  {
   extPrefix = "";
   extSuffix = "";

   if(StringLen(name) <= 0 || StringLen(token) <= 0)
      return(false);

   string upperName  = name;
   string upperToken = token;
   StringToUpper(upperName);
   StringToUpper(upperToken);

   const int pos = StringFind(upperName, upperToken);
   if(pos < 0)
      return(false);

   extPrefix = StringSubstr(name, 0, pos);
   extSuffix = StringSubstr(name, pos + StringLen(token));
   if(StringLen(extPrefix) + StringLen(extSuffix) > UQ_SYMBOL_EXT_MAX_LEN)
      return(false);

   return(true);
  }

//+------------------------------------------------------------------+
//| Standard pairs used to infer this broker's prefix/suffix layout. |
//| The list is fixed so detection stays deterministic across runs.   |
//+------------------------------------------------------------------+
string UQProbeSymbol(const int index)
  {
   switch(index)
     {
      case 0: return("EURUSD");
      case 1: return("GBPUSD");
      case 2: return("USDJPY");
      case 3: return("USDCHF");
      case 4: return("AUDUSD");
      case 5: return("USDCAD");
      case 6: return("NZDUSD");
      case 7: return("EURJPY");
      case 8: return("EURGBP");
      case 9: return("GBPJPY");
     }
   return("");
  }

//+------------------------------------------------------------------+
//| Verify the broker symbol naming convention.                      |
//|                                                                  |
//| A convention is only trusted when several independent standard    |
//| pairs agree on the same prefix/suffix, so a single broker name    |
//| that happens to contain a pair token can never define it. When    |
//| no convention is verified the tag stays empty and the resolver     |
//| falls back to an explicit ambiguity error instead of guessing.     |
//+------------------------------------------------------------------+
bool UQDetectBrokerTag(string &tagPrefix, string &tagSuffix)
  {
   tagPrefix = "";
   tagSuffix = "";

   string keys[];
   int    counts[];
   int    distinct  = 0;
   int    totalVote = 0;

   const int catalogue = SymbolsTotal(false);

   for(int probe = 0; probe < UQ_SYMBOL_PROBE_MAX; probe++)
     {
      const string token = UQProbeSymbol(probe);
      if(StringLen(token) <= 0)
         break;

      string bestPre  = "";
      string bestSuf  = "";
      int    bestLen  = -1;
      int    tightest = 0;

      for(int i = 0; i < catalogue; i++)
        {
         const string name = SymbolName(i, false);
         string pre = "";
         string suf = "";
         if(!UQSymbolExtension(name, token, pre, suf))
            continue;

         const int len = StringLen(pre) + StringLen(suf);
         if(bestLen < 0 || len < bestLen)
           {
            bestLen  = len;
            bestPre  = pre;
            bestSuf  = suf;
            tightest = 1;
            continue;
           }
         if(len == bestLen)
            tightest++;
        }

      //--- a probe with no candidate, or with several equally tight
      //--- candidates, cannot vote for a convention
      if(tightest != 1)
         continue;

      const string key = bestPre + "|" + bestSuf;
      int slot = -1;
      for(int k = 0; k < distinct; k++)
        {
         if(keys[k] == key)
           {
            slot = k;
            break;
           }
        }
      if(slot < 0)
        {
         ArrayResize(keys, distinct + 1);
         ArrayResize(counts, distinct + 1);
         keys[distinct]   = key;
         counts[distinct] = 0;
         slot             = distinct;
         distinct++;
        }
      counts[slot]++;
      totalVote++;
     }

   if(distinct <= 0 || totalVote <= 0)
      return(false);

   int bestVotes = 0;
   int best      = -1;
   for(int k = 0; k < distinct; k++)
     {
      if(counts[k] > bestVotes)
        {
         bestVotes = counts[k];
         best      = k;
        }
     }

   if(best < 0 || bestVotes < UQ_SYMBOL_PROBE_MIN_VOTES)
      return(false);
   if(bestVotes * 2 <= totalVote)
      return(false);          // a weak majority is not a verified convention

   const string key = keys[best];
   const int    sep = StringFind(key, "|");
   if(sep < 0)
      return(false);

   tagPrefix = StringSubstr(key, 0, sep);
   tagSuffix = StringSubstr(key, sep + 1);
   return(true);
  }

//+------------------------------------------------------------------+
//| Fail-closed deterministic resolution of one requested symbol.    |
//|                                                                  |
//|  1. unique exact catalogue name, in either letter case           |
//|  2. unique eligible broker prefix/suffix variant                 |
//|  3. the verified broker convention, when it leaves exactly one   |
//|  4. otherwise EMPTY / NOT_FOUND / AMBIGUOUS / INELIGIBLE         |
//+------------------------------------------------------------------+
ENUM_UQ_RESOLVE UQResolveSymbol(const string requested,
                                const string tagPrefix, const string tagSuffix,
                                string &resolved, string &detail)
  {
   resolved = "";
   detail   = "";

   string token = requested;
   StringTrimLeft(token);
   StringTrimRight(token);
   if(StringLen(token) <= 0)
     {
      detail = "the requested symbol is empty";
      return(UQ_RESOLVE_EMPTY);
     }

   string tokenUpper = token;
   StringToUpper(tokenUpper);

   //--- 1) exact catalogue name
   string exact      = "";
   int    exactCount = 0;
   const int catalogue = SymbolsTotal(false);

   for(int i = 0; i < catalogue; i++)
     {
      const string name = SymbolName(i, false);
      if(StringLen(name) <= 0)
         continue;

      string upper = name;
      StringToUpper(upper);
      if(upper != tokenUpper)
         continue;

      exact = name;
      exactCount++;
     }

   if(exactCount > 1)
     {
      detail = "more than one catalogue symbol matches the request exactly";
      return(UQ_RESOLVE_AMBIGUOUS);
     }

   if(exactCount == 1)
     {
      SymbolSelect(exact, true);
      string why = "";
      if(!UQSymbolEligible(exact, why))
        {
         detail = "'" + exact + "' cannot be traded by this strategy: " + why;
         return(UQ_RESOLVE_INELIGIBLE);
        }
      resolved = exact;
      return(UQ_RESOLVE_OK);
     }

   //--- 2) broker prefix/suffix variants
   string candidates[UQ_SYMBOL_CANDIDATE_MAX];
   int    candidateCount = 0;

   for(int i = 0; i < catalogue; i++)
     {
      const string name = SymbolName(i, false);
      if(StringLen(name) <= 0)
         continue;

      string pre = "";
      string suf = "";
      if(!UQSymbolExtension(name, token, pre, suf))
         continue;
      if(StringLen(pre) + StringLen(suf) == 0)
         continue;                       // identical name, handled above

      if(candidateCount >= UQ_SYMBOL_CANDIDATE_MAX)
        {
         detail = "too many broker variants carry the requested token; specify the exact broker symbol name";
         return(UQ_RESOLVE_AMBIGUOUS);
        }

      candidates[candidateCount] = name;
      candidateCount++;
     }

   if(candidateCount <= 0)
     {
      detail = "no broker symbol carries the requested token";
      return(UQ_RESOLVE_NOT_FOUND);
     }

   //--- only an eligible instrument may be selected
   string eligible[UQ_SYMBOL_CANDIDATE_MAX];
   int    eligibleCount = 0;
   string eligibleList  = "";
   string firstReason   = "";

   for(int i = 0; i < candidateCount; i++)
     {
      SymbolSelect(candidates[i], true);
      string why = "";
      if(UQSymbolEligible(candidates[i], why))
        {
         eligible[eligibleCount] = candidates[i];
         eligibleCount++;
         if(StringLen(eligibleList) > 0)
            eligibleList += ", ";
         eligibleList += candidates[i];
         continue;
        }
      if(StringLen(firstReason) == 0)
         firstReason = "'" + candidates[i] + "' cannot be traded by this strategy: " + why;
     }

   if(eligibleCount == 1)
     {
      resolved = eligible[0];
      return(UQ_RESOLVE_OK);
     }

   if(eligibleCount <= 0)
     {
      detail = (StringLen(firstReason) > 0 ? firstReason :
                "no eligible FX instrument carries the requested token");
      return(UQ_RESOLVE_INELIGIBLE);
     }

   //--- 3) the verified broker convention breaks the tie
   if(StringLen(tagPrefix) + StringLen(tagSuffix) > 0)
     {
      string tagged[UQ_SYMBOL_CANDIDATE_MAX];
      int    taggedCount = 0;
      string taggedList  = "";

      for(int i = 0; i < eligibleCount; i++)
        {
         string pre = "";
         string suf = "";
         if(!UQSymbolExtension(eligible[i], token, pre, suf))
            continue;
         if(pre != tagPrefix || suf != tagSuffix)
            continue;

         tagged[taggedCount] = eligible[i];
         taggedCount++;
         if(StringLen(taggedList) > 0)
            taggedList += ", ";
         taggedList += eligible[i];
        }

      if(taggedCount == 1)
        {
         resolved = tagged[0];
         return(UQ_RESOLVE_OK);
        }
      if(taggedCount > 1)
        {
         detail = "the verified broker convention still matches several instruments: " + taggedList;
         return(UQ_RESOLVE_AMBIGUOUS);
        }
     }

   detail = "ambiguous request; eligible candidates: " + eligibleList;
   return(UQ_RESOLVE_AMBIGUOUS);
  }

//+------------------------------------------------------------------+
//| Symbol registry and signal engine                                |
//+------------------------------------------------------------------+
class CUQSymbols
  {
private:
   UQSymbol          m_sym[];
   int               m_count;
   int               m_skipped;
   bool              m_requireAll;
   ENUM_TIMEFRAMES   m_tf;
   int               m_channel;
   int               m_emaPeriod;
   int               m_atrPeriod;
   string            m_tagPrefix;
   string            m_tagSuffix;
   string            m_lastError;

public:
   CUQSymbols(void);
  ~CUQSymbols(void);

   bool              Init(const ENUM_UQ_SYMBOL_MODE mode, const string list,
                          const ENUM_TIMEFRAMES tf, const int channel,
                          const int emaPeriod, const int atrPeriod,
                          const bool requireAll);
   void              Deinit(void);

   int               Count(void)  const { return(m_count);   }
   int               Skipped(void) const { return(m_skipped); }
   string            LastError(void) const { return(m_lastError); }
   string            TagText(void) const;

   string            Name(const int idx) const;
   string            Requested(const int idx) const;
   int               FindByName(const string name) const;

   datetime          LastEntryBar(const int idx) const;
   void              SetLastEntryBar(const int idx, const datetime t);

   bool              EnsureHandles(const int idx);
   bool              IsNewBar(const int idx, datetime &barTime);
   bool              EvaluateSignal(const int idx, int &direction, double &atrOut, string &reason);
   double            AtrValue(const int idx);

   void              Note(const int idx, const string text, const bool throttle);
  };

//+------------------------------------------------------------------+
CUQSymbols::CUQSymbols(void)
  {
   m_count     = 0;
   m_skipped   = 0;
   m_requireAll = true;
   m_tf        = PERIOD_H1;
   m_channel   = 20;
   m_emaPeriod = 100;
   m_atrPeriod = 14;
   m_tagPrefix = "";
   m_tagSuffix = "";
   m_lastError = "";
   ArrayResize(m_sym, 0);
  }

//+------------------------------------------------------------------+
CUQSymbols::~CUQSymbols(void)
  {
   Deinit();
  }

//+------------------------------------------------------------------+
//| Verified broker prefix/suffix convention, for the status display |
//+------------------------------------------------------------------+
string CUQSymbols::TagText(void) const
  {
   if(StringLen(m_tagPrefix) + StringLen(m_tagSuffix) == 0)
      return("unverified");
   return("'" + m_tagPrefix + "<pair>" + m_tagSuffix + "'");
  }

//+------------------------------------------------------------------+
//| Build the managed symbol set                                     |
//|                                                                  |
//| Every configured token is resolved deterministically. A token    |
//| that cannot be resolved to exactly one eligible instrument is a   |
//| configuration error, never a silently dropped symbol, unless the  |
//| operator explicitly allowed a partial set.                       |
//+------------------------------------------------------------------+
bool CUQSymbols::Init(const ENUM_UQ_SYMBOL_MODE mode, const string list,
                      const ENUM_TIMEFRAMES tf, const int channel,
                      const int emaPeriod, const int atrPeriod,
                      const bool requireAll)
  {
   m_tf         = tf;
   m_channel    = channel;
   m_emaPeriod  = emaPeriod;
   m_atrPeriod  = atrPeriod;
   m_requireAll = requireAll;
   m_lastError  = "";
   m_count      = 0;
   m_skipped    = 0;
   m_tagPrefix  = "";
   m_tagSuffix  = "";
   ArrayResize(m_sym, 0);

   //--- the broker convention is inferred once, from a fixed probe set
   if(UQDetectBrokerTag(m_tagPrefix, m_tagSuffix))
      PrintFormat("[UQ] Broker symbol convention verified: prefix='%s' suffix='%s'.",
                  m_tagPrefix, m_tagSuffix);
   else
      PrintFormat("[UQ] Broker symbol convention could not be verified; only exact and unambiguous names are accepted.");

   string tokens[];
   int nTok = 0;

   if(mode == UQ_SYM_CURRENT_CHART)
     {
      ArrayResize(tokens, 1);
      tokens[0] = _Symbol;
      nTok      = 1;
     }
   else
     {
      string src = list;
      StringReplace(src, ";", ",");
      nTok = StringSplit(src, ',', tokens);
     }

   if(nTok <= 0)
     {
      m_lastError = "no symbols are configured";
      return(false);
     }

   for(int i = 0; i < nTok; i++)
     {
      string t = tokens[i];
      StringTrimLeft(t);
      StringTrimRight(t);
      if(StringLen(t) == 0)
         continue;

      bool duplicate = false;
      for(int k = 0; k < m_count; k++)
        {
         if(StringCompare(m_sym[k].requested, t, false) == 0)
           {
            duplicate = true;
            break;
           }
        }
      if(duplicate)
        {
         PrintFormat("[UQ] WARNING: symbol '%s' is configured twice and is ignored the second time.", t);
         continue;
        }

      string resolved = "";
      string detail   = "";
      const ENUM_UQ_RESOLVE outcome = UQResolveSymbol(t, m_tagPrefix, m_tagSuffix, resolved, detail);
      if(outcome != UQ_RESOLVE_OK)
        {
         m_skipped++;
         PrintFormat("[UQ] SYMBOL REJECTED '%s': %s (%s).", t, UQResolveText(outcome), detail);
         if(m_requireAll)
           {
            m_lastError = StringFormat("symbol '%s' could not be resolved: %s (%s)",
                                       t, UQResolveText(outcome), detail);
            return(false);
           }
         continue;
        }

      //--- two tokens may not resolve to the same broker instrument
      if(FindByName(resolved) >= 0)
        {
         PrintFormat("[UQ] WARNING: '%s' resolves to '%s', which is already managed by an earlier token; it is ignored.",
                     t, resolved);
         continue;
        }

      ArrayResize(m_sym, m_count + 1);
      m_sym[m_count].requested    = t;
      m_sym[m_count].name         = resolved;
      m_sym[m_count].resolved     = true;
      m_sym[m_count].hEma         = INVALID_HANDLE;
      m_sym[m_count].hAtr         = INVALID_HANDLE;
      m_sym[m_count].lastBar      = 0;
      m_sym[m_count].lastEntryBar = 0;
      m_sym[m_count].lastLogTime  = 0;
      m_sym[m_count].lastNote     = "";
      m_count++;

      if(resolved == t)
         PrintFormat("[UQ] Symbol '%s' resolved exactly to '%s'.", t, resolved);
      else
         PrintFormat("[UQ] Symbol '%s' resolved to broker symbol '%s'.", t, resolved);
     }

   if(m_count <= 0)
     {
      if(StringLen(m_lastError) <= 0)
         m_lastError = "no usable symbol could be resolved";
      return(false);
     }

   //--- indicator handles are created once, during initialisation
   for(int i = 0; i < m_count; i++)
     {
      if(!EnsureHandles(i))
        {
         m_lastError = StringFormat("indicator handles could not be created for '%s'", m_sym[i].name);
         return(false);
        }
     }

   return(true);
  }

//+------------------------------------------------------------------+
//| Release indicator handles                                        |
//+------------------------------------------------------------------+
void CUQSymbols::Deinit(void)
  {
   for(int i = 0; i < m_count; i++)
     {
      if(m_sym[i].hEma != INVALID_HANDLE)
        {
         IndicatorRelease(m_sym[i].hEma);
         m_sym[i].hEma = INVALID_HANDLE;
        }
      if(m_sym[i].hAtr != INVALID_HANDLE)
        {
         IndicatorRelease(m_sym[i].hAtr);
         m_sym[i].hAtr = INVALID_HANDLE;
        }
     }
  }

//+------------------------------------------------------------------+
string CUQSymbols::Name(const int idx) const
  {
   if(idx < 0 || idx >= m_count)
      return("");
   return(m_sym[idx].name);
  }

//+------------------------------------------------------------------+
string CUQSymbols::Requested(const int idx) const
  {
   if(idx < 0 || idx >= m_count)
      return("");
   return(m_sym[idx].requested);
  }

//+------------------------------------------------------------------+
int CUQSymbols::FindByName(const string name) const
  {
   for(int i = 0; i < m_count; i++)
     {
      if(m_sym[i].name == name)
         return(i);
     }
   return(-1);
  }

//+------------------------------------------------------------------+
datetime CUQSymbols::LastEntryBar(const int idx) const
  {
   if(idx < 0 || idx >= m_count)
      return(0);
   return(m_sym[idx].lastEntryBar);
  }

//+------------------------------------------------------------------+
void CUQSymbols::SetLastEntryBar(const int idx, const datetime t)
  {
   if(idx < 0 || idx >= m_count)
      return;
   m_sym[idx].lastEntryBar = t;
  }

//+------------------------------------------------------------------+
//| Create indicator handles on first use and validate readiness     |
//+------------------------------------------------------------------+
bool CUQSymbols::EnsureHandles(const int idx)
  {
   if(idx < 0 || idx >= m_count)
      return(false);

   const string s = m_sym[idx].name;

   if(m_sym[idx].hEma == INVALID_HANDLE)
     {
      m_sym[idx].hEma = iMA(s, m_tf, m_emaPeriod, 0, MODE_EMA, PRICE_CLOSE);
      if(m_sym[idx].hEma == INVALID_HANDLE)
        {
         Note(idx, StringFormat("EMA handle creation failed (%d)", GetLastError()), true);
         return(false);
        }
     }

   if(m_sym[idx].hAtr == INVALID_HANDLE)
     {
      m_sym[idx].hAtr = iATR(s, m_tf, m_atrPeriod);
      if(m_sym[idx].hAtr == INVALID_HANDLE)
        {
         Note(idx, StringFormat("ATR handle creation failed (%d)", GetLastError()), true);
         return(false);
        }
     }

   //--- readiness is decided by the actual buffer copies, not by a cached
   //--- BarsCalculated() value, which can stay unset for handles created
   //--- inside the strategy tester.
   const int emaBars = BarsCalculated(m_sym[idx].hEma);
   const int atrBars = BarsCalculated(m_sym[idx].hAtr);
   if(emaBars == -1 && atrBars == -1)
      Note(idx, StringFormat("indicator buffers still initialising (ema bars=%d, atr bars=%d)",
                             emaBars, atrBars), true);

   return(true);
  }

//+------------------------------------------------------------------+
//| New-bar detection. The first observation only seeds the state so |
//| that attaching mid-bar cannot trigger a late historical entry.   |
//+------------------------------------------------------------------+
bool CUQSymbols::IsNewBar(const int idx, datetime &barTime)
  {
   barTime = 0;
   if(idx < 0 || idx >= m_count)
      return(false);

   datetime t[];
   if(CopyTime(m_sym[idx].name, m_tf, 0, 1, t) < 1)
      return(false);

   barTime = t[0];
   if(barTime <= 0)
      return(false);

   if(barTime == m_sym[idx].lastBar)
      return(false);

   const bool firstObservation = (m_sym[idx].lastBar == 0);
   m_sym[idx].lastBar = barTime;

   if(firstObservation)
      return(false);

   return(true);
  }

//+------------------------------------------------------------------+
//| ATR of the last completed signal bar                             |
//+------------------------------------------------------------------+
double CUQSymbols::AtrValue(const int idx)
  {
   if(idx < 0 || idx >= m_count)
      return(0.0);
   if(!EnsureHandles(idx))
      return(0.0);

   double atr[];
   ArraySetAsSeries(atr, true);
   if(CopyBuffer(m_sym[idx].hAtr, 0, 0, 3, atr) < 3)
      return(0.0);
   if(!MathIsValidNumber(atr[1]) || atr[1] <= 0.0)
      return(0.0);
   return(atr[1]);
  }

//+------------------------------------------------------------------+
//| Evaluate the breakout signal on completed candles only.          |
//| direction: +1 long, -1 short, 0 no signal                         |
//+------------------------------------------------------------------+
bool CUQSymbols::EvaluateSignal(const int idx, int &direction, double &atrOut, string &reason)
  {
   direction = 0;
   atrOut    = 0.0;
   reason    = "";

   if(idx < 0 || idx >= m_count)
     {
      reason = "invalid symbol index";
      return(false);
     }
   if(!m_sym[idx].resolved)
     {
      reason = "symbol is not resolved";
      return(false);
     }
   if(!EnsureHandles(idx))
     {
      reason = "indicators are not ready";
      return(false);
     }

   const string s    = m_sym[idx].name;
   const int    sdig = (int)SymbolInfoInteger(s, SYMBOL_DIGITS);
   const int    need = m_channel + 5;

   double   high[], low[], close[];
   datetime times[];

   ArraySetAsSeries(high,  true);
   ArraySetAsSeries(low,   true);
   ArraySetAsSeries(close, true);
   ArraySetAsSeries(times, true);

   const int nHigh  = CopyHigh(s,  m_tf, 0, need, high);
   const int nLow   = CopyLow(s,   m_tf, 0, need, low);
   const int nClose = CopyClose(s, m_tf, 0, need, close);
   const int nTime  = CopyTime(s,  m_tf, 0, need, times);

   if(nHigh < need || nLow < need || nClose < need || nTime < need)
     {
      reason = StringFormat("history not ready (high %d, low %d, close %d, time %d, need %d)",
                            nHigh, nLow, nClose, nTime, need);
      return(false);
     }

   //--- channel of the completed bars preceding the last completed bar
   double channelHigh = -DBL_MAX;
   double channelLow  =  DBL_MAX;
   for(int i = 2; i <= m_channel + 1; i++)
     {
      if(!MathIsValidNumber(high[i]) || !MathIsValidNumber(low[i]))
        {
         reason = "invalid channel price data";
         return(false);
        }
      if(high[i] > channelHigh)
         channelHigh = high[i];
      if(low[i] < channelLow)
         channelLow = low[i];
     }

   double ema[], atr[];
   ArraySetAsSeries(ema, true);
   ArraySetAsSeries(atr, true);

   if(CopyBuffer(m_sym[idx].hEma, 0, 0, 3, ema) < 3)
     {
      reason = "EMA buffer is not available";
      return(false);
     }
   if(CopyBuffer(m_sym[idx].hAtr, 0, 0, 3, atr) < 3)
     {
      reason = "ATR buffer is not available";
      return(false);
     }

   const double lastClose = close[1];
   const double emaValue  = ema[1];
   const double atrValue  = atr[1];

   if(!MathIsValidNumber(lastClose) || lastClose <= 0.0)
     {
      reason = "invalid completed close price";
      return(false);
     }
   if(!MathIsValidNumber(emaValue) || emaValue <= 0.0)
     {
      reason = "invalid EMA value";
      return(false);
     }
   if(!MathIsValidNumber(atrValue) || atrValue <= 0.0)
     {
      reason = "invalid ATR value";
      return(false);
     }

   atrOut = atrValue;

   if(lastClose > channelHigh && lastClose > emaValue)
     {
      direction = 1;
      reason = StringFormat("close %s > channelHigh %s and EMA %s",
                            DoubleToString(lastClose, sdig),
                            DoubleToString(channelHigh, sdig),
                            DoubleToString(emaValue, sdig));
      return(true);
     }

   if(lastClose < channelLow && lastClose < emaValue)
     {
      direction = -1;
      reason = StringFormat("close %s < channelLow %s and EMA %s",
                            DoubleToString(lastClose, sdig),
                            DoubleToString(channelLow, sdig),
                            DoubleToString(emaValue, sdig));
      return(true);
     }

   return(true);
  }

//+------------------------------------------------------------------+
//| Throttled per-symbol diagnostic note                             |
//+------------------------------------------------------------------+
void CUQSymbols::Note(const int idx, const string text, const bool throttle)
  {
   if(idx < 0 || idx >= m_count)
      return;

   const datetime now = TimeCurrent();
   if(throttle && m_sym[idx].lastNote == text && (now - m_sym[idx].lastLogTime) < 300)
      return;

   m_sym[idx].lastNote    = text;
   m_sym[idx].lastLogTime = now;
   PrintFormat("[UQ] %s: %s", m_sym[idx].name, text);
  }

#endif // UQ_SYMBOLS_MQH
//+------------------------------------------------------------------+