energylink/public/app/plugins/datasource/graphite/gfunc.ts

import _ from 'lodash';
import $ from 'jquery';
import { isVersionGtOrEq } from 'app/core/utils/version';

var index = [];
var categories = {
  Combine: [],
  Transform: [],
  Calculate: [],
  Filter: [],
  Special: [],
};

function addFuncDef(funcDef) {
  funcDef.params = funcDef.params || [];
  funcDef.defaultParams = funcDef.defaultParams || [];

  if (funcDef.category) {
    funcDef.category.push(funcDef);
  }
  index[funcDef.name] = funcDef;
  index[funcDef.shortName || funcDef.name] = funcDef;
}

var optionalSeriesRefArgs = [
  { name: 'other', type: 'value_or_series', optional: true },
  { name: 'other', type: 'value_or_series', optional: true },
  { name: 'other', type: 'value_or_series', optional: true },
  { name: 'other', type: 'value_or_series', optional: true },
  { name: 'other', type: 'value_or_series', optional: true },
];

addFuncDef({
  name: 'scaleToSeconds',
  category: categories.Transform,
  params: [{ name: 'seconds', type: 'int' }],
  defaultParams: [1],
});

addFuncDef({
  name: 'perSecond',
  category: categories.Transform,
  params: [{ name: 'max value', type: 'int', optional: true }],
  defaultParams: [],
});

addFuncDef({
  name: 'holtWintersForecast',
  category: categories.Calculate,
});

addFuncDef({
  name: 'holtWintersConfidenceBands',
  category: categories.Calculate,
  params: [{ name: 'delta', type: 'int' }],
  defaultParams: [3],
});

addFuncDef({
  name: 'holtWintersAberration',
  category: categories.Calculate,
  params: [{ name: 'delta', type: 'int' }],
  defaultParams: [3],
});

addFuncDef({
  name: 'nPercentile',
  category: categories.Calculate,
  params: [{ name: 'Nth percentile', type: 'int' }],
  defaultParams: [95],
});

addFuncDef({
  name: 'diffSeries',
  params: optionalSeriesRefArgs,
  defaultParams: ['#A'],
  category: categories.Calculate,
});

addFuncDef({
  name: 'stddevSeries',
  params: optionalSeriesRefArgs,
  defaultParams: [''],
  category: categories.Calculate,
});

addFuncDef({
  name: 'divideSeries',
  params: optionalSeriesRefArgs,
  defaultParams: ['#A'],
  category: categories.Calculate,
});

addFuncDef({
  name: 'multiplySeries',
  params: optionalSeriesRefArgs,
  defaultParams: ['#A'],
  category: categories.Calculate,
});

addFuncDef({
  name: 'asPercent',
  params: optionalSeriesRefArgs,
  defaultParams: ['#A'],
  category: categories.Calculate,
});

addFuncDef({
  name: 'group',
  params: optionalSeriesRefArgs,
  defaultParams: ['#A', '#B'],
  category: categories.Combine,
});

addFuncDef({
  name: 'sumSeries',
  shortName: 'sum',
  category: categories.Combine,
  params: optionalSeriesRefArgs,
  defaultParams: [''],
});

addFuncDef({
  name: 'averageSeries',
  shortName: 'avg',
  category: categories.Combine,
  params: optionalSeriesRefArgs,
  defaultParams: [''],
});

addFuncDef({
  name: 'rangeOfSeries',
  category: categories.Combine,
});

addFuncDef({
  name: 'percentileOfSeries',
  category: categories.Combine,
  params: [
    { name: 'n', type: 'int' },
    { name: 'interpolate', type: 'boolean', options: ['true', 'false'] },
  ],
  defaultParams: [95, 'false'],
});

addFuncDef({
  name: 'sumSeriesWithWildcards',
  category: categories.Combine,
  params: [
    { name: 'node', type: 'int' },
    { name: 'node', type: 'int', optional: true },
    { name: 'node', type: 'int', optional: true },
    { name: 'node', type: 'int', optional: true },
  ],
  defaultParams: [3],
});

addFuncDef({
  name: 'maxSeries',
  shortName: 'max',
  category: categories.Combine,
});

addFuncDef({
  name: 'minSeries',
  shortName: 'min',
  category: categories.Combine,
});

addFuncDef({
  name: 'averageSeriesWithWildcards',
  category: categories.Combine,
  params: [
    { name: 'node', type: 'int' },
    { name: 'node', type: 'int', optional: true },
  ],
  defaultParams: [3],
});

addFuncDef({
  name: 'alias',
  category: categories.Special,
  params: [{ name: 'alias', type: 'string' }],
  defaultParams: ['alias'],
});

addFuncDef({
  name: 'aliasSub',
  category: categories.Special,
  params: [
    { name: 'search', type: 'string' },
    { name: 'replace', type: 'string' },
  ],
  defaultParams: ['', '\\1'],
});

addFuncDef({
  name: 'stacked',
  category: categories.Special,
  params: [{ name: 'stack', type: 'string' }],
  defaultParams: ['stacked'],
});

addFuncDef({
  name: 'consolidateBy',
  category: categories.Special,
  params: [
    {
      name: 'function',
      type: 'string',
      options: ['sum', 'average', 'min', 'max'],
    },
  ],
  defaultParams: ['max'],
});

addFuncDef({
  name: 'cumulative',
  category: categories.Special,
  params: [],
  defaultParams: [],
});

addFuncDef({
  name: 'groupByNode',
  category: categories.Special,
  params: [
    {
      name: 'node',
      type: 'int',
      options: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12],
    },
    {
      name: 'function',
      type: 'string',
      options: ['sum', 'avg', 'maxSeries'],
    },
  ],
  defaultParams: [3, 'sum'],
});

addFuncDef({
  name: 'aliasByNode',
  category: categories.Special,
  params: [
    {
      name: 'node',
      type: 'int',
      options: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12],
    },
    {
      name: 'node',
      type: 'int',
      options: [0, -1, -2, -3, -4, -5, -6, -7],
      optional: true,
    },
    {
      name: 'node',
      type: 'int',
      options: [0, -1, -2, -3, -4, -5, -6, -7],
      optional: true,
    },
    {
      name: 'node',
      type: 'int',
      options: [0, -1, -2, -3, -4, -5, -6, -7],
      optional: true,
    },
  ],
  defaultParams: [3],
});

addFuncDef({
  name: 'substr',
  category: categories.Special,
  params: [
    {
      name: 'start',
      type: 'int',
      options: [-6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12],
    },
    {
      name: 'stop',
      type: 'int',
      options: [-6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12],
    },
  ],
  defaultParams: [0, 0],
});

addFuncDef({
  name: 'sortByName',
  category: categories.Special,
  params: [
    {
      name: 'natural',
      type: 'boolean',
      options: ['true', 'false'],
      optional: true,
    },
  ],
  defaultParams: ['false'],
});

addFuncDef({
  name: 'sortByMaxima',
  category: categories.Special,
});

addFuncDef({
  name: 'sortByMinima',
  category: categories.Special,
});

addFuncDef({
  name: 'sortByTotal',
  category: categories.Special,
});

addFuncDef({
  name: 'aliasByMetric',
  category: categories.Special,
});

addFuncDef({
  name: 'randomWalk',
  fake: true,
  category: categories.Special,
  params: [{ name: 'name', type: 'string' }],
  defaultParams: ['randomWalk'],
});

addFuncDef({
  name: 'countSeries',
  category: categories.Special,
});

addFuncDef({
  name: 'constantLine',
  category: categories.Special,
  params: [{ name: 'value', type: 'int' }],
  defaultParams: [10],
});

addFuncDef({
  name: 'cactiStyle',
  category: categories.Special,
});

addFuncDef({
  name: 'keepLastValue',
  category: categories.Special,
  params: [{ name: 'n', type: 'int' }],
  defaultParams: [100],
});

addFuncDef({
  name: 'changed',
  category: categories.Special,
  params: [],
  defaultParams: [],
});

addFuncDef({
  name: 'scale',
  category: categories.Transform,
  params: [{ name: 'factor', type: 'int' }],
  defaultParams: [1],
});

addFuncDef({
  name: 'offset',
  category: categories.Transform,
  params: [{ name: 'amount', type: 'int' }],
  defaultParams: [10],
});

addFuncDef({
  name: 'transformNull',
  category: categories.Transform,
  params: [{ name: 'amount', type: 'int' }],
  defaultParams: [0],
});

addFuncDef({
  name: 'integral',
  category: categories.Transform,
});

addFuncDef({
  name: 'derivative',
  category: categories.Transform,
});

addFuncDef({
  name: 'nonNegativeDerivative',
  category: categories.Transform,
  params: [{ name: 'max value or 0', type: 'int', optional: true }],
  defaultParams: [''],
});

addFuncDef({
  name: 'timeShift',
  category: categories.Transform,
  params: [
    {
      name: 'amount',
      type: 'select',
      options: ['1h', '6h', '12h', '1d', '2d', '7d', '14d', '30d'],
    },
  ],
  defaultParams: ['1d'],
});

addFuncDef({
  name: 'timeStack',
  category: categories.Transform,
  params: [
    {
      name: 'timeShiftUnit',
      type: 'select',
      options: ['1h', '6h', '12h', '1d', '2d', '7d', '14d', '30d'],
    },
    { name: 'timeShiftStart', type: 'int' },
    { name: 'timeShiftEnd', type: 'int' },
  ],
  defaultParams: ['1d', 0, 7],
});

addFuncDef({
  name: 'summarize',
  category: categories.Transform,
  params: [
    { name: 'interval', type: 'string' },
    {
      name: 'func',
      type: 'select',
      options: ['sum', 'avg', 'min', 'max', 'last'],
    },
    {
      name: 'alignToFrom',
      type: 'boolean',
      optional: true,
      options: ['false', 'true'],
    },
  ],
  defaultParams: ['1h', 'sum', 'false'],
});

addFuncDef({
  name: 'smartSummarize',
  category: categories.Transform,
  params: [
    { name: 'interval', type: 'string' },
    {
      name: 'func',
      type: 'select',
      options: ['sum', 'avg', 'min', 'max', 'last'],
    },
  ],
  defaultParams: ['1h', 'sum'],
});

addFuncDef({
  name: 'absolute',
  category: categories.Transform,
});

addFuncDef({
  name: 'hitcount',
  category: categories.Transform,
  params: [{ name: 'interval', type: 'string' }],
  defaultParams: ['10s'],
});

addFuncDef({
  name: 'log',
  category: categories.Transform,
  params: [{ name: 'base', type: 'int' }],
  defaultParams: ['10'],
});

addFuncDef({
  name: 'averageAbove',
  category: categories.Filter,
  params: [{ name: 'n', type: 'int' }],
  defaultParams: [25],
});

addFuncDef({
  name: 'averageBelow',
  category: categories.Filter,
  params: [{ name: 'n', type: 'int' }],
  defaultParams: [25],
});

addFuncDef({
  name: 'currentAbove',
  category: categories.Filter,
  params: [{ name: 'n', type: 'int' }],
  defaultParams: [25],
});

addFuncDef({
  name: 'currentBelow',
  category: categories.Filter,
  params: [{ name: 'n', type: 'int' }],
  defaultParams: [25],
});

addFuncDef({
  name: 'maximumAbove',
  category: categories.Filter,
  params: [{ name: 'value', type: 'int' }],
  defaultParams: [0],
});

addFuncDef({
  name: 'maximumBelow',
  category: categories.Filter,
  params: [{ name: 'value', type: 'int' }],
  defaultParams: [0],
});

addFuncDef({
  name: 'minimumAbove',
  category: categories.Filter,
  params: [{ name: 'value', type: 'int' }],
  defaultParams: [0],
});

addFuncDef({
  name: 'minimumBelow',
  category: categories.Filter,
  params: [{ name: 'value', type: 'int' }],
  defaultParams: [0],
});

addFuncDef({
  name: 'limit',
  category: categories.Filter,
  params: [{ name: 'n', type: 'int' }],
  defaultParams: [5],
});

addFuncDef({
  name: 'mostDeviant',
  category: categories.Filter,
  params: [{ name: 'n', type: 'int' }],
  defaultParams: [10],
});

addFuncDef({
  name: 'exclude',
  category: categories.Filter,
  params: [{ name: 'exclude', type: 'string' }],
  defaultParams: ['exclude'],
});

addFuncDef({
  name: 'highestCurrent',
  category: categories.Filter,
  params: [{ name: 'count', type: 'int' }],
  defaultParams: [5],
});

addFuncDef({
  name: 'highestMax',
  category: categories.Filter,
  params: [{ name: 'count', type: 'int' }],
  defaultParams: [5],
});

addFuncDef({
  name: 'lowestCurrent',
  category: categories.Filter,
  params: [{ name: 'count', type: 'int' }],
  defaultParams: [5],
});

addFuncDef({
  name: 'movingAverage',
  category: categories.Filter,
  params: [
    {
      name: 'windowSize',
      type: 'int_or_interval',
      options: ['5', '7', '10', '5min', '10min', '30min', '1hour'],
    },
  ],
  defaultParams: [10],
});

addFuncDef({
  name: 'movingMedian',
  category: categories.Filter,
  params: [
    {
      name: 'windowSize',
      type: 'int_or_interval',
      options: ['5', '7', '10', '5min', '10min', '30min', '1hour'],
    },
  ],
  defaultParams: ['5'],
});

addFuncDef({
  name: 'stdev',
  category: categories.Filter,
  params: [{ name: 'n', type: 'int' }, { name: 'tolerance', type: 'int' }],
  defaultParams: [5, 0.1],
});

addFuncDef({
  name: 'highestAverage',
  category: categories.Filter,
  params: [{ name: 'count', type: 'int' }],
  defaultParams: [5],
});

addFuncDef({
  name: 'lowestAverage',
  category: categories.Filter,
  params: [{ name: 'count', type: 'int' }],
  defaultParams: [5],
});

addFuncDef({
  name: 'removeAbovePercentile',
  category: categories.Filter,
  params: [{ name: 'n', type: 'int' }],
  defaultParams: [5],
});

addFuncDef({
  name: 'removeAboveValue',
  category: categories.Filter,
  params: [{ name: 'n', type: 'int' }],
  defaultParams: [5],
});

addFuncDef({
  name: 'removeBelowPercentile',
  category: categories.Filter,
  params: [{ name: 'n', type: 'int' }],
  defaultParams: [5],
});

addFuncDef({
  name: 'removeBelowValue',
  category: categories.Filter,
  params: [{ name: 'n', type: 'int' }],
  defaultParams: [5],
});

addFuncDef({
  name: 'useSeriesAbove',
  category: categories.Filter,
  params: [
    { name: 'value', type: 'int' },
    { name: 'search', type: 'string' },
    { name: 'replace', type: 'string' },
  ],
  defaultParams: [0, 'search', 'replace'],
});

////////////////////
// Graphite 1.0.x //
////////////////////

addFuncDef({
  name: 'aggregateLine',
  category: categories.Combine,
  params: [
    {
      name: 'func',
      type: 'select',
      options: ['sum', 'avg', 'min', 'max', 'last'],
    },
  ],
  defaultParams: ['avg'],
  version: '1.0',
});

addFuncDef({
  name: 'averageOutsidePercentile',
  category: categories.Filter,
  params: [{ name: 'n', type: 'int' }],
  defaultParams: [95],
  version: '1.0',
});

addFuncDef({
  name: 'delay',
  category: categories.Transform,
  params: [{ name: 'steps', type: 'int' }],
  defaultParams: [1],
  version: '1.0',
});

addFuncDef({
  name: 'exponentialMovingAverage',
  category: categories.Calculate,
  params: [
    {
      name: 'windowSize',
      type: 'int_or_interval',
      options: ['5', '7', '10', '5min', '10min', '30min', '1hour'],
    },
  ],
  defaultParams: [10],
  version: '1.0',
});

addFuncDef({
  name: 'fallbackSeries',
  category: categories.Special,
  params: [{ name: 'fallback', type: 'string' }],
  defaultParams: ['constantLine(0)'],
  version: '1.0',
});

addFuncDef({
  name: 'grep',
  category: categories.Filter,
  params: [{ name: 'grep', type: 'string' }],
  defaultParams: ['grep'],
  version: '1.0',
});

addFuncDef({
  name: 'groupByNodes',
  category: categories.Special,
  params: [
    {
      name: 'function',
      type: 'string',
      options: ['sum', 'avg', 'maxSeries'],
    },
    {
      name: 'node',
      type: 'int',
      options: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12],
    },
    {
      name: 'node',
      type: 'int',
      options: [0, -1, -2, -3, -4, -5, -6, -7],
      optional: true,
    },
    {
      name: 'node',
      type: 'int',
      options: [0, -1, -2, -3, -4, -5, -6, -7],
      optional: true,
    },
    {
      name: 'node',
      type: 'int',
      options: [0, -1, -2, -3, -4, -5, -6, -7],
      optional: true,
    },
  ],
  defaultParams: ['sum', 3],
  version: '1.0',
});

addFuncDef({
  name: 'integralByInterval',
  category: categories.Transform,
  params: [
    {
      name: 'intervalUnit',
      type: 'select',
      options: ['1h', '6h', '12h', '1d', '2d', '7d', '14d', '30d'],
    },
  ],
  defaultParams: ['1d'],
  version: '1.0',
});

addFuncDef({
  name: 'interpolate',
  category: categories.Transform,
  params: [{ name: 'limit', type: 'int', optional: true }],
  defaultParams: [],
  version: '1.0',
});

addFuncDef({
  name: 'invert',
  category: categories.Transform,
  version: '1.0',
});

addFuncDef({
  name: 'isNonNull',
  category: categories.Combine,
  version: '1.0',
});

addFuncDef({
  name: 'linearRegression',
  category: categories.Calculate,
  params: [
    {
      name: 'startSourceAt',
      type: 'select',
      options: ['-1h', '-6h', '-12h', '-1d', '-2d', '-7d', '-14d', '-30d'],
      optional: true,
    },
    {
      name: 'endSourceAt',
      type: 'select',
      options: ['-1h', '-6h', '-12h', '-1d', '-2d', '-7d', '-14d', '-30d'],
      optional: true,
    },
  ],
  defaultParams: [],
  version: '1.0',
});

addFuncDef({
  name: 'mapSeries',
  shortName: 'map',
  params: [{ name: 'node', type: 'int' }],
  defaultParams: [3],
  category: categories.Combine,
  version: '1.0',
});

addFuncDef({
  name: 'movingMin',
  category: categories.Calculate,
  params: [
    {
      name: 'windowSize',
      type: 'int_or_interval',
      options: ['5', '7', '10', '5min', '10min', '30min', '1hour'],
    },
  ],
  defaultParams: [10],
  version: '1.0',
});

addFuncDef({
  name: 'movingMax',
  category: categories.Calculate,
  params: [
    {
      name: 'windowSize',
      type: 'int_or_interval',
      options: ['5', '7', '10', '5min', '10min', '30min', '1hour'],
    },
  ],
  defaultParams: [10],
  version: '1.0',
});

addFuncDef({
  name: 'movingSum',
  category: categories.Calculate,
  params: [
    {
      name: 'windowSize',
      type: 'int_or_interval',
      options: ['5', '7', '10', '5min', '10min', '30min', '1hour'],
    },
  ],
  defaultParams: [10],
  version: '1.0',
});

addFuncDef({
  name: 'multiplySeriesWithWildcards',
  category: categories.Calculate,
  params: [
    {
      name: 'position',
      type: 'int',
      options: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12],
    },
    {
      name: 'position',
      type: 'int',
      options: [0, -1, -2, -3, -4, -5, -6, -7],
      optional: true,
    },
    {
      name: 'position',
      type: 'int',
      options: [0, -1, -2, -3, -4, -5, -6, -7],
      optional: true,
    },
    {
      name: 'position',
      type: 'int',
      options: [0, -1, -2, -3, -4, -5, -6, -7],
      optional: true,
    },
  ],
  defaultParams: [2],
  version: '1.0',
});

addFuncDef({
  name: 'offsetToZero',
  category: categories.Transform,
  version: '1.0',
});

addFuncDef({
  name: 'pow',
  category: categories.Transform,
  params: [{ name: 'factor', type: 'int' }],
  defaultParams: [10],
  version: '1.0',
});

addFuncDef({
  name: 'powSeries',
  category: categories.Transform,
  params: optionalSeriesRefArgs,
  defaultParams: [''],
  version: '1.0',
});

addFuncDef({
  name: 'reduceSeries',
  shortName: 'reduce',
  params: [
    {
      name: 'function',
      type: 'string',
      options: ['asPercent', 'diffSeries', 'divideSeries'],
    },
    {
      name: 'reduceNode',
      type: 'int',
      options: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13],
    },
    { name: 'reduceMatchers', type: 'string' },
    { name: 'reduceMatchers', type: 'string' },
  ],
  defaultParams: ['asPercent', 2, 'used_bytes', 'total_bytes'],
  category: categories.Combine,
  version: '1.0',
});

addFuncDef({
  name: 'removeBetweenPercentile',
  category: categories.Filter,
  params: [{ name: 'n', type: 'int' }],
  defaultParams: [95],
  version: '1.0',
});

addFuncDef({
  name: 'removeEmptySeries',
  category: categories.Filter,
  version: '1.0',
});

addFuncDef({
  name: 'squareRoot',
  category: categories.Transform,
  version: '1.0',
});

addFuncDef({
  name: 'timeSlice',
  category: categories.Transform,
  params: [
    {
      name: 'startSliceAt',
      type: 'select',
      options: ['-1h', '-6h', '-12h', '-1d', '-2d', '-7d', '-14d', '-30d'],
    },
    {
      name: 'endSliceAt',
      type: 'select',
      options: ['-1h', '-6h', '-12h', '-1d', '-2d', '-7d', '-14d', '-30d'],
      optional: true,
    },
  ],
  defaultParams: ['-1h'],
  version: '1.0',
});

addFuncDef({
  name: 'weightedAverage',
  category: categories.Filter,
  params: [
    { name: 'other', type: 'value_or_series', optional: true },
    {
      name: 'node',
      type: 'int',
      options: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12],
    },
  ],
  defaultParams: ['#A', 4],
  version: '1.0',
});

addFuncDef({
  name: 'seriesByTag',
  category: categories.Special,
  params: [
    { name: 'tagExpression', type: 'string' },
    { name: 'tagExpression', type: 'string', optional: true },
    { name: 'tagExpression', type: 'string', optional: true },
    { name: 'tagExpression', type: 'string', optional: true },
  ],
  version: '1.1',
});

addFuncDef({
  name: 'groupByTags',
  category: categories.Special,
  params: [
    {
      name: 'function',
      type: 'string',
      options: ['sum', 'avg', 'maxSeries'],
    },
    { name: 'tag', type: 'string' },
    { name: 'tag', type: 'string', optional: true },
    { name: 'tag', type: 'string', optional: true },
    { name: 'tag', type: 'string', optional: true },
  ],
  defaultParams: ['sum', 'tag'],
  version: '1.1',
});

addFuncDef({
  name: 'aliasByTags',
  category: categories.Special,
  params: [
    { name: 'tag', type: 'string' },
    { name: 'tag', type: 'string', optional: true },
    { name: 'tag', type: 'string', optional: true },
    { name: 'tag', type: 'string', optional: true },
  ],
  defaultParams: ['tag'],
  version: '1.1',
});

_.each(categories, function(funcList, catName) {
  categories[catName] = _.sortBy(funcList, 'name');
});

function isVersionRelatedFunction(func, graphiteVersion) {
  return isVersionGtOrEq(graphiteVersion, func.version) || !func.version;
}

export class FuncInstance {
  def: any;
  params: any;
  text: any;
  added: boolean;

  constructor(funcDef, options) {
    this.def = funcDef;
    this.params = [];

    if (options && options.withDefaultParams) {
      this.params = funcDef.defaultParams.slice(0);
    }

    this.updateText();
  }

  render(metricExp) {
    var str = this.def.name + '(';
    var parameters = _.map(
      this.params,
      function(value, index) {
        var paramType = this.def.params[index].type;
        if (
          paramType === 'int' ||
          paramType === 'value_or_series' ||
          paramType === 'boolean'
        ) {
          return value;
        } else if (paramType === 'int_or_interval' && $.isNumeric(value)) {
          return value;
        }

        return "'" + value + "'";
      }.bind(this)
    );

    if (metricExp) {
      parameters.unshift(metricExp);
    }

    return str + parameters.join(', ') + ')';
  }

  _hasMultipleParamsInString(strValue, index) {
    if (strValue.indexOf(',') === -1) {
      return false;
    }

    return this.def.params[index + 1] && this.def.params[index + 1].optional;
  }

  updateParam(strValue, index) {
    // handle optional parameters
    // if string contains ',' and next param is optional, split and update both
    if (this._hasMultipleParamsInString(strValue, index)) {
      _.each(
        strValue.split(','),
        function(partVal, idx) {
          this.updateParam(partVal.trim(), index + idx);
        }.bind(this)
      );
      return;
    }

    if (strValue === '' && this.def.params[index].optional) {
      this.params.splice(index, 1);
    } else {
      this.params[index] = strValue;
    }

    this.updateText();
  }

  updateText() {
    if (this.params.length === 0) {
      this.text = this.def.name + '()';
      return;
    }

    var text = this.def.name + '(';
    text += this.params.join(', ');
    text += ')';
    this.text = text;
  }
}

export default {
  createFuncInstance: function(funcDef, options?) {
    if (_.isString(funcDef)) {
      if (!index[funcDef]) {
        throw { message: 'Method not found ' + name };
      }
      funcDef = index[funcDef];
    }
    return new FuncInstance(funcDef, options);
  },

  getFuncDef: function(name) {
    return index[name];
  },

  getCategories: function(graphiteVersion) {
    var filteredCategories: any = {};
    _.each(categories, function(functions, category) {
      var filteredFuncs = _.filter(functions, function(func) {
        return isVersionRelatedFunction(func, graphiteVersion);
      });
      if (filteredFuncs.length) {
        filteredCategories[category] = filteredFuncs;
      }
    });

    return filteredCategories;
  },
};