import _objectSpread from "@babel/runtime/helpers/objectSpread2";
import _extends from "@babel/runtime/helpers/extends";
import _defineProperty from "@babel/runtime/helpers/defineProperty";
import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
import _createClass from "@babel/runtime/helpers/createClass";
import _inherits from "@babel/runtime/helpers/inherits";
import _createSuper from "@babel/runtime/helpers/createSuper";
import _slicedToArray from "@babel/runtime/helpers/slicedToArray";

/* tslint:disable jsx-no-multiline-js */
import React, { Component } from 'react';
import moment, { isMoment } from 'moment';
import classNames from 'classnames';
import Button from '../button';
import Icon from '../icon';
import warning from '../_util/warning';
import RangeCalendar from '../rc-components/calendar/RangeCalendar';
import RcDatePicker from '../rc-components/calendar/Picker';
import { Size } from '../_util/enum';
import ConfigContext from '../config-provider/ConfigContext';

function getShowDateFromValue(value) {
  var _value = _slicedToArray(value, 2),
      start = _value[0],
      end = _value[1]; // value could be an empty array, then we should not reset showDate


  if (!start && !end) {
    return;
  }

  var newEnd = end && end.isSame(start, 'month') ? end.clone().add(1, 'month') : end;
  return [start, newEnd];
}

function formatValue(value, format) {
  return value && value.format(format) || '';
}

function pickerValueAdapter(value) {
  if (!value) {
    return;
  }

  if (Array.isArray(value)) {
    return value;
  }

  return [value, value.clone().add(1, 'month')];
}

function isEmptyArray(arr) {
  if (Array.isArray(arr)) {
    return arr.length === 0 || arr.every(function (i) {
      return !i;
    });
  }

  return false;
}

function fixLocale(value, localeCode) {
  if (!localeCode) {
    return;
  }

  if (!value || value.length === 0) {
    return;
  }

  if (value[0]) {
    value[0].locale(localeCode);
  }

  if (value[1]) {
    value[1].locale(localeCode);
  }
}

var RangePicker = /*#__PURE__*/function (_Component) {
  _inherits(RangePicker, _Component);

  var _super = _createSuper(RangePicker);

  function RangePicker(props, context) {
    var _this;

    _classCallCheck(this, RangePicker);

    _this = _super.call(this, props, context);

    _this.clearSelection = function (e) {
      e.preventDefault();
      e.stopPropagation();

      _this.setState({
        value: []
      });

      _this.handleChange([]);
    };

    _this.clearHoverValue = function () {
      return _this.setState({
        hoverValue: []
      });
    };

    _this.handleChange = function (value) {
      var props = _this.props;

      if (!('value' in props)) {
        _this.setState(function (_ref) {
          var showDate = _ref.showDate;
          return {
            value: value,
            showDate: getShowDateFromValue(value) || showDate
          };
        });
      }

      props.onChange(value, [formatValue(value[0], props.format), formatValue(value[1], props.format)]);
    };

    _this.handleOpenChange = function (open) {
      if (!('open' in _this.props)) {
        _this.setState({
          open: open
        });
      }

      if (open === false) {
        _this.clearHoverValue();
      }

      var onOpenChange = _this.props.onOpenChange;

      if (onOpenChange) {
        onOpenChange(open);
      }
    };

    _this.handleShowDateChange = function (showDate) {
      return _this.setState({
        showDate: showDate
      });
    };

    _this.handleHoverChange = function (hoverValue) {
      return _this.setState({
        hoverValue: hoverValue
      });
    };

    _this.handleRangeMouseLeave = function () {
      var open = _this.state.open;

      if (open) {
        _this.clearHoverValue();
      }
    };

    _this.handleCalendarInputSelect = function (value) {
      if (!value[0]) {
        return;
      }

      _this.setState(function (_ref2) {
        var showDate = _ref2.showDate;
        return {
          value: value,
          showDate: getShowDateFromValue(value) || showDate
        };
      });
    };

    _this.handleRangeClick = function (value) {
      if (typeof value === 'function') {
        value = value();
      }

      _this.setValue(value, true);

      var onOk = _this.props.onOk;

      if (onOk) {
        onOk(value);
      }
    };

    _this.savePicker = function (node) {
      _this.picker = node;
    };

    _this.renderFooter = function () {
      var _this$props = _this.props,
          ranges = _this$props.ranges,
          renderExtraFooter = _this$props.renderExtraFooter;

      var prefixCls = _this.getPrefixCls();

      if (!ranges && !renderExtraFooter) {
        return null;
      }

      var customFooter = renderExtraFooter ? /*#__PURE__*/React.createElement("div", {
        className: "".concat(prefixCls, "-footer-extra"),
        key: "extra"
      }, renderExtraFooter.apply(void 0, arguments)) : null;
      var operations = Object.keys(ranges || {}).map(function (range) {
        var value = ranges[range];
        return /*#__PURE__*/React.createElement("a", {
          key: range,
          onClick: function onClick() {
            return _this.handleRangeClick(value);
          },
          onMouseEnter: function onMouseEnter() {
            return _this.setState({
              hoverValue: value
            });
          },
          onMouseLeave: _this.handleRangeMouseLeave
        }, range);
      });
      var rangeNode = /*#__PURE__*/React.createElement("div", {
        className: "".concat(prefixCls, "-footer-extra ").concat(prefixCls, "-range-quick-selector"),
        key: "range"
      }, operations);
      return [rangeNode, customFooter];
    };

    var value = props.value || props.defaultValue || [];

    if (value[0] && !isMoment(value[0]) || value[1] && !isMoment(value[1])) {
      throw new Error('The value/defaultValue of RangePicker must be a moment object array');
    }

    var pickerValue = !value || isEmptyArray(value) ? props.defaultPickerValue : value;
    _this.state = {
      value: value,
      showDate: pickerValueAdapter(pickerValue || moment()),
      open: props.open,
      hoverValue: []
    };
    return _this;
  }

  _createClass(RangePicker, [{
    key: "componentWillReceiveProps",
    value: function componentWillReceiveProps(nextProps) {
      if ('value' in nextProps) {
        var showDate = this.state.showDate;
        var value = nextProps.value || [];
        this.setState({
          value: value,
          showDate: getShowDateFromValue(value) || showDate
        });
      }

      if ('open' in nextProps) {
        this.setState({
          open: nextProps.open
        });
      }
    }
  }, {
    key: "setValue",
    value: function setValue(value, hidePanel) {
      this.handleChange(value);
      var props = this.props;

      if ((hidePanel || !props.showTime) && !('open' in props)) {
        this.setState({
          open: false
        });
      }
    }
  }, {
    key: "focus",
    value: function focus() {
      this.picker.focus();
    }
  }, {
    key: "blur",
    value: function blur() {
      this.picker.blur();
    }
  }, {
    key: "getPrefixCls",
    value: function getPrefixCls() {
      var prefixCls = this.props.prefixCls;
      var getPrefixCls = this.context.getPrefixCls;
      return getPrefixCls('calendar', prefixCls);
    }
  }, {
    key: "render",
    value: function render() {
      var _classNames,
          _this2 = this;

      var state = this.state,
          props = this.props;
      var value = state.value,
          showDate = state.showDate,
          hoverValue = state.hoverValue,
          open = state.open;
      var popupStyle = props.popupStyle,
          style = props.style,
          disabledDate = props.disabledDate,
          disabledTime = props.disabledTime,
          showTime = props.showTime,
          showToday = props.showToday,
          ranges = props.ranges,
          onOk = props.onOk,
          locale = props.locale,
          localeCode = props.localeCode,
          format = props.format,
          dateRender = props.dateRender,
          onCalendarChange = props.onCalendarChange;
      fixLocale(value, localeCode);
      fixLocale(showDate, localeCode);
      warning(!('onOK' in props), 'It should be `RangePicker[onOk]`, instead of `onOK`!');
      var prefixCls = this.getPrefixCls();
      var calendarClassName = classNames((_classNames = {}, _defineProperty(_classNames, "".concat(prefixCls, "-time"), showTime), _defineProperty(_classNames, "".concat(prefixCls, "-range-with-ranges"), ranges), _classNames)); // 需要选择时间时，点击 ok 时才触发 onChange

      var pickerChangeHandler = {
        onChange: this.handleChange
      };
      var calendarProps = {
        onOk: this.handleChange
      };

      if (props.timePicker) {
        pickerChangeHandler.onChange = function (changedValue) {
          return _this2.handleChange(changedValue);
        };
      } else {
        calendarProps = {};
      }

      if ('mode' in props) {
        calendarProps.mode = props.mode;
      }

      var startPlaceholder = 'placeholder' in props ? props.placeholder[0] : locale.lang.rangePlaceholder[0];
      var endPlaceholder = 'placeholder' in props ? props.placeholder[1] : locale.lang.rangePlaceholder[1];
      var calendar = /*#__PURE__*/React.createElement(RangeCalendar, _extends({}, calendarProps, {
        onChange: onCalendarChange,
        format: format,
        prefixCls: prefixCls,
        className: calendarClassName,
        renderFooter: this.renderFooter,
        timePicker: props.timePicker,
        disabledDate: disabledDate,
        disabledTime: disabledTime,
        dateInputPlaceholder: [startPlaceholder, endPlaceholder],
        locale: locale.lang,
        onOk: onOk,
        dateRender: dateRender,
        value: showDate,
        onValueChange: this.handleShowDateChange,
        hoverValue: hoverValue,
        onHoverChange: this.handleHoverChange,
        onPanelChange: props.onPanelChange,
        showToday: showToday,
        onInputSelect: this.handleCalendarInputSelect
      })); // default width for showTime

      var pickerStyle = {};

      if (props.showTime) {
        pickerStyle.width = style && style.width || 350;
      }

      var clearIcon = !props.disabled && props.allowClear && value && (value[0] || value[1]) ? /*#__PURE__*/React.createElement(Button, {
        shape: "circle",
        size: Size.small,
        onClick: this.clearSelection,
        className: "".concat(prefixCls, "-picker-clear"),
        icon: "close"
      }) : null;

      var input = function input(_ref3) {
        var inputValue = _ref3.value;
        var start = inputValue[0];
        var end = inputValue[1];
        return /*#__PURE__*/React.createElement("span", {
          className: "".concat(prefixCls, "-range-picker ").concat(props.pickerWrapperInputClass)
        }, /*#__PURE__*/React.createElement("span", {
          className: props.pickerInputClass
        }, /*#__PURE__*/React.createElement("input", {
          disabled: props.disabled,
          readOnly: true,
          value: start && start.format(props.format) || '',
          placeholder: startPlaceholder,
          className: "".concat(prefixCls, "-range-picker-input"),
          tabIndex: -1
        }), /*#__PURE__*/React.createElement("span", {
          className: "".concat(prefixCls, "-range-picker-separator")
        }, " ~ "), /*#__PURE__*/React.createElement("input", {
          disabled: props.disabled,
          readOnly: true,
          value: end && end.format(props.format) || '',
          placeholder: endPlaceholder,
          className: "".concat(prefixCls, "-range-picker-input"),
          tabIndex: -1
        }), clearIcon, /*#__PURE__*/React.createElement("span", {
          className: "".concat(props.inputPrefixCls, "-suffix")
        }, /*#__PURE__*/React.createElement(Icon, {
          type: "date_range",
          className: "".concat(prefixCls, "-picker-icon")
        }))));
      };

      return /*#__PURE__*/React.createElement("span", {
        ref: this.savePicker,
        id: props.id,
        className: classNames(props.className, props.pickerClass),
        style: _objectSpread(_objectSpread({}, style), pickerStyle),
        tabIndex: props.disabled ? -1 : 0,
        onFocus: props.onFocus,
        onBlur: props.onBlur
      }, /*#__PURE__*/React.createElement(RcDatePicker, _extends({}, props, pickerChangeHandler, {
        calendar: calendar,
        value: value,
        open: open,
        onOpenChange: this.handleOpenChange,
        prefixCls: "".concat(prefixCls, "-picker-container"),
        style: popupStyle
      }), input));
    }
  }], [{
    key: "contextType",
    get: function get() {
      return ConfigContext;
    }
  }]);

  return RangePicker;
}(Component);

export { RangePicker as default };
RangePicker.displayName = 'RangePicker';
RangePicker.defaultProps = {
  allowClear: true,
  showToday: false
};
//# sourceMappingURL=RangePicker.js.map
