evaluator.ts

import type { Node } from './parser.ts';

export type Func = (...args: number[]) => number;

export const defaultFuncs: Record<string, Func> = {
  // Comparison
  min: Math.min,
  max: Math.max,
  clamp: (lo, v, hi) => Math.min(Math.max(v, lo), hi),

  // Sign / absolute value
  abs: Math.abs,
  sign: Math.sign,

  // Exponential
  pow: Math.pow,
  sqrt: Math.sqrt,
  hypot: Math.hypot,
  log: Math.log,
  exp: Math.exp,

  // Trig (radians)
  sin: Math.sin,
  cos: Math.cos,
  tan: Math.tan,
  asin: Math.asin,
  acos: Math.acos,
  atan: Math.atan,
  atan2: Math.atan2,

  // Stepped value
  round: Math.round,
  floor: Math.floor,
  ceil: Math.ceil,
  trunc: Math.trunc,
  // Floor-mod (result sign follows divisor); `rem` uses JS `%` (sign follows dividend).
  mod: (a, b) => ((a % b) + b) % b,
  rem: (a, b) => a % b,
};

export const defaultConsts: Record<string, number> = {
  pi: Math.PI,
  e: Math.E,
  infinity: Infinity,
};

export interface EvalContext {
  funcs?: Record<string, Func>;
  consts?: Record<string, number>;
}

export function evaluate(node: Node, ctx: EvalContext = {}): number {
  const funcs = ctx.funcs ?? defaultFuncs;
  const consts = ctx.consts ?? defaultConsts;

  switch (node.type) {
    case 'Num':
      return node.value;

    case 'Dim':
      throw new Error(
        `Cannot evaluate dimension ${node.value}${node.unit} as a plain number`
      );

    case 'Ident': {
      const v = consts[node.name.toLowerCase()];
      if (v === undefined) {
        throw new Error(`Unknown identifier "${node.name}"`);
      }
      return v;
    }

    case 'Unary': {
      const v = evaluate(node.arg, { funcs, consts });
      return node.op === '-' ? -v : +v;
    }

    case 'Binary': {
      const l = evaluate(node.left, { funcs, consts });
      const r = evaluate(node.right, { funcs, consts });
      switch (node.op) {
        case '+':
          return l + r;
        case '-':
          return l - r;
        case '*':
          return l * r;
        case '/':
          if (r === 0) {
            throw new Error('Division by zero');
          }
          return l / r;
      }
    }

    case 'Call': {
      const fn = funcs[node.name.toLowerCase()];
      if (!fn) {
        throw new Error(`Unknown function "${node.name}"`);
      }
      const args = node.args.map((a) => evaluate(a, { funcs, consts }));
      return fn(...args);
    }
  }
}