import _ from 'lodash';
import moment from 'moment';

var kbn: any = {};

kbn.valueFormats = {};

kbn.regexEscape = function(value) {
  return value.replace(/[\\^$*+?.()|[\]{}\/]/g, '\\$&');
};

///// HELPER FUNCTIONS /////

kbn.round_interval = function(interval) {
  switch (true) {
    // 0.015s
    case interval < 15:
      return 10; // 0.01s
    // 0.035s
    case interval < 35:
      return 20; // 0.02s
    // 0.075s
    case interval < 75:
      return 50; // 0.05s
    // 0.15s
    case interval < 150:
      return 100; // 0.1s
    // 0.35s
    case interval < 350:
      return 200; // 0.2s
    // 0.75s
    case interval < 750:
      return 500; // 0.5s
    // 1.5s
    case interval < 1500:
      return 1000; // 1s
    // 3.5s
    case interval < 3500:
      return 2000; // 2s
    // 7.5s
    case interval < 7500:
      return 5000; // 5s
    // 12.5s
    case interval < 12500:
      return 10000; // 10s
    // 17.5s
    case interval < 17500:
      return 15000; // 15s
    // 25s
    case interval < 25000:
      return 20000; // 20s
    // 45s
    case interval < 45000:
      return 30000; // 30s
    // 1.5m
    case interval < 90000:
      return 60000; // 1m
    // 3.5m
    case interval < 210000:
      return 120000; // 2m
    // 7.5m
    case interval < 450000:
      return 300000; // 5m
    // 12.5m
    case interval < 750000:
      return 600000; // 10m
    // 12.5m
    case interval < 1050000:
      return 900000; // 15m
    // 25m
    case interval < 1500000:
      return 1200000; // 20m
    // 45m
    case interval < 2700000:
      return 1800000; // 30m
    // 1.5h
    case interval < 5400000:
      return 3600000; // 1h
    // 2.5h
    case interval < 9000000:
      return 7200000; // 2h
    // 4.5h
    case interval < 16200000:
      return 10800000; // 3h
    // 9h
    case interval < 32400000:
      return 21600000; // 6h
    // 1d
    case interval < 86400000:
      return 43200000; // 12h
    // 1w
    case interval < 604800000:
      return 86400000; // 1d
    // 3w
    case interval < 1814400000:
      return 604800000; // 1w
    // 6w
    case interval < 3628800000:
      return 2592000000; // 30d
    default:
      return 31536000000; // 1y
  }
};

kbn.secondsToHms = function(seconds) {
  var numyears = Math.floor(seconds / 31536000);
  if (numyears) {
    return numyears + 'y';
  }
  var numdays = Math.floor((seconds % 31536000) / 86400);
  if (numdays) {
    return numdays + 'd';
  }
  var numhours = Math.floor(((seconds % 31536000) % 86400) / 3600);
  if (numhours) {
    return numhours + 'h';
  }
  var numminutes = Math.floor((((seconds % 31536000) % 86400) % 3600) / 60);
  if (numminutes) {
    return numminutes + 'm';
  }
  var numseconds = Math.floor((((seconds % 31536000) % 86400) % 3600) % 60);
  if (numseconds) {
    return numseconds + 's';
  }
  var nummilliseconds = Math.floor(seconds * 1000.0);
  if (nummilliseconds) {
    return nummilliseconds + 'ms';
  }

  return 'less than a millisecond'; //'just now' //or other string you like;
};

kbn.to_percent = function(nr, outof) {
  return Math.floor(nr / outof * 10000) / 100 + '%';
};

kbn.addslashes = function(str) {
  str = str.replace(/\\/g, '\\\\');
  str = str.replace(/\'/g, "\\'");
  str = str.replace(/\"/g, '\\"');
  str = str.replace(/\0/g, '\\0');
  return str;
};

kbn.interval_regex = /(\d+(?:\.\d+)?)(ms|[Mwdhmsy])/;

// histogram & trends
kbn.intervals_in_seconds = {
  y: 31536000,
  M: 2592000,
  w: 604800,
  d: 86400,
  h: 3600,
  m: 60,
  s: 1,
  ms: 0.001,
};

kbn.calculateInterval = function(range, resolution, lowLimitInterval) {
  var lowLimitMs = 1; // 1 millisecond default low limit
  var intervalMs;

  if (lowLimitInterval) {
    if (lowLimitInterval[0] === '>') {
      lowLimitInterval = lowLimitInterval.slice(1);
    }
    lowLimitMs = kbn.interval_to_ms(lowLimitInterval);
  }

  intervalMs = kbn.round_interval((range.to.valueOf() - range.from.valueOf()) / resolution);
  if (lowLimitMs > intervalMs) {
    intervalMs = lowLimitMs;
  }

  return {
    intervalMs: intervalMs,
    interval: kbn.secondsToHms(intervalMs / 1000),
  };
};

kbn.describe_interval = function(str) {
  var matches = str.match(kbn.interval_regex);
  if (!matches || !_.has(kbn.intervals_in_seconds, matches[2])) {
    throw new Error('Invalid interval string, expecting a number followed by one of "Mwdhmsy"');
  } else {
    return {
      sec: kbn.intervals_in_seconds[matches[2]],
      type: matches[2],
      count: parseInt(matches[1], 10),
    };
  }
};

kbn.interval_to_ms = function(str) {
  var info = kbn.describe_interval(str);
  return info.sec * 1000 * info.count;
};

kbn.interval_to_seconds = function(str) {
  var info = kbn.describe_interval(str);
  return info.sec * info.count;
};

kbn.query_color_dot = function(color, diameter) {
  return (
    '<div class="icon-circle" style="' +
    ['display:inline-block', 'color:' + color, 'font-size:' + diameter + 'px'].join(';') +
    '"></div>'
  );
};

kbn.slugifyForUrl = function(str) {
  return str
    .toLowerCase()
    .replace(/[^\w ]+/g, '')
    .replace(/ +/g, '-');
};

kbn.stringToJsRegex = function(str) {
  if (str[0] !== '/') {
    return new RegExp('^' + str + '$');
  }

  var match = str.match(new RegExp('^/(.*?)/(g?i?m?y?)$'));
  return new RegExp(match[1], match[2]);
};

kbn.toFixed = function(value, decimals) {
  if (value === null) {
    return '';
  }

  var factor = decimals ? Math.pow(10, Math.max(0, decimals)) : 1;
  var formatted = String(Math.round(value * factor) / factor);

  // if exponent return directly
  if (formatted.indexOf('e') !== -1 || value === 0) {
    return formatted;
  }

  // If tickDecimals was specified, ensure that we have exactly that
  // much precision; otherwise default to the value's own precision.
  if (decimals != null) {
    var decimalPos = formatted.indexOf('.');
    var precision = decimalPos === -1 ? 0 : formatted.length - decimalPos - 1;
    if (precision < decimals) {
      return (precision ? formatted : formatted + '.') + String(factor).substr(1, decimals - precision);
    }
  }

  return formatted;
};

kbn.toFixedScaled = function(value, decimals, scaledDecimals, additionalDecimals, ext) {
  if (scaledDecimals === null) {
    return kbn.toFixed(value, decimals) + ext;
  } else {
    return kbn.toFixed(value, scaledDecimals + additionalDecimals) + ext;
  }
};

kbn.roundValue = function(num, decimals) {
  if (num === null) {
    return null;
  }
  var n = Math.pow(10, decimals);
  var formatted = (n * num).toFixed(decimals);
  return Math.round(parseFloat(formatted)) / n;
};

///// FORMAT FUNCTION CONSTRUCTORS /////

kbn.formatBuilders = {};

// Formatter which always appends a fixed unit string to the value. No
// scaling of the value is performed.
kbn.formatBuilders.fixedUnit = function(unit) {
  return function(size, decimals) {
    if (size === null) {
      return '';
    }
    return kbn.toFixed(size, decimals) + ' ' + unit;
  };
};

// Formatter which scales the unit string geometrically according to the given
// numeric factor. Repeatedly scales the value down by the factor until it is
// less than the factor in magnitude, or the end of the array is reached.
kbn.formatBuilders.scaledUnits = function(factor, extArray) {
  return function(size, decimals, scaledDecimals) {
    if (size === null) {
      return '';
    }

    var steps = 0;
    var limit = extArray.length;

    while (Math.abs(size) >= factor) {
      steps++;
      size /= factor;

      if (steps >= limit) {
        return 'NA';
      }
    }

    if (steps > 0 && scaledDecimals !== null) {
      decimals = scaledDecimals + 3 * steps;
    }

    return kbn.toFixed(size, decimals) + extArray[steps];
  };
};

// Extension of the scaledUnits builder which uses SI decimal prefixes. If an
// offset is given, it adjusts the starting units at the given prefix; a value
// of 0 starts at no scale; -3 drops to nano, +2 starts at mega, etc.
kbn.formatBuilders.decimalSIPrefix = function(unit, offset) {
  var prefixes = ['n', 'µ', 'm', '', 'k', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y'];
  prefixes = prefixes.slice(3 + (offset || 0));
  var units = prefixes.map(function(p) {
    return ' ' + p + unit;
  });
  return kbn.formatBuilders.scaledUnits(1000, units);
};

// Extension of the scaledUnits builder which uses SI binary prefixes. If
// offset is given, it starts the units at the given prefix; otherwise, the
// offset defaults to zero and the initial unit is not prefixed.
kbn.formatBuilders.binarySIPrefix = function(unit, offset) {
  var prefixes = ['', 'Ki', 'Mi', 'Gi', 'Ti', 'Pi', 'Ei', 'Zi', 'Yi'].slice(offset);
  var units = prefixes.map(function(p) {
    return ' ' + p + unit;
  });
  return kbn.formatBuilders.scaledUnits(1024, units);
};

// Currency formatter for prefixing a symbol onto a number. Supports scaling
// up to the trillions.
kbn.formatBuilders.currency = function(symbol) {
  var units = ['', 'K', 'M', 'B', 'T'];
  var scaler = kbn.formatBuilders.scaledUnits(1000, units);
  return function(size, decimals, scaledDecimals) {
    if (size === null) {
      return '';
    }
    var scaled = scaler(size, decimals, scaledDecimals);
    return symbol + scaled;
  };
};

kbn.formatBuilders.simpleCountUnit = function(symbol) {
  var units = ['', 'K', 'M', 'B', 'T'];
  var scaler = kbn.formatBuilders.scaledUnits(1000, units);
  return function(size, decimals, scaledDecimals) {
    if (size === null) {
      return '';
    }
    var scaled = scaler(size, decimals, scaledDecimals);
    return scaled + ' ' + symbol;
  };
};

///// VALUE FORMATS /////

// Dimensionless Units
kbn.valueFormats.none = kbn.toFixed;
kbn.valueFormats.short = kbn.formatBuilders.scaledUnits(1000, [
  '',
  ' K',
  ' Mil',
  ' Bil',
  ' Tri',
  ' Quadr',
  ' Quint',
  ' Sext',
  ' Sept',
]);
kbn.valueFormats.dB = kbn.formatBuilders.fixedUnit('dB');
kbn.valueFormats.ppm = kbn.formatBuilders.fixedUnit('ppm');

kbn.valueFormats.percent = function(size, decimals) {
  if (size === null) {
    return '';
  }
  return kbn.toFixed(size, decimals) + '%';
};

kbn.valueFormats.percentunit = function(size, decimals) {
  if (size === null) {
    return '';
  }
  return kbn.toFixed(100 * size, decimals) + '%';
};

/* Formats the value to hex. Uses float if specified decimals are not 0.
 * There are two options, one with 0x, and one without */

kbn.valueFormats.hex = function(value, decimals) {
  if (value == null) {
    return '';
  }
  return parseFloat(kbn.toFixed(value, decimals))
    .toString(16)
    .toUpperCase();
};

kbn.valueFormats.hex0x = function(value, decimals) {
  if (value == null) {
    return '';
  }
  var hexString = kbn.valueFormats.hex(value, decimals);
  if (hexString.substring(0, 1) === '-') {
    return '-0x' + hexString.substring(1);
  }
  return '0x' + hexString;
};

kbn.valueFormats.sci = function(value, decimals) {
  return value.toExponential(decimals);
};

kbn.valueFormats.locale = function(value, decimals) {
  return value.toLocaleString(undefined, { maximumFractionDigits: decimals });
};

// Currencies
kbn.valueFormats.currencyUSD = kbn.formatBuilders.currency('$');
kbn.valueFormats.currencyGBP = kbn.formatBuilders.currency('£');
kbn.valueFormats.currencyEUR = kbn.formatBuilders.currency('€');
kbn.valueFormats.currencyJPY = kbn.formatBuilders.currency('¥');
kbn.valueFormats.currencyRUB = kbn.formatBuilders.currency('₽');
kbn.valueFormats.currencyUAH = kbn.formatBuilders.currency('₴');
kbn.valueFormats.currencyBRL = kbn.formatBuilders.currency('R$');
kbn.valueFormats.currencyDKK = kbn.formatBuilders.currency('kr');
kbn.valueFormats.currencyISK = kbn.formatBuilders.currency('kr');
kbn.valueFormats.currencyNOK = kbn.formatBuilders.currency('kr');
kbn.valueFormats.currencySEK = kbn.formatBuilders.currency('kr');

// Data (Binary)
kbn.valueFormats.bits = kbn.formatBuilders.binarySIPrefix('b');
kbn.valueFormats.bytes = kbn.formatBuilders.binarySIPrefix('B');
kbn.valueFormats.kbytes = kbn.formatBuilders.binarySIPrefix('B', 1);
kbn.valueFormats.mbytes = kbn.formatBuilders.binarySIPrefix('B', 2);
kbn.valueFormats.gbytes = kbn.formatBuilders.binarySIPrefix('B', 3);

// Data (Decimal)
kbn.valueFormats.decbits = kbn.formatBuilders.decimalSIPrefix('b');
kbn.valueFormats.decbytes = kbn.formatBuilders.decimalSIPrefix('B');
kbn.valueFormats.deckbytes = kbn.formatBuilders.decimalSIPrefix('B', 1);
kbn.valueFormats.decmbytes = kbn.formatBuilders.decimalSIPrefix('B', 2);
kbn.valueFormats.decgbytes = kbn.formatBuilders.decimalSIPrefix('B', 3);

// Data Rate
kbn.valueFormats.pps = kbn.formatBuilders.decimalSIPrefix('pps');
kbn.valueFormats.bps = kbn.formatBuilders.decimalSIPrefix('bps');
kbn.valueFormats.Bps = kbn.formatBuilders.decimalSIPrefix('Bps');
kbn.valueFormats.KBs = kbn.formatBuilders.decimalSIPrefix('Bs', 1);
kbn.valueFormats.Kbits = kbn.formatBuilders.decimalSIPrefix('bps', 1);
kbn.valueFormats.MBs = kbn.formatBuilders.decimalSIPrefix('Bs', 2);
kbn.valueFormats.Mbits = kbn.formatBuilders.decimalSIPrefix('bps', 2);
kbn.valueFormats.GBs = kbn.formatBuilders.decimalSIPrefix('Bs', 3);
kbn.valueFormats.Gbits = kbn.formatBuilders.decimalSIPrefix('bps', 3);

// Throughput
kbn.valueFormats.ops = kbn.formatBuilders.simpleCountUnit('ops');
kbn.valueFormats.rps = kbn.formatBuilders.simpleCountUnit('rps');
kbn.valueFormats.wps = kbn.formatBuilders.simpleCountUnit('wps');
kbn.valueFormats.iops = kbn.formatBuilders.simpleCountUnit('iops');
kbn.valueFormats.opm = kbn.formatBuilders.simpleCountUnit('opm');
kbn.valueFormats.rpm = kbn.formatBuilders.simpleCountUnit('rpm');
kbn.valueFormats.wpm = kbn.formatBuilders.simpleCountUnit('wpm');

// Energy
kbn.valueFormats.watt = kbn.formatBuilders.decimalSIPrefix('W');
kbn.valueFormats.kwatt = kbn.formatBuilders.decimalSIPrefix('W', 1);
kbn.valueFormats.mwatt = kbn.formatBuilders.decimalSIPrefix('W', -1);
kbn.valueFormats.kwattm = kbn.formatBuilders.decimalSIPrefix('W/Min', 1);
kbn.valueFormats.voltamp = kbn.formatBuilders.decimalSIPrefix('VA');
kbn.valueFormats.kvoltamp = kbn.formatBuilders.decimalSIPrefix('VA', 1);
kbn.valueFormats.voltampreact = kbn.formatBuilders.decimalSIPrefix('var');
kbn.valueFormats.kvoltampreact = kbn.formatBuilders.decimalSIPrefix('var', 1);
kbn.valueFormats.watth = kbn.formatBuilders.decimalSIPrefix('Wh');
kbn.valueFormats.kwatth = kbn.formatBuilders.decimalSIPrefix('Wh', 1);
kbn.valueFormats.joule = kbn.formatBuilders.decimalSIPrefix('J');
kbn.valueFormats.ev = kbn.formatBuilders.decimalSIPrefix('eV');
kbn.valueFormats.amp = kbn.formatBuilders.decimalSIPrefix('A');
kbn.valueFormats.kamp = kbn.formatBuilders.decimalSIPrefix('A', 1);
kbn.valueFormats.mamp = kbn.formatBuilders.decimalSIPrefix('A', -1);
kbn.valueFormats.volt = kbn.formatBuilders.decimalSIPrefix('V');
kbn.valueFormats.kvolt = kbn.formatBuilders.decimalSIPrefix('V', 1);
kbn.valueFormats.mvolt = kbn.formatBuilders.decimalSIPrefix('V', -1);
kbn.valueFormats.dBm = kbn.formatBuilders.decimalSIPrefix('dBm');
kbn.valueFormats.ohm = kbn.formatBuilders.decimalSIPrefix('Ω');
kbn.valueFormats.lumens = kbn.formatBuilders.decimalSIPrefix('Lm');

// Temperature
kbn.valueFormats.celsius = kbn.formatBuilders.fixedUnit('°C');
kbn.valueFormats.farenheit = kbn.formatBuilders.fixedUnit('°F');
kbn.valueFormats.kelvin = kbn.formatBuilders.fixedUnit('K');
kbn.valueFormats.humidity = kbn.formatBuilders.fixedUnit('%H');

// Pressure
kbn.valueFormats.pressurebar = kbn.formatBuilders.decimalSIPrefix('bar');
kbn.valueFormats.pressurembar = kbn.formatBuilders.decimalSIPrefix('bar', -1);
kbn.valueFormats.pressurekbar = kbn.formatBuilders.decimalSIPrefix('bar', 1);
kbn.valueFormats.pressurehpa = kbn.formatBuilders.fixedUnit('hPa');
kbn.valueFormats.pressurehg = kbn.formatBuilders.fixedUnit('"Hg');
kbn.valueFormats.pressurepsi = kbn.formatBuilders.scaledUnits(1000, [' psi', ' ksi', ' Mpsi']);

// Force
kbn.valueFormats.forceNm = kbn.formatBuilders.decimalSIPrefix('Nm');
kbn.valueFormats.forcekNm = kbn.formatBuilders.decimalSIPrefix('Nm', 1);
kbn.valueFormats.forceN = kbn.formatBuilders.decimalSIPrefix('N');
kbn.valueFormats.forcekN = kbn.formatBuilders.decimalSIPrefix('N', 1);

// Length
kbn.valueFormats.lengthm = kbn.formatBuilders.decimalSIPrefix('m');
kbn.valueFormats.lengthmm = kbn.formatBuilders.decimalSIPrefix('m', -1);
kbn.valueFormats.lengthkm = kbn.formatBuilders.decimalSIPrefix('m', 1);
kbn.valueFormats.lengthmi = kbn.formatBuilders.fixedUnit('mi');
kbn.valueFormats.lengthft = kbn.formatBuilders.fixedUnit('ft');

// Area
kbn.valueFormats.areaM2 = kbn.formatBuilders.fixedUnit('m²');
kbn.valueFormats.areaF2 = kbn.formatBuilders.fixedUnit('ft²');
kbn.valueFormats.areaMI2 = kbn.formatBuilders.fixedUnit('mi²');

// Mass
kbn.valueFormats.massmg = kbn.formatBuilders.decimalSIPrefix('g', -1);
kbn.valueFormats.massg = kbn.formatBuilders.decimalSIPrefix('g');
kbn.valueFormats.masskg = kbn.formatBuilders.decimalSIPrefix('g', 1);
kbn.valueFormats.masst = kbn.formatBuilders.fixedUnit('t');

// Velocity
kbn.valueFormats.velocityms = kbn.formatBuilders.fixedUnit('m/s');
kbn.valueFormats.velocitykmh = kbn.formatBuilders.fixedUnit('km/h');
kbn.valueFormats.velocitymph = kbn.formatBuilders.fixedUnit('mph');
kbn.valueFormats.velocityknot = kbn.formatBuilders.fixedUnit('kn');

// Acceleration
kbn.valueFormats.accMS2 = kbn.formatBuilders.fixedUnit('m/sec²');
kbn.valueFormats.accFS2 = kbn.formatBuilders.fixedUnit('f/sec²');
kbn.valueFormats.accG = kbn.formatBuilders.fixedUnit('g');

// Volume
kbn.valueFormats.litre = kbn.formatBuilders.decimalSIPrefix('L');
kbn.valueFormats.mlitre = kbn.formatBuilders.decimalSIPrefix('L', -1);
kbn.valueFormats.m3 = kbn.formatBuilders.fixedUnit('m3');
kbn.valueFormats.dm3 = kbn.formatBuilders.fixedUnit('dm3');
kbn.valueFormats.gallons = kbn.formatBuilders.fixedUnit('gal');

// Flow
kbn.valueFormats.flowgpm = kbn.formatBuilders.fixedUnit('gpm');
kbn.valueFormats.flowcms = kbn.formatBuilders.fixedUnit('cms');
kbn.valueFormats.flowcfs = kbn.formatBuilders.fixedUnit('cfs');
kbn.valueFormats.flowcfm = kbn.formatBuilders.fixedUnit('cfm');

// Angle
kbn.valueFormats.degree = kbn.formatBuilders.fixedUnit('°');
kbn.valueFormats.radian = kbn.formatBuilders.fixedUnit('rad');
kbn.valueFormats.grad = kbn.formatBuilders.fixedUnit('grad');

// Time
kbn.valueFormats.hertz = kbn.formatBuilders.decimalSIPrefix('Hz');

kbn.valueFormats.ms = function(size, decimals, scaledDecimals) {
  if (size === null) {
    return '';
  }

  if (Math.abs(size) < 1000) {
    return kbn.toFixed(size, decimals) + ' ms';
  } else if (Math.abs(size) < 60000) {
    // Less than 1 min
    return kbn.toFixedScaled(size / 1000, decimals, scaledDecimals, 3, ' s');
  } else if (Math.abs(size) < 3600000) {
    // Less than 1 hour, devide in minutes
    return kbn.toFixedScaled(size / 60000, decimals, scaledDecimals, 5, ' min');
  } else if (Math.abs(size) < 86400000) {
    // Less than one day, devide in hours
    return kbn.toFixedScaled(size / 3600000, decimals, scaledDecimals, 7, ' hour');
  } else if (Math.abs(size) < 31536000000) {
    // Less than one year, devide in days
    return kbn.toFixedScaled(size / 86400000, decimals, scaledDecimals, 8, ' day');
  }

  return kbn.toFixedScaled(size / 31536000000, decimals, scaledDecimals, 10, ' year');
};

kbn.valueFormats.s = function(size, decimals, scaledDecimals) {
  if (size === null) {
    return '';
  }

  // Less than 1 µs, devide in ns
  if (Math.abs(size) < 0.000001) {
    return kbn.toFixedScaled(size * 1e9, decimals, scaledDecimals - decimals, -9, ' ns');
  }
  // Less than 1 ms, devide in µs
  if (Math.abs(size) < 0.001) {
    return kbn.toFixedScaled(size * 1e6, decimals, scaledDecimals - decimals, -6, ' µs');
  }
  // Less than 1 second, devide in ms
  if (Math.abs(size) < 1) {
    return kbn.toFixedScaled(size * 1e3, decimals, scaledDecimals - decimals, -3, ' ms');
  }

  if (Math.abs(size) < 60) {
    return kbn.toFixed(size, decimals) + ' s';
  } else if (Math.abs(size) < 3600) {
    // Less than 1 hour, devide in minutes
    return kbn.toFixedScaled(size / 60, decimals, scaledDecimals, 1, ' min');
  } else if (Math.abs(size) < 86400) {
    // Less than one day, devide in hours
    return kbn.toFixedScaled(size / 3600, decimals, scaledDecimals, 4, ' hour');
  } else if (Math.abs(size) < 604800) {
    // Less than one week, devide in days
    return kbn.toFixedScaled(size / 86400, decimals, scaledDecimals, 5, ' day');
  } else if (Math.abs(size) < 31536000) {
    // Less than one year, devide in week
    return kbn.toFixedScaled(size / 604800, decimals, scaledDecimals, 6, ' week');
  }

  return kbn.toFixedScaled(size / 3.15569e7, decimals, scaledDecimals, 7, ' year');
};

kbn.valueFormats['µs'] = function(size, decimals, scaledDecimals) {
  if (size === null) {
    return '';
  }

  if (Math.abs(size) < 1000) {
    return kbn.toFixed(size, decimals) + ' µs';
  } else if (Math.abs(size) < 1000000) {
    return kbn.toFixedScaled(size / 1000, decimals, scaledDecimals, 3, ' ms');
  } else {
    return kbn.toFixedScaled(size / 1000000, decimals, scaledDecimals, 6, ' s');
  }
};

kbn.valueFormats.ns = function(size, decimals, scaledDecimals) {
  if (size === null) {
    return '';
  }

  if (Math.abs(size) < 1000) {
    return kbn.toFixed(size, decimals) + ' ns';
  } else if (Math.abs(size) < 1000000) {
    return kbn.toFixedScaled(size / 1000, decimals, scaledDecimals, 3, ' µs');
  } else if (Math.abs(size) < 1000000000) {
    return kbn.toFixedScaled(size / 1000000, decimals, scaledDecimals, 6, ' ms');
  } else if (Math.abs(size) < 60000000000) {
    return kbn.toFixedScaled(size / 1000000000, decimals, scaledDecimals, 9, ' s');
  } else {
    return kbn.toFixedScaled(size / 60000000000, decimals, scaledDecimals, 12, ' min');
  }
};

kbn.valueFormats.m = function(size, decimals, scaledDecimals) {
  if (size === null) {
    return '';
  }

  if (Math.abs(size) < 60) {
    return kbn.toFixed(size, decimals) + ' min';
  } else if (Math.abs(size) < 1440) {
    return kbn.toFixedScaled(size / 60, decimals, scaledDecimals, 2, ' hour');
  } else if (Math.abs(size) < 10080) {
    return kbn.toFixedScaled(size / 1440, decimals, scaledDecimals, 3, ' day');
  } else if (Math.abs(size) < 604800) {
    return kbn.toFixedScaled(size / 10080, decimals, scaledDecimals, 4, ' week');
  } else {
    return kbn.toFixedScaled(size / 5.25948e5, decimals, scaledDecimals, 5, ' year');
  }
};

kbn.valueFormats.h = function(size, decimals, scaledDecimals) {
  if (size === null) {
    return '';
  }

  if (Math.abs(size) < 24) {
    return kbn.toFixed(size, decimals) + ' hour';
  } else if (Math.abs(size) < 168) {
    return kbn.toFixedScaled(size / 24, decimals, scaledDecimals, 2, ' day');
  } else if (Math.abs(size) < 8760) {
    return kbn.toFixedScaled(size / 168, decimals, scaledDecimals, 3, ' week');
  } else {
    return kbn.toFixedScaled(size / 8760, decimals, scaledDecimals, 4, ' year');
  }
};

kbn.valueFormats.d = function(size, decimals, scaledDecimals) {
  if (size === null) {
    return '';
  }

  if (Math.abs(size) < 7) {
    return kbn.toFixed(size, decimals) + ' day';
  } else if (Math.abs(size) < 365) {
    return kbn.toFixedScaled(size / 7, decimals, scaledDecimals, 2, ' week');
  } else {
    return kbn.toFixedScaled(size / 365, decimals, scaledDecimals, 3, ' year');
  }
};

kbn.toDuration = function(size, decimals, timeScale) {
  if (size === null) {
    return '';
  }
  if (size === 0) {
    return '0 ' + timeScale + 's';
  }
  if (size < 0) {
    return kbn.toDuration(-size, decimals, timeScale) + ' ago';
  }

  var units = [
    { short: 'y', long: 'year' },
    { short: 'M', long: 'month' },
    { short: 'w', long: 'week' },
    { short: 'd', long: 'day' },
    { short: 'h', long: 'hour' },
    { short: 'm', long: 'minute' },
    { short: 's', long: 'second' },
    { short: 'ms', long: 'millisecond' },
  ];
  // convert $size to milliseconds
  // intervals_in_seconds uses seconds (duh), convert them to milliseconds here to minimize floating point errors
  size *=
    kbn.intervals_in_seconds[
      units.find(function(e) {
        return e.long === timeScale;
      }).short
    ] * 1000;

  var strings = [];
  // after first value >= 1 print only $decimals more
  var decrementDecimals = false;
  for (var i = 0; i < units.length && decimals >= 0; i++) {
    var interval = kbn.intervals_in_seconds[units[i].short] * 1000;
    var value = size / interval;
    if (value >= 1 || decrementDecimals) {
      decrementDecimals = true;
      var floor = Math.floor(value);
      var unit = units[i].long + (floor !== 1 ? 's' : '');
      strings.push(floor + ' ' + unit);
      size = size % interval;
      decimals--;
    }
  }

  return strings.join(', ');
};

kbn.valueFormats.dtdurationms = function(size, decimals) {
  return kbn.toDuration(size, decimals, 'millisecond');
};

kbn.valueFormats.dtdurations = function(size, decimals) {
  return kbn.toDuration(size, decimals, 'second');
};

kbn.valueFormats.dateTimeAsIso = function(epoch) {
  var time = moment(epoch);

  if (moment().isSame(epoch, 'day')) {
    return time.format('HH:mm:ss');
  }
  return time.format('YYYY-MM-DD HH:mm:ss');
};

kbn.valueFormats.dateTimeAsUS = function(epoch) {
  var time = moment(epoch);

  if (moment().isSame(epoch, 'day')) {
    return time.format('h:mm:ss a');
  }
  return time.format('MM/DD/YYYY h:mm:ss a');
};

kbn.valueFormats.dateTimeFromNow = function(epoch) {
  return moment(epoch).fromNow();
};

///// FORMAT MENU /////

kbn.getUnitFormats = function() {
  return [
    {
      text: 'none',
      submenu: [
        { text: 'none', value: 'none' },
        { text: 'short', value: 'short' },
        { text: 'percent (0-100)', value: 'percent' },
        { text: 'percent (0.0-1.0)', value: 'percentunit' },
        { text: 'Humidity (%H)', value: 'humidity' },
        { text: 'ppm', value: 'ppm' },
        { text: 'decibel', value: 'dB' },
        { text: 'hexadecimal (0x)', value: 'hex0x' },
        { text: 'hexadecimal', value: 'hex' },
        { text: 'scientific notation', value: 'sci' },
        { text: 'locale format', value: 'locale' },
      ],
    },
    {
      text: 'currency',
      submenu: [
        { text: 'Dollars ($)', value: 'currencyUSD' },
        { text: 'Pounds (£)', value: 'currencyGBP' },
        { text: 'Euro (€)', value: 'currencyEUR' },
        { text: 'Yen (¥)', value: 'currencyJPY' },
        { text: 'Rubles (₽)', value: 'currencyRUB' },
        { text: 'Hryvnias (₴)', value: 'currencyUAH' },
        { text: 'Real (R$)', value: 'currencyBRL' },
        { text: 'Danish Krone (kr)', value: 'currencyDKK' },
        { text: 'Icelandic Krone (kr)', value: 'currencyISK' },
        { text: 'Norwegian Krone (kr)', value: 'currencyNOK' },
        { text: 'Swedish Krone (kr)', value: 'currencySEK' },
      ],
    },
    {
      text: 'time',
      submenu: [
        { text: 'Hertz (1/s)', value: 'hertz' },
        { text: 'nanoseconds (ns)', value: 'ns' },
        { text: 'microseconds (µs)', value: 'µs' },
        { text: 'milliseconds (ms)', value: 'ms' },
        { text: 'seconds (s)', value: 's' },
        { text: 'minutes (m)', value: 'm' },
        { text: 'hours (h)', value: 'h' },
        { text: 'days (d)', value: 'd' },
        { text: 'duration (ms)', value: 'dtdurationms' },
        { text: 'duration (s)', value: 'dtdurations' },
      ],
    },
    {
      text: 'date & time',
      submenu: [
        { text: 'YYYY-MM-DD HH:mm:ss', value: 'dateTimeAsIso' },
        { text: 'DD/MM/YYYY h:mm:ss a', value: 'dateTimeAsUS' },
        { text: 'From Now', value: 'dateTimeFromNow' },
      ],
    },
    {
      text: 'data (IEC)',
      submenu: [
        { text: 'bits', value: 'bits' },
        { text: 'bytes', value: 'bytes' },
        { text: 'kibibytes', value: 'kbytes' },
        { text: 'mebibytes', value: 'mbytes' },
        { text: 'gibibytes', value: 'gbytes' },
      ],
    },
    {
      text: 'data (Metric)',
      submenu: [
        { text: 'bits', value: 'decbits' },
        { text: 'bytes', value: 'decbytes' },
        { text: 'kilobytes', value: 'deckbytes' },
        { text: 'megabytes', value: 'decmbytes' },
        { text: 'gigabytes', value: 'decgbytes' },
      ],
    },
    {
      text: 'data rate',
      submenu: [
        { text: 'packets/sec', value: 'pps' },
        { text: 'bits/sec', value: 'bps' },
        { text: 'bytes/sec', value: 'Bps' },
        { text: 'kilobits/sec', value: 'Kbits' },
        { text: 'kilobytes/sec', value: 'KBs' },
        { text: 'megabits/sec', value: 'Mbits' },
        { text: 'megabytes/sec', value: 'MBs' },
        { text: 'gigabytes/sec', value: 'GBs' },
        { text: 'gigabits/sec', value: 'Gbits' },
      ],
    },
    {
      text: 'throughput',
      submenu: [
        { text: 'ops/sec (ops)', value: 'ops' },
        { text: 'reads/sec (rps)', value: 'rps' },
        { text: 'writes/sec (wps)', value: 'wps' },
        { text: 'I/O ops/sec (iops)', value: 'iops' },
        { text: 'ops/min (opm)', value: 'opm' },
        { text: 'reads/min (rpm)', value: 'rpm' },
        { text: 'writes/min (wpm)', value: 'wpm' },
      ],
    },
    {
      text: 'length',
      submenu: [
        { text: 'millimetre (mm)', value: 'lengthmm' },
        { text: 'meter (m)', value: 'lengthm' },
        { text: 'feet (ft)', value: 'lengthft' },
        { text: 'kilometer (km)', value: 'lengthkm' },
        { text: 'mile (mi)', value: 'lengthmi' },
      ],
    },
    {
      text: 'area',
      submenu: [
        { text: 'Square Meters (m²)', value: 'areaM2' },
        { text: 'Square Feet (ft²)', value: 'areaF2' },
        { text: 'Square Miles (mi²)', value: 'areaMI2' },
      ],
    },
    {
      text: 'mass',
      submenu: [
        { text: 'milligram (mg)', value: 'massmg' },
        { text: 'gram (g)', value: 'massg' },
        { text: 'kilogram (kg)', value: 'masskg' },
        { text: 'metric ton (t)', value: 'masst' },
      ],
    },
    {
      text: 'velocity',
      submenu: [
        { text: 'm/s', value: 'velocityms' },
        { text: 'km/h', value: 'velocitykmh' },
        { text: 'mph', value: 'velocitymph' },
        { text: 'knot (kn)', value: 'velocityknot' },
      ],
    },
    {
      text: 'volume',
      submenu: [
        { text: 'millilitre', value: 'mlitre' },
        { text: 'litre', value: 'litre' },
        { text: 'cubic metre', value: 'm3' },
        { text: 'cubic decimetre', value: 'dm3' },
        { text: 'gallons', value: 'gallons' },
      ],
    },
    {
      text: 'energy',
      submenu: [
        { text: 'Watt (W)', value: 'watt' },
        { text: 'Kilowatt (kW)', value: 'kwatt' },
        { text: 'Milliwatt (mW)', value: 'mwatt' },
        { text: 'Volt-ampere (VA)', value: 'voltamp' },
        { text: 'Kilovolt-ampere (kVA)', value: 'kvoltamp' },
        { text: 'Volt-ampere reactive (var)', value: 'voltampreact' },
        { text: 'Kilovolt-ampere reactive (kvar)', value: 'kvoltampreact' },
        { text: 'Watt-hour (Wh)', value: 'watth' },
        { text: 'Kilowatt-hour (kWh)', value: 'kwatth' },
        { text: 'Kilowatt-min (kWm)', value: 'kwattm' },
        { text: 'Joule (J)', value: 'joule' },
        { text: 'Electron volt (eV)', value: 'ev' },
        { text: 'Ampere (A)', value: 'amp' },
        { text: 'Kiloampere (kA)', value: 'kamp' },
        { text: 'Milliampere (mA)', value: 'mamp' },
        { text: 'Volt (V)', value: 'volt' },
        { text: 'Kilovolt (kV)', value: 'kvolt' },
        { text: 'Millivolt (mV)', value: 'mvolt' },
        { text: 'Decibel-milliwatt (dBm)', value: 'dBm' },
        { text: 'Ohm (Ω)', value: 'ohm' },
        { text: 'Lumens (Lm)', value: 'lumens' },
      ],
    },
    {
      text: 'temperature',
      submenu: [
        { text: 'Celsius (°C)', value: 'celsius' },
        { text: 'Farenheit (°F)', value: 'farenheit' },
        { text: 'Kelvin (K)', value: 'kelvin' },
      ],
    },
    {
      text: 'pressure',
      submenu: [
        { text: 'Millibars', value: 'pressurembar' },
        { text: 'Bars', value: 'pressurebar' },
        { text: 'Kilobars', value: 'pressurekbar' },
        { text: 'Hectopascals', value: 'pressurehpa' },
        { text: 'Inches of mercury', value: 'pressurehg' },
        { text: 'PSI', value: 'pressurepsi' },
      ],
    },
    {
      text: 'force',
      submenu: [
        { text: 'Newton-meters (Nm)', value: 'forceNm' },
        { text: 'Kilonewton-meters (kNm)', value: 'forcekNm' },
        { text: 'Newtons (N)', value: 'forceN' },
        { text: 'Kilonewtons (kN)', value: 'forcekN' },
      ],
    },
    {
      text: 'flow',
      submenu: [
        { text: 'Gallons/min (gpm)', value: 'flowgpm' },
        { text: 'Cubic meters/sec (cms)', value: 'flowcms' },
        { text: 'Cubic feet/sec (cfs)', value: 'flowcfs' },
        { text: 'Cubic feet/min (cfm)', value: 'flowcfm' },
      ],
    },
    {
      text: 'angle',
      submenu: [
        { text: 'Degrees (°)', value: 'degree' },
        { text: 'Radians', value: 'radian' },
        { text: 'Gradian', value: 'grad' },
      ],
    },
    {
      text: 'acceleration',
      submenu: [
        { text: 'Meters/sec²', value: 'accMS2' },
        { text: 'Feet/sec²', value: 'accFS2' },
        { text: 'G unit', value: 'accG' },
      ],
    },
  ];
};

export default kbn;