'use strict';

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

var _momentTimezone = require('moment-timezone');

var _momentTimezone2 = _interopRequireDefault(_momentTimezone);

var _dates = require('./dates');

var _dates2 = _interopRequireDefault(_dates);

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

var getDstOffset = function getDstOffset(start, end) {
  return start.getTimezoneOffset() - end.getTimezoneOffset();
};

var getKey = function getKey(min, max, step, slots, timezoneShift) {
  return '' + +_dates2.default.startOf(min, 'minutes') + +_dates2.default.startOf(max, 'minutes') + step + '-' + slots + '-' + timezoneShift;
};

var getDateByCoords = function getDateByCoords(isGenericCalendarMode, min, max, startOfWeek, coords, parentCoords, daySize, roundingMinutes, roundingMode) {
  var days = Math.floor(coords.x * _dates.TOTAL.DAY_IN_WEEK / (parentCoords.right - parentCoords.left - parentCoords.shiftX));
  var currentDayMinutes = isGenericCalendarMode ? _dates2.default.diff(min, max, 'minutes') : _dates.TOTAL.MIN_IN_DAY;
  var date = (0, _momentTimezone2.default)(startOfWeek);

  var currentOffset = Math.abs((0, _momentTimezone2.default)().startOf('day').utcOffset());
  var startOffset = Math.abs(date.utcOffset());
  var dayLightOffset = 0;
  if (currentOffset !== startOffset) {
    dayLightOffset = currentOffset > startOffset ? -(currentOffset - startOffset) : startOffset - currentOffset;
    if (min.getHours() === 0) dayLightOffset = 0;
  }
  date = date.toDate();
  var offsetDate = new Date(date);
  var minutes = Math.floor((coords.y + daySize.scroll) * currentDayMinutes / daySize.height);
  var offset = _dates2.default.diff(offsetDate.setHours(min.getHours()), date, 'minutes') + minutes + dayLightOffset;

  date.setDate(date.getDate() + Math.min(days, _dates.TOTAL.DAY_IN_WEEK - 1));
  if (isGenericCalendarMode) {
    date.setMinutes(_dates2.default.dateRound(offset, roundingMinutes, roundingMode || 'round'));
  } else {
    date.setMinutes(_dates2.default.dateRound(minutes, roundingMinutes, roundingMode || 'round'));
  }
  return date;
};

function getSlotMetrics(_ref) {
  var start = _ref.min,
      end = _ref.max,
      step = _ref.step,
      timeslots = _ref.timeslots,
      isGenericCalendarMode = _ref.isGenericCalendarMode,
      _ref$timezoneShift = _ref.timezoneShift,
      timezoneShift = _ref$timezoneShift === undefined ? 0 : _ref$timezoneShift;

  var key = getKey(start, end, step, timeslots, timezoneShift);
  var todayReferanceDate = new Date().setHours(0, 0, 0, 0);
  var startGeneric = new Date(todayReferanceDate).setHours(start.getHours());
  var endGeneric = new Date(todayReferanceDate).setHours(end.getHours(), end.getMinutes(), 0, 0);

  var totalMin = isGenericCalendarMode ? _dates2.default.diff(startGeneric, endGeneric, 'minutes') : 1 + _dates2.default.diff(start, end, 'minutes') + getDstOffset(start, end);
  var minutesFromMidnight = _dates2.default.diff(_dates2.default.startOf(start, 'day'), start, 'minutes');

  var numGroups = Math.ceil(totalMin / (step * timeslots));
  var numSlots = numGroups * timeslots;
  var groups = new Array(numGroups);
  var slots = new Array(numSlots);
  // Each slot date is created from "zero", instead of adding `step` to
  // the previous one, in order to avoid DST oddities
  for (var grp = 0; grp < numGroups; grp++) {
    groups[grp] = new Array(timeslots);

    for (var slot = 0; slot < timeslots; slot++) {
      var slotIdx = grp * timeslots + slot;
      var minFromStart = slotIdx * step;
      // A date with total minutes calculated from the start of the day

      var _value = new Date(start.getFullYear(), start.getMonth(), start.getDate(), 0, minutesFromMidnight + minFromStart, 0, 0);

      slots[slotIdx] = groups[grp][slot] = {
        value: _value,
        notAllowed: (0, _momentTimezone2.default)(_value).isBefore() && !isGenericCalendarMode,
        isInThePast: (0, _momentTimezone2.default)(_value).isBefore((0, _momentTimezone2.default)().add(timezoneShift, 'm')) && !isGenericCalendarMode
      };
    }
  }

  // Necessary to be able to select up until the last timeslot in a day
  var lastSlotMinFromStart = slots.length * step;
  var value = new Date(start.getFullYear(), start.getMonth(), start.getDate(), 0, minutesFromMidnight + lastSlotMinFromStart, 0, 0);
  slots.push({
    value: value,
    notAllowed: (0, _momentTimezone2.default)(value).isBefore() && !isGenericCalendarMode,
    isInThePast: (0, _momentTimezone2.default)(value).isBefore((0, _momentTimezone2.default)().add(timezoneShift, 'm')) && !isGenericCalendarMode
  });

  // Array of slots for another snapping rules during moving and resize

  var stepM = 15;
  var numGroupsM = Math.ceil(totalMin / (stepM * timeslots));
  var numSlotsM = numGroupsM * timeslots;
  var groupsM = new Array(numGroupsM);
  var slotsM = new Array(numSlotsM);
  // Each slot date is created from "zero", instead of adding `step` to
  // the previous one, in order to avoid DST oddities
  for (var _grp = 0; _grp < numGroupsM; _grp++) {
    groupsM[_grp] = new Array(timeslots);

    for (var _slot = 0; _slot < timeslots; _slot++) {
      var _slotIdx = _grp * timeslots + _slot;
      var _minFromStart = _slotIdx * step * 0.5;
      // A date with total minutes calculated from the start of the day

      var _value2 = new Date(start.getFullYear(), start.getMonth(), start.getDate(), 0, minutesFromMidnight + _minFromStart, 0, 0);

      slotsM[_slotIdx] = groupsM[_grp][_slot] = {
        value: _value2,
        notAllowed: (0, _momentTimezone2.default)(_value2).isBefore() && !isGenericCalendarMode,
        isInThePast: (0, _momentTimezone2.default)(_value2).isBefore((0, _momentTimezone2.default)().add(timezoneShift, 'm')) && !isGenericCalendarMode
      };
    }
  }

  // Necessary to be able to select up until the last timeslot in a day
  var lastSlotMinFromStartM = slotsM.length * stepM;
  var valueM = new Date(start.getFullYear(), start.getMonth(), start.getDate(), 0, minutesFromMidnight + lastSlotMinFromStartM, 0, 0);
  slotsM.push({
    value: valueM,
    notAllowed: (0, _momentTimezone2.default)(valueM).isBefore() && !isGenericCalendarMode,
    isInThePast: (0, _momentTimezone2.default)(value).isBefore((0, _momentTimezone2.default)().add(timezoneShift, 'm')) && !isGenericCalendarMode
  });

  function positionFromDate(date) {
    var diff = _dates2.default.diff(start, date, 'minutes') + getDstOffset(start, date);
    return Math.min(diff, totalMin);
  }

  return {
    groups: groups,
    update: function update(args) {
      // if (getKey(args) !== key) return getSlotMetrics(args);
      var min = args.min,
          max = args.max,
          step = args.step,
          timeslots = args.timeslots,
          timezoneShift = args.timezoneShift;

      if (getKey(min, max, step, timeslots, timezoneShift) !== key) return getSlotMetrics(args);
      return this;
    },
    dateIsInGroup: function dateIsInGroup(date, groupIndex) {
      var nextGroup = groups[groupIndex + 1];
      return _dates2.default.inRange(date, groups[groupIndex][0], nextGroup ? nextGroup[0] : end, 'minutes');
    },
    positionFromDate: function positionFromDate(startDate, containerHeight, containerScroll) {
      var start = (0, _momentTimezone2.default)(startDate);
      var startOfDay = start.clone().diff(start.startOf('day'));
      var diffInMinutes = _momentTimezone2.default.duration(startOfDay).asMinutes();
      return Math.max(Math.ceil(containerHeight * diffInMinutes / _dates.TOTAL.MIN_IN_DAY - containerScroll), 1);
    },
    positionFromDateGenericCalendar: function positionFromDateGenericCalendar(hoverStartDate, containerHeight, containerScroll, min, max) {
      var todayhoverStartReferanceDate = new Date().setHours(hoverStartDate.getHours(), hoverStartDate.getMinutes(), 0, 0);
      var dayStart = new Date(todayhoverStartReferanceDate);
      dayStart.setMinutes(0);
      var diffInMinutes = _dates2.default.diff(dayStart.setHours(min.getHours()), todayhoverStartReferanceDate, 'minutes');
      return Math.max(Math.ceil(containerHeight * diffInMinutes / _dates2.default.diff(min, max, 'minutes') - containerScroll), 1);
    },
    isAllowedForClick: function isAllowedForClick(_ref2) {
      var events = _ref2.events,
          start = _ref2.start,
          end = _ref2.end,
          accessors = _ref2.accessors;

      var endDate = (0, _momentTimezone2.default)(end);
      var isPastTime = (0, _momentTimezone2.default)(start).isBefore();
      var isOneDay = (0, _momentTimezone2.default)(start).isSame(endDate, 'day') || endDate.isSame((0, _momentTimezone2.default)(_dates2.default.startOf(endDate, 'day')));

      var isIntersect = events && events.some(function (event) {
        return _momentTimezone2.default.range(start, end).intersect(_momentTimezone2.default.range(accessors.start(event)), accessors.end(event));
      });
      return !isIntersect && !isPastTime && isOneDay;
    },
    nextSlot: function nextSlot(slot) {
      var next = slots[Math.min(slots.indexOf(slot) + 1, slots.length - 1)];
      // in the case of the last slot we won't a long enough range so manually get it
      if (next === slot) next = _dates2.default.add(slot, step, 'minutes');
      return next;
    },
    getBlockSlots: function getBlockSlots(isGenericCalendarMode, min, max, startOfWeek, start, end, parentCoords, daySize, roundingMinutes, roundingMode) {
      return {
        start: start,
        end: end,
        startDate: getDateByCoords(isGenericCalendarMode, min, max, startOfWeek, start, parentCoords, daySize, roundingMinutes, roundingMode),
        endDate: getDateByCoords(isGenericCalendarMode, min, max, startOfWeek, end, parentCoords, daySize, roundingMinutes, roundingMode)
      };
    },
    getHoverBlockSlots: function getHoverBlockSlots(isGenericCalendarMode, min, max, slotDuration, startOfWeek, start, end, parentCoords, daySize, roundingMinutes, roundingMode) {
      var duration = isGenericCalendarMode ? slotDuration / 60000 : _dates2.default.dateRound((end.y - start.y) * _dates.TOTAL.MIN_IN_DAY / daySize.height, roundingMinutes, 'round');
      var startDate = getDateByCoords(isGenericCalendarMode, min, max, startOfWeek, start, parentCoords, daySize, roundingMinutes, roundingMode);
      var endDate = (0, _momentTimezone2.default)(startDate).clone().add(duration, 'minutes').toDate();
      return {
        start: start,
        end: end,
        startDate: startDate,
        endDate: endDate
      };
    },
    getSlotHeightFromMS: function getSlotHeightFromMS(duration, customDayTimeInMinutes) {
      var $dayColumn = document.querySelector('#rbc-time-content');
      var dayColumnHeight = $dayColumn.scrollHeight;
      if (customDayTimeInMinutes) {
        return duration * dayColumnHeight / (_dates.MILLI.minutes * customDayTimeInMinutes);
      }
      return duration * dayColumnHeight / (_dates.MILLI.minutes * _dates.TOTAL.MIN_IN_DAY);
    },
    getSelectionBlock: function getSelectionBlock(selectionCoords, parentCoords) {
      var $timeColumnWidth = document.querySelector('#rbc-time-column').offsetWidth;

      var leftPosition = Math.max(selectionCoords.left - parentCoords.left, $timeColumnWidth);
      var topPosition = Math.max(selectionCoords.top - parentCoords.top, 0);

      var selectionHeight = Math.min(Math.abs(selectionCoords.bottom - topPosition - parentCoords.top), Math.abs(parentCoords.bottom - selectionCoords.top));
      var selectionWidth = Math.min(Math.abs(selectionCoords.right - leftPosition - parentCoords.left), Math.abs(parentCoords.right - selectionCoords.left));

      return {
        top: topPosition,
        left: leftPosition,
        width: selectionWidth,
        height: selectionHeight
      };
    },
    getHoverBlock: function getHoverBlock(hoverCoords, parentCoords) {
      var el = document.scrollingElement || document.documentElement;
      var documentScroll = el.scrollTop;
      var y = hoverCoords.y,
          containerCoords = hoverCoords.containerCoords,
          shiftX = hoverCoords.shiftX;


      var leftPosition = Math.max(parentCoords.left - containerCoords.left, shiftX);

      var topPosition = Math.max(y - containerCoords.top + documentScroll, 0);

      return {
        top: topPosition,
        left: leftPosition
      };
    },
    closestSlotToPosition: function closestSlotToPosition(percent) {
      var slot = Math.min(slotsM.length - 1, Math.max(0, Math.floor(percent * numSlotsM)));
      return slotsM[slot].value;
    },
    closestSlotFromPoint: function closestSlotFromPoint(point, boundaryRect) {
      var range = Math.abs(boundaryRect.top - boundaryRect.bottom);
      return this.closestSlotToPosition((point.y - boundaryRect.top) / range);
    },
    closestSlotFromDate: function closestSlotFromDate(date) {
      var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;

      if (_dates2.default.lt(date, start, 'minutes')) return slotsM[0];

      var diffMins = _dates2.default.diff(start, date, 'minutes');
      var closestSlot = slotsM[(diffMins - diffMins % stepM) / stepM + offset];
      return closestSlot ? closestSlot.value : slotsM[0];
    },
    startsBeforeDay: function startsBeforeDay(date) {
      return _dates2.default.lt(date, start, 'day');
    },
    startsAfterDay: function startsAfterDay(date) {
      return _dates2.default.gt(date, end, 'day');
    },
    startsBefore: function startsBefore(date) {
      return _dates2.default.lt(_dates2.default.merge(start, date), start, 'minutes');
    },
    startsAfter: function startsAfter(date) {
      return _dates2.default.gt(_dates2.default.merge(end, date), end, 'minutes');
    },
    getRange: function getRange(rangeStart, rangeEnd) {
      var minDurationOnResize = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;

      rangeStart = _dates2.default.min(end, _dates2.default.max(start, rangeStart));
      rangeEnd = _dates2.default.min(end, _dates2.default.max(start, rangeEnd));

      var rangeStartMin = positionFromDate(rangeStart);
      var rangeEndMin = positionFromDate(rangeEnd);
      var top = rangeStartMin / (step * numSlots) * 100;

      /**
       * rangeStartMin and rangeEndMin increase/decrease in intervals of 15 (minutes).
       * The difference between them, express the duration of the target time slot.
       * If the time slot is being resized, the height shouldn't be smaller than the
       * one representing the minimum duration allowed on resize. And the end time should
       * also be updated accordingly to keep the minimum duration, because it is used in
       * calculations for positioning the slot in the time grid.
       */
      if (minDurationOnResize > 0) {
        var duration = rangeEndMin - rangeStartMin;
        if (duration < minDurationOnResize) {
          var exceededTime = minDurationOnResize - duration;
          rangeEndMin += exceededTime;
          rangeEnd = (0, _momentTimezone2.default)(rangeEnd).add(exceededTime, 'minutes').toDate();
        }
      }

      return {
        top: top,
        height: Math.floor((rangeEndMin / (step * numSlots) * 100 - top - 0.05) * 10) / 10,
        start: positionFromDate(rangeStart),
        startDate: rangeStart,
        end: positionFromDate(rangeEnd),
        endDate: rangeEnd
      };
    }
  };
}