'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.UnconnectedAxisInterval = undefined;

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _react = require('react');

var _react2 = _interopRequireDefault(_react);

var _Field = require('./Field');

var _Field2 = _interopRequireDefault(_Field);

var _Dropdown = require('../widgets/Dropdown');

var _Dropdown2 = _interopRequireDefault(_Dropdown);

var _NumericInput = require('../widgets/NumericInput');

var _NumericInput2 = _interopRequireDefault(_NumericInput);

var _propTypes = require('prop-types');

var _propTypes2 = _interopRequireDefault(_propTypes);

var _lib = require('../../lib');

var _lib2 = require('plotly.js/src/lib');

var _dates = require('plotly.js/src/lib/dates');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var MILLISECONDS_IN_SECOND = 1000;
var MILLISECONDS_IN_MINUTE = MILLISECONDS_IN_SECOND * 60; // eslint-disable-line
var MILLISECONDS_IN_DAY = MILLISECONDS_IN_MINUTE * 60 * 24; // eslint-disable-line
var DAYS_IN_MONTH = 30;
var MONTHS_IN_YEAR = 12; //eslint-disable-line

function twoDecimalsRound(value) {
  return Math.round(value * 100) / 100;
}

function getSmallestUnit(milliseconds) {
  var units = {
    seconds: MILLISECONDS_IN_SECOND,
    minutes: MILLISECONDS_IN_MINUTE,
    days: MILLISECONDS_IN_DAY
  };

  var smallestUnit = 'milliseconds';

  ['seconds', 'minutes', 'days'].forEach(function (unit) {
    if (milliseconds % units[unit] === 0 && (smallestUnit === 'milliseconds' || smallestUnit !== 'milliseconds' && milliseconds / units[smallestUnit] > milliseconds / units[unit])) {
      smallestUnit = unit;
    }
  });

  return smallestUnit;
}

var UnconnectedAxisInterval = exports.UnconnectedAxisInterval = function (_Component) {
  _inherits(UnconnectedAxisInterval, _Component);

  function UnconnectedAxisInterval(props) {
    _classCallCheck(this, UnconnectedAxisInterval);

    var _this = _possibleConstructorReturn(this, (UnconnectedAxisInterval.__proto__ || Object.getPrototypeOf(UnconnectedAxisInterval)).call(this, props));

    var initialUnit = props.fullValue && typeof props.fullValue === 'string' && props.fullValue[0] === 'M' ? parseInt(props.fullValue.substring(1), 10) % MONTHS_IN_YEAR === 0 ? 'years' : 'months' : getSmallestUnit(props.fullValue);

    _this.state = {
      units: initialUnit
    };
    return _this;
  }

  _createClass(UnconnectedAxisInterval, [{
    key: 'update',
    value: function update(value) {
      var adjustedValue = value < 0 ? 0 : value;
      var isValueInteger = adjustedValue % 1 === 0;

      if (this.state.units === 'years') {
        if (isValueInteger) {
          adjustedValue = 'M' + adjustedValue * MONTHS_IN_YEAR;
        } else {
          adjustedValue = adjustedValue * MONTHS_IN_YEAR * DAYS_IN_MONTH * MILLISECONDS_IN_DAY;
        }
      }

      if (this.state.units === 'months') {
        if (isValueInteger) {
          adjustedValue = 'M' + adjustedValue;
        } else {
          adjustedValue = adjustedValue * DAYS_IN_MONTH * MILLISECONDS_IN_DAY;
        }
      }

      if (this.state.units === 'days') {
        adjustedValue = adjustedValue * MILLISECONDS_IN_DAY;
      }

      if (this.state.units === 'minutes') {
        adjustedValue = adjustedValue * MILLISECONDS_IN_MINUTE;
      }

      if (this.state.units === 'seconds') {
        adjustedValue = adjustedValue * MILLISECONDS_IN_SECOND;
      }

      this.props.updatePlot(adjustedValue);
    }
  }, {
    key: 'onUnitChange',
    value: function onUnitChange(value) {
      var isFullValueMonthFormat = typeof this.props.fullValue === 'string' && this.props.fullValue[0] === 'M';

      var milliseconds = isFullValueMonthFormat ? parseInt(this.props.fullValue.substring(1), 10) * DAYS_IN_MONTH * MILLISECONDS_IN_DAY : this.props.fullValue;

      this.setState({ units: value });

      if (['years', 'months'].includes(value)) {
        var nbMonths = milliseconds / MILLISECONDS_IN_DAY / DAYS_IN_MONTH;
        if (nbMonths % 1 === 0) {
          this.props.updatePlot('M' + nbMonths);
        } else {
          this.props.updatePlot(milliseconds);
        }
      } else {
        this.props.updatePlot(milliseconds);
      }
    }
  }, {
    key: 'getDisplayValue',
    value: function getDisplayValue(value) {
      var numericValue = typeof value === 'string' && value[0] === 'M' ? parseInt(value.substring(1), 10) : value;

      if (this.state.units === 'years') {
        if (typeof value === 'string') {
          return twoDecimalsRound(numericValue / MONTHS_IN_YEAR);
        }
        return twoDecimalsRound(numericValue / MILLISECONDS_IN_DAY / DAYS_IN_MONTH / MONTHS_IN_YEAR);
      }
      if (this.state.units === 'months') {
        if (typeof value === 'string') {
          return twoDecimalsRound(numericValue);
        }
        return twoDecimalsRound(numericValue / MILLISECONDS_IN_DAY / DAYS_IN_MONTH);
      }
      if (this.state.units === 'days') {
        return twoDecimalsRound(numericValue / MILLISECONDS_IN_DAY);
      }
      if (this.state.units === 'minutes') {
        return twoDecimalsRound(numericValue / MILLISECONDS_IN_MINUTE);
      }
      if (this.state.units === 'seconds') {
        return twoDecimalsRound(numericValue / MILLISECONDS_IN_SECOND);
      }
      if (this.state.units === 'milliseconds') {
        return numericValue;
      }
      return null;
    }
  }, {
    key: 'render',
    value: function render() {
      var _this2 = this;

      var _ = this.context.localize;
      var attrHead = this.props.attr.split('.')[0];
      var binStartValue = this.props.fullContainer[attrHead].start;
      var BinStartIsDate = typeof binStartValue === 'string' && ((0, _lib2.isDateTime)(binStartValue) || (0, _dates.isJSDate)(binStartValue));
      var tick0 = this.props.fullContainer.tick0 && (this.props.fullContainer.tick0 || this.props.fullContainer.colorbar.tick0);
      var tick0IsDate = tick0 && ((0, _lib2.isDateTime)(tick0) || (0, _dates.isJSDate)(tick0));

      return BinStartIsDate || tick0IsDate ? _react2.default.createElement(
        _Field2.default,
        this.props,
        _react2.default.createElement(_Dropdown2.default, {
          options: [{ value: 'years', label: _('Years') }, { value: 'months', label: _('Months') }, { value: 'days', label: _('Days') }, { value: 'minutes', label: _('Minutes') }, { value: 'seconds', label: _('Seconds') }, { value: 'milliseconds', label: _('Milliseconds') }],
          clearable: false,
          onChange: function onChange(value) {
            return _this2.onUnitChange(value);
          },
          value: this.state.units
        }),
        _react2.default.createElement(
          'div',
          { style: { width: '100%', display: 'block' } },
          ' '
        ),
        _react2.default.createElement(_NumericInput2.default, {
          value: this.getDisplayValue(this.props.fullValue),
          onUpdate: function onUpdate(value) {
            return _this2.update(value);
          },
          editableClassName: 'AxisInterval-milliseconds'
        })
      ) : _react2.default.createElement(
        _Field2.default,
        this.props,
        _react2.default.createElement(_NumericInput2.default, {
          value: this.props.fullValue,
          onUpdate: function onUpdate(value) {
            return _this2.props.updatePlot(value);
          }
        })
      );
    }
  }]);

  return UnconnectedAxisInterval;
}(_react.Component);

UnconnectedAxisInterval.contextTypes = {
  localize: _propTypes2.default.func
};

UnconnectedAxisInterval.propTypes = _extends({
  fullValue: _propTypes2.default.oneOfType([_propTypes2.default.number, _propTypes2.default.string]),
  updatePlot: _propTypes2.default.func,
  attr: _propTypes2.default.string,
  fullContainer: _propTypes2.default.object
}, _Field2.default.propTypes);

exports.default = (0, _lib.connectToContainer)(UnconnectedAxisInterval);
//# sourceMappingURL=AxisInterval.js.map