//+------------------------------------------------------------------+
//| TF_Expr.mqh - Tick Forge price-function parser                    |
//| Copyright (c) 2026 Joshua Dunnink. MIT License (see LICENSE).     |
//|                                                                   |
//| A small, safe expression compiler: text -> reverse-polish program |
//| -> fast evaluation. No eval, no file access, no side effects.     |
//|                                                                   |
//| Variables  p (x)  original price     p0  first price in range     |
//|            r      p / p0             t   progress in range, 0..1  |
//|            d      days since range start                          |
//| Operators  + - * / ^  and unary minus, parentheses                |
//| Functions  abs sqrt ln log10 exp sin cos pow(a,b) min(a,b) max(a,b)|
//| Constants  pi e                                                   |
//+------------------------------------------------------------------+
#property strict

enum ENUM_TF_OP
  {
   TFOP_NUM = 0, TFOP_P, TFOP_P0, TFOP_R, TFOP_T, TFOP_D,
   TFOP_ADD, TFOP_SUB, TFOP_MUL, TFOP_DIV, TFOP_POW, TFOP_NEG,
   TFOP_ABS, TFOP_SQRT, TFOP_LN, TFOP_LOG10, TFOP_EXP, TFOP_SIN, TFOP_COS,
   TFOP_MIN, TFOP_MAX
  };

class CTFExpr
  {
private:
   string            m_src;
   int               m_pos;
   string            m_err;
   int               m_op[];
   double            m_val[];
   int               m_n;
   int               m_depth, m_maxdepth;

   void              Emit(const int op, const double v = 0.0);
   void              SkipWs();
   bool              Fail(const string e) { if(m_err == "") m_err = e + " at position " + IntegerToString(m_pos + 1); return false; }
   bool              ParseExpr();
   bool              ParseTerm();
   bool              ParseUnary();
   bool              ParsePower();
   bool              ParsePrimary();
   bool              Peek(const ushort c);
   int               FuncOp(const string name, int &argc);

public:
                     CTFExpr() : m_n(0) {}
   bool              Compile(const string text);
   string            Error() const { return m_err; }
   double            Eval(const double p, const double p0, const double t, const double d) const;
  };

void CTFExpr::Emit(const int op, const double v)
  {
   if(ArraySize(m_op) <= m_n) { ArrayResize(m_op, m_n + 32); ArrayResize(m_val, m_n + 32); }
   m_op[m_n] = op; m_val[m_n] = v; m_n++;
   // stack bookkeeping: pushes +1, binary ops -1, unary/func1 0
   switch(op)
     {
      case TFOP_NUM: case TFOP_P: case TFOP_P0: case TFOP_R: case TFOP_T: case TFOP_D:
         m_depth++; if(m_depth > m_maxdepth) m_maxdepth = m_depth; break;
      case TFOP_ADD: case TFOP_SUB: case TFOP_MUL: case TFOP_DIV: case TFOP_POW: case TFOP_MIN: case TFOP_MAX:
         m_depth--; break;
      default: break;
     }
  }

void CTFExpr::SkipWs() { while(m_pos < StringLen(m_src) && (m_src[m_pos] == ' ' || m_src[m_pos] == '\t')) m_pos++; }

bool CTFExpr::Peek(const ushort c) { SkipWs(); return (m_pos < StringLen(m_src) && m_src[m_pos] == c); }

bool CTFExpr::Compile(const string text)
  {
   m_src = text; m_pos = 0; m_err = ""; m_n = 0; m_depth = 0; m_maxdepth = 0;
   ArrayResize(m_op, 32); ArrayResize(m_val, 32);
   if(StringLen(text) == 0) { m_err = "empty expression"; return false; }
   if(!ParseExpr()) return false;
   SkipWs();
   if(m_pos < StringLen(m_src)) return Fail("unexpected '" + StringSubstr(m_src, m_pos, 1) + "'");
   if(m_maxdepth > 60) { m_err = "expression too deep"; return false; }
   return true;
  }

bool CTFExpr::ParseExpr()
  {
   if(!ParseTerm()) return false;
   while(true)
     {
      SkipWs();
      if(m_pos >= StringLen(m_src)) return true;
      ushort c = m_src[m_pos];
      if(c != '+' && c != '-') return true;
      m_pos++;
      if(!ParseTerm()) return false;
      Emit(c == '+' ? TFOP_ADD : TFOP_SUB);
     }
   return true;
  }

bool CTFExpr::ParseTerm()
  {
   if(!ParseUnary()) return false;
   while(true)
     {
      SkipWs();
      if(m_pos >= StringLen(m_src)) return true;
      ushort c = m_src[m_pos];
      if(c != '*' && c != '/') return true;
      m_pos++;
      if(!ParseUnary()) return false;
      Emit(c == '*' ? TFOP_MUL : TFOP_DIV);
     }
   return true;
  }

bool CTFExpr::ParseUnary()
  {
   SkipWs();
   if(m_pos < StringLen(m_src) && (m_src[m_pos] == '-' || m_src[m_pos] == '+'))
     {
      bool neg = (m_src[m_pos] == '-');
      m_pos++;
      if(!ParseUnary()) return false;
      if(neg) Emit(TFOP_NEG);
      return true;
     }
   return ParsePower();
  }

bool CTFExpr::ParsePower()
  {
   if(!ParsePrimary()) return false;
   SkipWs();
   if(m_pos < StringLen(m_src) && m_src[m_pos] == '^')
     {
      m_pos++;
      if(!ParseUnary()) return false;     // right associative, allows 2^-1
      Emit(TFOP_POW);
     }
   return true;
  }

int CTFExpr::FuncOp(const string name, int &argc)
  {
   argc = 1;
   if(name == "abs")   return TFOP_ABS;
   if(name == "sqrt")  return TFOP_SQRT;
   if(name == "ln")    return TFOP_LN;
   if(name == "log10") return TFOP_LOG10;
   if(name == "exp")   return TFOP_EXP;
   if(name == "sin")   return TFOP_SIN;
   if(name == "cos")   return TFOP_COS;
   argc = 2;
   if(name == "pow")   return TFOP_POW;
   if(name == "min")   return TFOP_MIN;
   if(name == "max")   return TFOP_MAX;
   return -1;
  }

bool CTFExpr::ParsePrimary()
  {
   SkipWs();
   if(m_pos >= StringLen(m_src)) return Fail("unexpected end");
   ushort c = m_src[m_pos];
   if(c == '(')
     {
      m_pos++;
      if(!ParseExpr()) return false;
      if(!Peek(')')) return Fail("missing ')'");
      m_pos++;
      return true;
     }
   if((c >= '0' && c <= '9') || c == '.')
     {
      int s = m_pos;
      while(m_pos < StringLen(m_src) && ((m_src[m_pos] >= '0' && m_src[m_pos] <= '9') || m_src[m_pos] == '.')) m_pos++;
      // optional exponent 1e-3
      if(m_pos < StringLen(m_src) && (m_src[m_pos] == 'e' || m_src[m_pos] == 'E'))
        {
         int save = m_pos; m_pos++;
         if(m_pos < StringLen(m_src) && (m_src[m_pos] == '+' || m_src[m_pos] == '-')) m_pos++;
         int ds = m_pos;
         while(m_pos < StringLen(m_src) && m_src[m_pos] >= '0' && m_src[m_pos] <= '9') m_pos++;
         if(m_pos == ds) m_pos = save;
        }
      Emit(TFOP_NUM, StringToDouble(StringSubstr(m_src, s, m_pos - s)));
      return true;
     }
   if((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_')
     {
      int s = m_pos;
      while(m_pos < StringLen(m_src) && ((m_src[m_pos] >= 'a' && m_src[m_pos] <= 'z') || (m_src[m_pos] >= 'A' && m_src[m_pos] <= 'Z') ||
            (m_src[m_pos] >= '0' && m_src[m_pos] <= '9') || m_src[m_pos] == '_')) m_pos++;
      string id = StringSubstr(m_src, s, m_pos - s);
      StringToLower(id);
      if(Peek('('))
        {
         int argc;
         int op = FuncOp(id, argc);
         if(op < 0) return Fail("unknown function '" + id + "'");
         m_pos++;                                   // (
         if(!ParseExpr()) return false;
         if(argc == 2)
           {
            if(!Peek(',')) return Fail("function '" + id + "' needs 2 arguments");
            m_pos++;
            if(!ParseExpr()) return false;
           }
         if(!Peek(')')) return Fail("missing ')'");
         m_pos++;
         Emit(op);
         return true;
        }
      if(id == "p" || id == "x") { Emit(TFOP_P);  return true; }
      if(id == "p0")             { Emit(TFOP_P0); return true; }
      if(id == "r")              { Emit(TFOP_R);  return true; }
      if(id == "t")              { Emit(TFOP_T);  return true; }
      if(id == "d")              { Emit(TFOP_D);  return true; }
      if(id == "pi")             { Emit(TFOP_NUM, M_PI); return true; }
      if(id == "e")              { Emit(TFOP_NUM, M_E);  return true; }
      m_pos = s;
      return Fail("unknown name '" + id + "'");
     }
   return Fail("unexpected '" + StringSubstr(m_src, m_pos, 1) + "'");
  }

double CTFExpr::Eval(const double p, const double p0, const double t, const double d) const
  {
   double st[64];
   int sp = 0;
   for(int i = 0; i < m_n; i++)
     {
      switch(m_op[i])
        {
         case TFOP_NUM: st[sp++] = m_val[i]; break;
         case TFOP_P:   st[sp++] = p; break;
         case TFOP_P0:  st[sp++] = p0; break;
         case TFOP_R:   st[sp++] = (p0 != 0.0 ? p / p0 : 0.0); break;
         case TFOP_T:   st[sp++] = t; break;
         case TFOP_D:   st[sp++] = d; break;
         case TFOP_ADD: sp--; st[sp - 1] += st[sp]; break;
         case TFOP_SUB: sp--; st[sp - 1] -= st[sp]; break;
         case TFOP_MUL: sp--; st[sp - 1] *= st[sp]; break;
         case TFOP_DIV: sp--; st[sp - 1] = (st[sp] != 0.0 ? st[sp - 1] / st[sp] : MathArcsin(2.0)); break;   // NaN
         case TFOP_POW: sp--; st[sp - 1] = MathPow(st[sp - 1], st[sp]); break;
         case TFOP_NEG: st[sp - 1] = -st[sp - 1]; break;
         case TFOP_ABS: st[sp - 1] = MathAbs(st[sp - 1]); break;
         case TFOP_SQRT:  st[sp - 1] = MathSqrt(st[sp - 1]); break;
         case TFOP_LN:    st[sp - 1] = MathLog(st[sp - 1]); break;
         case TFOP_LOG10: st[sp - 1] = MathLog10(st[sp - 1]); break;
         case TFOP_EXP:   st[sp - 1] = MathExp(st[sp - 1]); break;
         case TFOP_SIN:   st[sp - 1] = MathSin(st[sp - 1]); break;
         case TFOP_COS:   st[sp - 1] = MathCos(st[sp - 1]); break;
         case TFOP_MIN:   sp--; st[sp - 1] = MathMin(st[sp - 1], st[sp]); break;
         case TFOP_MAX:   sp--; st[sp - 1] = MathMax(st[sp - 1], st[sp]); break;
        }
     }
   return (sp == 1 ? st[0] : MathArcsin(2.0));
  }
//+------------------------------------------------------------------+