/**
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

var App = require('app');

App.BaseUnitConvertMixin = Em.Mixin.create({
  /**
   * Which type of units should be used e.g. size, time.
   * Conversion dimensions will be used according this type.
   * For more info regarding dimension table @see convertMapTable property.
   *
   * This property can be used in mixed object to specify which dimension table map will
   * be used for conversion. If type is not specified we try to find correct table by input unit type.
   *
   * Note: You should specify dimension for `percentage` conversion with specified property unit type.
   *
   * @property currentDimensionType
   * @type {String}
   */
  currentDimensionType: null,

  units: ['b', 'kb', 'mb', 'gb', 'tb', 'pb'],

  /**
   * Labels related to units. Specify desired display names here that not much actual unit name.
   */
  unitLabelMap: {
    percent: '%',
    int: '',
    float: ''
  },

  convertMapTable: Em.Object.create({
    size: {
      b: 1024,
      kb: 1024,
      mb: 1024,
      gb: 1024,
      tb: 1024,
      pb: 1024
    },
    time: {
      milliseconds: 1,
      seconds: 1000,
      minutes: 60,
      hours: 60,
      days: 24
    },
    /**
     * Percent dimension type should be specified directly through `currentDimensionType` property.
     * For example:
     * 'percent.percent_int' if widget `unit-name` is "percent" and config property `type` is "int"
     * 'percent.percent_float' if widget `unit-name` is "percent" and config property `type` is "float"
     */
    percent: {
      percent_int: {
        int: 1,
        percent: 1
      },
      percent_float: {
        float: 1,
        percent: 0.01
      }
    }
  }),

  /**
   * Convert value between different unit types. Conversion works for following directions:
   *  single unit -> single unit e.g. from "s" -> "s".
   *  single unit -> multi unit e.g. from "ms" -> "days,hours"
   *  multi unit -> single unit e.g. from "days,hours" -> "ms"
   * For single -> single unit conversion returned value will be as is or an array of objects if
   * isObjectOutput flag passed.
   * If any passed unit is multi dimensions like "days,hours" array of objects will return always.
   * For example:
   *  <code>
   *     convertValue(1024, 'kb', 'kb') // returns 1024
   *     convertValue(1024, 'kb', 'kb', true) // returns [{ type: 'kb', value: 1024 }]
   *     convertValue(60000, 'ms', 'hours,minutes') // returns [{type: 'hours', value: 0 }, {type: 'minutes', value: 1}]
   *  </code>
   * For more examples see unit tests.
   *
   * @method convertValue
   * @param {String|Number|Object[]} value - value to convert
   * @param {String|String[]} fromUnit - specified value unit type(s) e.g. "mb"
   *    Form multi dimensional format pass units separated with "," or list of unit types
   *    e.g. "gb,mb", ['gb', 'mb']
   * @param {Boolean} [isObjectOutput=false] - 'returned' value should be object this option useful for widgets where its
   *    value should be an Object
   * @param {String|String[]} toUnit - desired unit(s) to convert specified value. Same format as for `fromUnit`
   * @returns {Number|Object[]} returns single value or array of objects according to multi unit format
   */
  convertValue: function(value, fromUnit, toUnit, isObjectOutput) {
    var self = this;
    var valueIsArray = Em.isArray(value);
    if (!valueIsArray) {
      value = +value;
    }
    // if desired unit not passed or fromUnit and toUnit are the same
    // just return the value
    if ((fromUnit == toUnit || !toUnit) && !isObjectOutput) {
      return value;
    }
    if (isNaN(value) && !valueIsArray) {
      return null;
    }
    // convert passed toUnit string to array of units by ','
    // for example "mb,kb" to ['mb','kb']
    if (!Em.isArray(toUnit)) {
      toUnit = toUnit.split(',');
    }
    // process multi unit format
    if (toUnit.length > 1 || isObjectOutput) {
      // returned array has following structure
      //  .value - value according to unit
      //  .type - unit name
      return toUnit.map(function(unit) {
        var convertedValue = Math.floor(self._convertToSingleValue(value, fromUnit, unit));
        value -= self._convertToSingleValue(convertedValue, unit, fromUnit);
        return {
          value: convertedValue,
          type: unit
        };
      });
    }
    // for single unit format just return single value
    else {
      if (!valueIsArray) {
        return this._convertToSingleValue(value, fromUnit, toUnit[0]);
      }
      else {
        return value.map(function(item) {
          return self._convertToSingleValue(item.value, item.type, toUnit[0]);
        }).reduce(Em.sum, 0);
      }
    }
  },

  /**
   * Get dimension table map. `currentDimensionType` will be used if specified or
   * detected by property unit type.
   *
   * @method _converterGetUnitTable
   * @private
   * @param {String|String[]} unit - unit type
   * @return {Object}
   */
  _converterGetUnitTable: function(unit) {
    var unitType;
    if (this.get('currentDimensionType')) {
      unitType = this.get('currentDimensionType');
    }
    else {
      unitType = Em.keys(this.get('convertMapTable')).filter(function(item) {
        return Em.keys(this.get('convertMapTable.' + item)).contains(Em.isArray(unit) ? unit[0].toLowerCase() : unit.toLowerCase());
      }, this)[0];
    }
    return this.get('convertMapTable.' + unitType);
  },

  /**
   * @method _convertToSingleValue
   * @private
   * @param {Number} value - value to convert
   * @param {String} fromUnit - unit type for current value
   * @param {String} toUnit - desired unit type
   * @return {Number}
   */
  _convertToSingleValue: function(value, fromUnit, toUnit) {
    var convertTable = this._converterGetUnitTable(fromUnit);
    var units = Em.keys(convertTable);
    var fromUnitIndex = units.indexOf(fromUnit.toLowerCase());
    var toUnitIndex = units.indexOf(toUnit.toLowerCase());
    var isInt = function(val) {
      return parseInt(val) === val;
    };
    Em.assert("Invalid value unit type " + fromUnit, fromUnitIndex > -1);
    Em.assert("Invalid desired unit type " + toUnit, toUnitIndex > -1);
    if (fromUnitIndex == toUnitIndex) {
      return value;
    }
    var range = [fromUnitIndex + 1, toUnitIndex + 1];
    var processedUnits = Array.prototype.slice.apply(units, range[0] < range[1] ? range : range.slice().reverse());
    var factor = processedUnits.map(function(unit) {
      return Em.get(convertTable, unit);
    }, this).reduce(function(p,c) { return p*c; });
    if (range[0] < range[1]) {
      value /= factor;
    }
    else {
      value *= factor;
    }
    return isInt(value) ? value : parseFloat(value.toFixed(3));
  }

});