//+------------------------------------------------------------------+
//|                                                        Query.mqh |
//|                                  Copyright 2026, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2026, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property strict

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
#include  "Def.mqh"

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
namespace TSN
{
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
class CSLDomQuery
 {
private:
  //---
  CDomNodeManager*   m_dom;

  //---
  long               m_bytecode[];
  int                m_bytecode_s;
  int                m_bytecode_r;

  //---
  string             m_str[128];
  int                m_str_s;

  //---
  union LD
   {
    ulong l;
    double d;
   };

  //---
  //- iteracion de obj
                     CHashMapFastIterator(string, CDomNodeBase*)  m_stack_it_obj[256];
  //- iteracion de array
  int                m_stack_it_ix[256];
  int                m_stack_it_k[256];
  int                m_stack_it_count[256];

  //- cacheables
  int                m_stack_it_curr;
  int                m_stack_it_s;


  //---
  CDomNodeBase*      m_curr;
  bool               m_last_bool_r;

  //CDomNodeBase*      m_root;

public:
                     CSLDomQuery(void) {}
                    ~CSLDomQuery(void) {}

  int                Run(CDomNodeBase& *elemts[]);
 };

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
// si es arr entonces solo se peude con size
#define DOMPATHQUEY_MACRO_U(X)  \
        switch(t) \
         { \
          case TSN_SBL_BASE_TYPE_OBJ: \
          case TSN_SBL_BASE_TYPE_ARR: \
          {\
           m_last_bool_r = (m_curr.Size() X m_bytecode[p + 1]); \
           break;\
          } \
          case TSN_SBL_BASE_TYPE_INT: \
           { \
            m_last_bool_r = (m_curr.m_v.iv X m_bytecode[p + 1]); \
            break; \
           } \
          case TSN_SBL_BASE_TYPE_FLT:\
           {\
            static LD un;\
            un.l = m_bytecode[p + 1];\
            m_last_bool_r = (m_curr.m_v.dv X  un.d);\
            break;\
           }\
          case TSN_SBL_BASE_TYPE_BOL:\
           {\
            m_last_bool_r = (m_curr.m_v.bv X  bool((m_bytecode[p] >> TSN_DOMPATH_BIT_INS_V_BOOL_START) & 1));\
            break;\
           }\
          case TSN_SBL_BASE_TYPE_STR:\
           {\
            const int ix = m_curr.m_v.ix;\
            m_last_bool_r = (m_dom.m_string_stack[ix] X  m_str[m_bytecode[p] >> TSN_DOMPATH_BIT_INS_V_STR_START_I]);\
            break;\
           }\
          default:\
            break;\
         }\


//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CSLDomQuery::Run(CDomNodeBase& *elemts[])
 {
//---
  int p = 0;

//---
  while(p < m_bytecode_s)
   {
    switch((m_bytecode[p]&TSN_DOMPATH_MASK_INS_TYPE))
     {
      case DOMPATH_QUERY_INS_TYPE_ACCESO_KEY:
       {
        m_curr = m_curr[m_str[m_bytecode[p++] >> TSN_DOMPATH_BIT_INS_ETYPE]]; // Acceso
        break;
       }
      case DOMPATH_QUERY_INS_TYPE_ACCESO_IDX:
       {
        m_curr = m_curr[m_bytecode[p++] >> TSN_DOMPATH_BIT_INS_ETYPE]; // Acceso
        break;
       }
      case DOMPATH_QUERY_INS_TYPE_INICIAR_ITERACION:
       {
        //m_stack_it_curr = m_stack_it_s++;
        if(m_curr.m_type == TSN_SBL_BASE_TYPE_OBJ)
         {
          m_stack_it_obj[m_stack_it_curr] = m_curr.BenginIteration();
         }
        else
         {
         }
        m_stack_it_curr++;
        break;
       }
      case DOMPATH_QUERY_INS_TYPE_ITER_ASSING:
       {
        if(m_curr.m_type == TSN_SBL_BASE_TYPE_OBJ)
         {
          if(m_stack_it_obj[m_stack_it_curr].IsValid())
           {
            m_curr = m_stack_it_obj[m_stack_it_curr].Val();
            m_stack_it_obj[m_stack_it_curr].Next();
            p++; // Siguiente instrucciones
           }
          else // SI no es valido
           {
            // Saltamos x posciones....
            p += int(m_bytecode[p] >> TSN_DOMPATH_BIT_INS_ETYPE);
           }
         }
        else
         {
         }
        break;
       }

      case DOMPATH_QUERY_INS_TYPE_EXIT:
       {


        break;
       }

      case DOMPATH_QUERY_INS_TYPE_COMPARE_IS: // comara que no este vacio .empty() o .size()
       {
        //----
        m_last_bool_r = false;

        //---
        if(((1 << m_curr.m_type) & (TSN_SBL_BASE_F_OBJ | TSN_SBL_BASE_F_ARR)) == 0)
          break; // Sale de golpe

        //---
        const int opt = int(m_bytecode[p] >> TSN_DOMPATH_BIT_INS_ETYPE) & TSN_DOMPATH_MASK_COMPARE;
        const int t = m_curr.Size();

        //---
        switch(opt)
         {
          case TSN_DOMPATH_OA_T_SIZE:
           {
            m_last_bool_r = bool(t); // true si no es 0 false si es 0
            break;
           }
          case TSN_DOMPATH_OA_T_EMPT:
           {
            m_last_bool_r = t == 0; // true si esta vacio
            break;
           }
          default:
            break;
         }
        break;
       }

      case DOMPATH_QUERY_INS_TYPE_COMPARE_MENOR:
       {
        //----
        m_last_bool_r = false;

        //---
        const int t = int(m_bytecode[p] >> TSN_DOMPATH_BIT_INS_ETYPE) & TSN_DOMPATH_MASK_COMPARE;
        if(t != m_curr.m_type)
          break;

        //---
        DOMPATHQUEY_MACRO_U( <)
        break;
       }
      case DOMPATH_QUERY_INS_TYPE_COMPARE_MAYOR:
       {
        //----
        m_last_bool_r = false;

        //---
        const int t = int(m_bytecode[p] >> TSN_DOMPATH_BIT_INS_ETYPE) & TSN_DOMPATH_MASK_COMPARE;
        if(t != m_curr.m_type)
          break;

        //---
        DOMPATHQUEY_MACRO_U( >)
        break;
       }
      case DOMPATH_QUERY_INS_TYPE_COMPARE_MENOR_IGUAL:
       {
        //----
        m_last_bool_r = false;

        //---
        const int t = int(m_bytecode[p] >> TSN_DOMPATH_BIT_INS_ETYPE) & TSN_DOMPATH_MASK_COMPARE;
        if(t != m_curr.m_type)
          break;

        //---
        DOMPATHQUEY_MACRO_U( <=)
        break;
       }
      case DOMPATH_QUERY_INS_TYPE_COMPARE_MAYOR_IGUAL:
       {
        //----
        m_last_bool_r = false;

        //---
        const int t = int(m_bytecode[p] >> TSN_DOMPATH_BIT_INS_ETYPE) & TSN_DOMPATH_MASK_COMPARE;
        if(t != m_curr.m_type)
          break;

        //---
        DOMPATHQUEY_MACRO_U( >=)
        break;
       }
      case DOMPATH_QUERY_INS_TYPE_COMPARE_NO_IGUAL:
       {
        //----
        m_last_bool_r = false;

        //---
        const int t = int(m_bytecode[p] >> TSN_DOMPATH_BIT_INS_ETYPE) & TSN_DOMPATH_MASK_COMPARE;
        if(t != m_curr.m_type)
          break;

        //---
        DOMPATHQUEY_MACRO_U( !=)
        break;
       }
      case DOMPATH_QUERY_INS_TYPE_COMPARE_IGUAL:
       {
        //----
        m_last_bool_r = false;

        //---
        const int t = int(m_bytecode[p] >> TSN_DOMPATH_BIT_INS_ETYPE) & TSN_DOMPATH_MASK_COMPARE;
        if(t != m_curr.m_type)
          break;

        //---
        DOMPATHQUEY_MACRO_U( ==)
        break;
       }
      case DOMPATH_QUERY_INS_TYPE_JUMP_IS_TRUE:
       {
        if(m_last_bool_r)
         {
          p += int(m_bytecode[p] >> TSN_DOMPATH_BIT_INS_ETYPE);
          break;
         }
        p++;
        break;
       }
      case DOMPATH_QUERY_INS_TYPE_JUMP_IS_FALSE:
       {
        if(m_last_bool_r)
         {
          // Si cumple entonces normal
          p++;
          break;
         }
        // No cumple saltamos..
        p += int(m_bytecode[p] >> TSN_DOMPATH_BIT_INS_ETYPE);
        break;
       }


      default:
        break;
     }

   }
 }

}
//+------------------------------------------------------------------+
/*
{
  "precios": {
    "libro1": {"valor":[20]},
    "libro2": {"valor":[10]},
    "libro3": {"valor":[15]}
  }
}

$.
precios.
[*].
valor

$.precios[*].valor[?(@ > 10 || @ < 20 || 20 == 20)]
→ [20, 15]

----
Acceso a "precios"
Inciar iteracion
Asignar elemento y mover (en caso termine jump a fin:, de lo contrario continuar)
Accceso a "valor"
Inciar iteracion
Asignar elemento y mover (en caso termine vuelve a jump: "Asignar elemento y mover")
Comparar > 10 (en caso no concinda jumpo a la nstruccion previa, si conice siugiente intrucciones)
Añadir elemento actual al array de elementos  (vuelve a Asignar elemento y mover)
fin: return.. (terminar)

*/
//+------------------------------------------------------------------+