'use strict';
/* ════════════════════════════════════════════════════════════════════════
   SimExpr — безопасный движок выражений для конструктора симуляций (Фаза 0).

   Спека симуляции — это ДАННЫЕ, которые шарятся между людьми, поэтому код
   выражений НИКОГДА не исполняется через eval/new Function. Здесь — собственный
   конвейер: токенайзер → AST → evaluate(ast, env). Логика расширяет парсер
   y=f(x) из graph.js (тот же подход к токенам и неявному умножению), но:
     - окружение многопеременное: любой идентификатор берётся из env (params, t,
       значения объектов), а не только x;
     - добавлены сравнения (< <= > >= == !=), логика (&& ||), тернарник ?:,
       функции min/max/mod/log(base,x) и константы pi/e;
     - результат компиляции — AST + замыкание fn(env), считается детерминированно.

   Ошибки времени выполнения (деление на 0, NaN, неизвестный идентификатор) НЕ
   кидаются из fn(env): они дают 0 (или флаг через evalSafe), чтобы один кривой
   кадр не ронял весь рантайм. Ошибки КОМПИЛЯЦИИ (синтаксис) возвращаются строкой
   в compile(src).error и не бросаются.

   API:
     SimExpr.compile(src) -> { ast, fn, error }
         fn(env) -> number      (никогда не бросает; при сбое -> 0)
     SimExpr.evaluate(ast, env) -> number   (никогда не бросает; при сбое -> 0)
     SimExpr.evalSafe(ast, env) -> { value, error }   (для отладки/билдера)
     SimExpr.FUNCTIONS  -> Set имён whitelisted-функций (для подсветки/билдера)
     SimExpr.CONSTANTS  -> Set имён констант (pi, e)

   env — простой объект { имя: number }. Имена объектов спеки удобно передавать
   как "obj.x"/"obj.y" — для этого допускается точка в идентификаторе.
   ════════════════════════════════════════════════════════════════════════ */
(function (global) {

  /* ── whitelist функций (имя -> арность: 1, 2 или -1 для переменной) ── */
  // -1 => принимает >=1 аргумент (min/max). log: 1 арг = ln по основанию e? нет —
  // log(x) трактуем как десятичный (как в graph.js log===log10), log(b,x)=log_b(x).
  var FN_ARITY = {
    sin: 1, cos: 1, tan: 1, tg: 1, ctg: 1, cot: 1,
    asin: 1, acos: 1, atan: 1, arcsin: 1, arccos: 1, arctan: 1, arctg: 1,
    sqrt: 1, abs: 1, exp: 1, ln: 1, log: -2, log2: 1, log10: 1,
    floor: 1, ceil: 1, round: 1, sign: 1,
    min: -1, max: -1, mod: 2, atan2: 2, pow: 2, hypot: -1
  };

  // Реализации. Все защищены от исключений на уровне evaluate (домены проверяются
  // там, где можно дать NaN -> наружу станет 0).
  var FN_IMPL = {
    sin: Math.sin, cos: Math.cos, tan: Math.tan, tg: Math.tan,
    ctg: function (x) { return 1 / Math.tan(x); },
    cot: function (x) { return 1 / Math.tan(x); },
    asin: Math.asin, acos: Math.acos, atan: Math.atan,
    arcsin: Math.asin, arccos: Math.acos, arctan: Math.atan, arctg: Math.atan,
    sqrt: Math.sqrt, abs: Math.abs, exp: Math.exp,
    ln: Math.log,
    log: function (a, b) {
      // log(x) -> log10(x); log(base, x) -> log_base(x)
      if (b === undefined) return Math.log(a) / Math.LN10;
      return Math.log(b) / Math.log(a);
    },
    log2: Math.log2, log10: Math.log10,
    floor: Math.floor, ceil: Math.ceil, round: Math.round, sign: Math.sign,
    min: Math.min, max: Math.max,
    mod: function (a, b) { return b === 0 ? 0 : a % b; },
    atan2: Math.atan2, pow: Math.pow, hypot: Math.hypot
  };

  var CONSTANTS = { pi: Math.PI, PI: Math.PI, e: Math.E, E: Math.E, tau: Math.PI * 2 };

  /* ════════════════════ TOKENIZER ════════════════════ */

  function tokenize(src) {
    var out = [];
    var i = 0, n = src.length;
    while (i < n) {
      var ch = src[i];
      if (ch === ' ' || ch === '\t' || ch === '\n' || ch === '\r') { i++; continue; }

      /* число */
      if ((ch >= '0' && ch <= '9') || (ch === '.' && src[i + 1] >= '0' && src[i + 1] <= '9')) {
        var j = i;
        while (j < n && src[j] >= '0' && src[j] <= '9') j++;
        if (j < n && src[j] === '.') { j++; while (j < n && src[j] >= '0' && src[j] <= '9') j++; }
        if (j < n && (src[j] === 'e' || src[j] === 'E')) {
          var k = j + 1;
          if (k < n && (src[k] === '+' || src[k] === '-')) k++;
          if (k < n && src[k] >= '0' && src[k] <= '9') {
            j = k; while (j < n && src[j] >= '0' && src[j] <= '9') j++;
          }
        }
        out.push({ t: 'num', v: parseFloat(src.slice(i, j)) });
        i = j; continue;
      }

      /* идентификатор (буквы/цифры/_/.) — точка допускает obj.x */
      if (isIdentStart(ch)) {
        var p = i + 1;
        while (p < n && isIdentPart(src[p])) p++;
        out.push({ t: 'id', v: src.slice(i, p) });
        i = p; continue;
      }

      /* двухсимвольные операторы */
      var two = src.substr(i, 2);
      if (two === '<=' || two === '>=' || two === '==' || two === '!=' ||
          two === '&&' || two === '||') {
        out.push({ t: 'op', v: two }); i += 2; continue;
      }

      /* односимвольные операторы / скобки / запятая / ?: */
      if ('+-*/^%()<>?:,'.indexOf(ch) !== -1) {
        out.push({ t: 'op', v: ch }); i++; continue;
      }
      // одиночный '=' трактуем как сравнение (часто пишут a=b по привычке)
      if (ch === '=') { out.push({ t: 'op', v: '==' }); i++; continue; }
      // одиночный '!' — логическое НЕ
      if (ch === '!') { out.push({ t: 'op', v: '!' }); i++; continue; }

      throw new Error('Неизвестный символ: «' + ch + '»');
    }
    return out;
  }

  function isIdentStart(ch) {
    return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ch === '_';
  }
  function isIdentPart(ch) {
    return isIdentStart(ch) || (ch >= '0' && ch <= '9') || ch === '.';
  }

  /* Вставка неявного умножения: 2x -> 2*x, 2(.. -> 2*(.., )( -> )*(, )x -> )*x.
     Функция перед '(' умножение НЕ получает. */
  function insertImplicitMul(tokens) {
    var out = [];
    for (var i = 0; i < tokens.length; i++) {
      out.push(tokens[i]);
      var cur = tokens[i], nxt = tokens[i + 1];
      if (!nxt) continue;
      var curIsFn = cur.t === 'id' && Object.prototype.hasOwnProperty.call(FN_ARITY, cur.v);
      var curEnds = cur.t === 'num' ||
                    (cur.t === 'id' && !curIsFn) ||
                    (cur.t === 'op' && cur.v === ')');
      var nxtStarts = nxt.t === 'num' ||
                      nxt.t === 'id' ||
                      (nxt.t === 'op' && nxt.v === '(');
      // не вставляем '*' если cur — функция (тогда дальше идёт её '(')
      if (curEnds && nxtStarts) out.push({ t: 'op', v: '*' });
    }
    return out;
  }

  /* ════════════════════ PARSER (рекурсивный спуск -> AST) ════════════════════

     Грамматика (по убыванию приоритета связывания):
       ternary  := logicOr ('?' ternary ':' ternary)?
       logicOr  := logicAnd ('||' logicAnd)*
       logicAnd := compare ('&&' compare)*
       compare  := addSub (('<'|'<='|'>'|'>='|'=='|'!=') addSub)?
       addSub   := mulDiv (('+'|'-') mulDiv)*
       mulDiv   := power (('*'|'/'|'%') power)*
       power    := unary ('^' power)?            // правоассоциативно
       unary    := ('-'|'+'|'!') unary | primary
       primary  := num | ident | const | fn(args...) | '(' ternary ')'

     Узлы AST:
       { k:'num', v }
       { k:'var', name }
       { k:'const', v }
       { k:'bin', op, a, b }
       { k:'un', op, a }
       { k:'cmp', op, a, b }
       { k:'logic', op, a, b }
       { k:'not', a }
       { k:'cond', c, a, b }
       { k:'call', name, args:[...] }
  */

  function parse(tokens) {
    var pos = 0;
    function peek() { return tokens[pos]; }
    function next() { return tokens[pos++]; }
    function expect(v) {
      var t = peek();
      if (!t || t.v !== v) throw new Error('Ожидалось «' + v + '»');
      pos++;
    }
    function isOp(v) { var t = peek(); return t && t.t === 'op' && t.v === v; }

    function ternary() {
      var c = logicOr();
      if (isOp('?')) {
        next();
        var a = ternary();
        expect(':');
        var b = ternary();
        return { k: 'cond', c: c, a: a, b: b };
      }
      return c;
    }
    function logicOr() {
      var l = logicAnd();
      while (isOp('||')) { next(); l = { k: 'logic', op: '||', a: l, b: logicAnd() }; }
      return l;
    }
    function logicAnd() {
      var l = compare();
      while (isOp('&&')) { next(); l = { k: 'logic', op: '&&', a: l, b: compare() }; }
      return l;
    }
    function compare() {
      var l = addSub();
      var t = peek();
      if (t && t.t === 'op' && (t.v === '<' || t.v === '<=' || t.v === '>' ||
          t.v === '>=' || t.v === '==' || t.v === '!=')) {
        var op = next().v;
        return { k: 'cmp', op: op, a: l, b: addSub() };
      }
      return l;
    }
    function addSub() {
      var l = mulDiv();
      while (isOp('+') || isOp('-')) { var op = next().v; l = { k: 'bin', op: op, a: l, b: mulDiv() }; }
      return l;
    }
    function mulDiv() {
      var l = power();
      while (isOp('*') || isOp('/') || isOp('%')) { var op = next().v; l = { k: 'bin', op: op, a: l, b: power() }; }
      return l;
    }
    function power() {
      var base = unary();
      if (isOp('^')) { next(); return { k: 'bin', op: '^', a: base, b: power() }; }
      return base;
    }
    function unary() {
      if (isOp('-')) { next(); return { k: 'un', op: '-', a: unary() }; }
      if (isOp('+')) { next(); return unary(); }
      if (isOp('!')) { next(); return { k: 'not', a: unary() }; }
      return primary();
    }
    function primary() {
      var t = peek();
      if (!t) throw new Error('Неожиданный конец выражения');

      if (t.t === 'num') { next(); return { k: 'num', v: t.v }; }

      if (t.t === 'id') {
        next();
        var name = t.v;
        if (Object.prototype.hasOwnProperty.call(FN_ARITY, name)) {
          expect('(');
          var args = [];
          if (!isOp(')')) {
            args.push(ternary());
            while (isOp(',')) { next(); args.push(ternary()); }
          }
          expect(')');
          checkArity(name, args.length);
          return { k: 'call', name: name, args: args };
        }
        if (Object.prototype.hasOwnProperty.call(CONSTANTS, name)) {
          return { k: 'const', v: CONSTANTS[name] };
        }
        // переменная окружения
        return { k: 'var', name: name };
      }

      if (t.t === 'op' && t.v === '(') {
        next();
        var e = ternary();
        expect(')');
        return e;
      }

      throw new Error('Неожиданный токен: «' + t.v + '»');
    }

    var ast = ternary();
    if (pos !== tokens.length) throw new Error('Лишние токены после выражения');
    return ast;
  }

  function checkArity(name, got) {
    var ar = FN_ARITY[name];
    if (ar === -1) { // >=1
      if (got < 1) throw new Error('Функции «' + name + '» нужен хотя бы 1 аргумент');
      return;
    }
    if (ar === -2) { // 1..2 (log)
      if (got < 1 || got > 2) throw new Error('Функция «' + name + '» принимает 1 или 2 аргумента');
      return;
    }
    if (got !== ar) throw new Error('Функция «' + name + '» принимает ' + ar + ' арг., дано ' + got);
  }

  /* ════════════════════ EVALUATE ════════════════════
     Чистый интерпретатор AST по окружению env. НЕ бросает наружу (см. evaluate).
     Внутренний _ev может вернуть NaN/Infinity — нормализуется в evaluate. */

  function _ev(node, env) {
    switch (node.k) {
      case 'num': return node.v;
      case 'const': return node.v;
      case 'var': {
        var val = env ? env[node.name] : undefined;
        return typeof val === 'number' ? val : 0; // неизвестная переменная -> 0
      }
      case 'un': // только '-'
        return -_ev(node.a, env);
      case 'not':
        return _ev(node.a, env) ? 0 : 1;
      case 'bin': {
        var a = _ev(node.a, env), b = _ev(node.b, env);
        switch (node.op) {
          case '+': return a + b;
          case '-': return a - b;
          case '*': return a * b;
          case '/': return b === 0 ? 0 : a / b;       // деление на 0 -> 0
          case '%': return b === 0 ? 0 : a % b;
          case '^': return Math.pow(a, b);
        }
        return 0;
      }
      case 'cmp': {
        var x = _ev(node.a, env), y = _ev(node.b, env);
        switch (node.op) {
          case '<': return x < y ? 1 : 0;
          case '<=': return x <= y ? 1 : 0;
          case '>': return x > y ? 1 : 0;
          case '>=': return x >= y ? 1 : 0;
          case '==': return x === y ? 1 : 0;
          case '!=': return x !== y ? 1 : 0;
        }
        return 0;
      }
      case 'logic': {
        if (node.op === '&&') return (_ev(node.a, env) && _ev(node.b, env)) ? 1 : 0;
        return (_ev(node.a, env) || _ev(node.b, env)) ? 1 : 0;
      }
      case 'cond':
        return _ev(node.c, env) ? _ev(node.a, env) : _ev(node.b, env);
      case 'call': {
        var fn = FN_IMPL[node.name];
        var args = node.args;
        if (args.length === 1) return fn(_ev(args[0], env));
        if (args.length === 2) return fn(_ev(args[0], env), _ev(args[1], env));
        // переменное число (min/max/hypot)
        var vals = new Array(args.length);
        for (var i = 0; i < args.length; i++) vals[i] = _ev(args[i], env);
        return fn.apply(null, vals);
      }
    }
    return 0;
  }

  // Никогда не бросает; NaN/Infinity -> 0.
  function evaluate(ast, env) {
    if (!ast) return 0;
    var v;
    try { v = _ev(ast, env); } catch (e) { return 0; }
    return (typeof v === 'number' && isFinite(v)) ? v : 0;
  }

  // Для отладки/билдера: возвращает значение + флаг (NaN/Infinity -> error).
  function evalSafe(ast, env) {
    if (!ast) return { value: 0, error: 'нет выражения' };
    var v;
    try { v = _ev(ast, env); } catch (e) { return { value: 0, error: String(e.message || e) }; }
    if (typeof v !== 'number' || !isFinite(v)) return { value: 0, error: 'не число (NaN/∞)' };
    return { value: v, error: null };
  }

  /* ════════════════════ COMPILE ════════════════════
     Возвращает { ast, fn, error }. Синтаксическая ошибка -> error:строка, fn:()=>0. */

  function compile(src) {
    if (src == null) return { ast: null, fn: function () { return 0; }, error: 'пустое выражение' };
    var raw = String(src).trim();
    // допускаем ведущее "y=" / "name=" (привычка), срезаем как в graph.js
    raw = raw.replace(/^\s*[a-zA-Z_][a-zA-Z_0-9.]*\s*=(?![=])\s*/, '');
    if (!raw) return { ast: null, fn: function () { return 0; }, error: 'пустое выражение' };
    var ast;
    try {
      var toks = insertImplicitMul(tokenize(raw));
      ast = parse(toks);
    } catch (e) {
      return { ast: null, fn: function () { return 0; }, error: String(e.message || e) };
    }
    var fn = function (env) { return evaluate(ast, env); };
    return { ast: ast, fn: fn, error: null };
  }

  /* Хелпер: значение — число вернуть как есть; строка — скомпилировать и вернуть
     { fn(env), error, constant }. Используется движком для свойств-привязок. */
  function compileValue(value) {
    if (typeof value === 'number') {
      var c = value;
      return { fn: function () { return c; }, error: null, constant: true, ast: { k: 'num', v: c } };
    }
    if (typeof value === 'string') {
      var r = compile(value);
      return { fn: r.fn, error: r.error, constant: false, ast: r.ast };
    }
    // прочие типы -> 0
    return { fn: function () { return 0; }, error: null, constant: true, ast: { k: 'num', v: 0 } };
  }

  var FUNCTIONS = {}; // имя -> true (как «множество» без ES6 Set ради совместимости)
  Object.keys(FN_ARITY).forEach(function (k) { FUNCTIONS[k] = true; });
  var CONSTSET = {};
  Object.keys(CONSTANTS).forEach(function (k) { CONSTSET[k] = true; });

  global.SimExpr = {
    compile: compile,
    compileValue: compileValue,
    evaluate: evaluate,
    evalSafe: evalSafe,
    tokenize: tokenize,           // экспортируем для тестов/билдера
    parse: function (src) {       // удобный helper: строка -> AST (бросает при ошибке)
      return parse(insertImplicitMul(tokenize(String(src).trim())));
    },
    FUNCTIONS: FUNCTIONS,
    CONSTANTS: CONSTSET
  };
})(typeof window !== 'undefined' ? window : globalThis);