// App that works with expressions can now build an AST using
// `buildExpressionFunction`, which takes a function name, and object of args:
const fn = buildExpressionFunction('hello', { world: ['whee'] });
fn.addArgument('first', true)
  .addArgument('second', 0)
  .replaceArgument('second', [2])
  .removeArgument('first');

fn.toAst(); // returns function AST

// `buildExpression` takes an expression string, AST,
// or array of `buildExpressionFunction`
const exp = buildExpression([
  buildExpressionFunction('a', {});
  buildExpressionFunction('b', {});
]); // or buildExpression(ast); or buildExpression('a | b');

// add a new function
exp.functions.push(
  buildExpressionFunction('c', { hi: ['friends'] })
);

exp.toAst(); // returns expression AST
exp.toString(); // returns expression string

// You can pass another `buildExpression` to any argument as a subexpression
const exp = buildExpression('foo | bar');
exp.functions.push(
  buildExpressionFunction('baz', {
    subexpressionArg: buildExpression('subexp a=true'),
  })
);

// Type safety provided by generic type params:
const exp = buildExpression([
  buildExpressionFunction<MyFnExpressionFunctionDefinition>('myFn', { hello: [true] });
]);
const fns = exp.findFunction<MyFnExpressionFunctionDefinition>('myFn');

// Eventually the goal is for plugins registering functions to individually export
// their own function builders that return `ExpressionAstFunctionBuilder`, so
// that dependencies stay explicit and you automatically get type safety:
// pluginA
export const myFnBuilder: (args: MyArgs) => ExpressionAstFunctionBuilder<MyFnDef> = (args) => {
  return buildExpressionFunction('myFnName', args);
};
// pluginB
import { myFnBuilder } from '../plugin_a';
const exp = buildExpression([myFnBuilder(args)]);

// Migrates all `b` functions in the expression to change the `version` arg to 2
const exp = buildExpression('a | b version=1 | c subexp={b version=1}');
exp.findFunction('b').forEach(fn => {
  const arg = fn.getArgument('version');
  if (arg) {
    fn.replaceArgument('version', [2]);
  }
});
exp.toString(); // `a | b version=2 | c subexp={b version=2}`

// also available on `expressions/public/server`
import {
  buildExpression,
  buildExpressionFunction
} from '../../src/plugins/expressions/public';

// `buildExpression` takes an expression string, AST, or array of `buildExpressionFunction`
const exp = buildExpression([
  // `buildExpressionFunction` takes an expression function name, and object of args
  buildExpressionFunction('myFn', { hello: [true] });
]);

const anotherFn = buildExpressionFunction('anotherFn', { world: [false] });
exp.functions.push(anotherFn);
fn.replaceArgument('world', [true]);

exp.toAst(); // prints the latest AST

// you can get added type-safety by providing a generic type argument:
const exp = buildExpression([
  buildExpressionFunction<MyFnExpressionFunctionDefinition>('myFn', { hello: [true] });
]);
const fns = exp.findFunction<MyFnExpressionFunctionDefinition>('myFn');