Skip to content

Interactive interface for browsing global, full-resolution satellite imagery

55.0 KB
Raw Blame
import {
  get as lodashGet,
  isUndefined as lodashIsUndefined,
  each as lodashEach,
  isNaN as lodashIsNaN,
  startCase as lodashStartCase,
  isArray,
  isEqual as lodashIsEqual,
} from 'lodash';
import moment from 'moment';
import update from 'immutability-helper';
import googleTagManager from 'googleTagManager';
import {
  addLayer,
  getStartingLayers,
  resetLayers,
  getLayers,
  getFutureLayerEndDate,
  getActiveLayersMap,
  getGranuleLayer,
  getMaxDayRange,
} from './selectors';
import { getPaletteAttributeArray } from '../palettes/util';
import { getVectorStyleAttributeArray } from '../vector-styles/util';
import util from '../../util/util';
import { parseDate } from '../date/util';
import { DEFAULT_DAY_COUNT, MIN_DAY_COUNT, MAX_DAY_COUNT, DEFAULT_NUM_GRANULES } from './constants';

/**
 * Given a layer definition, returns formatted string
 * @param {object} def | Layer definition
 * @param {bool} includeSatName | Optionally exclude the satellite name from the output
 * @return {string}
 */
export function getOrbitTrackTitle(def, includeSatName = true) {
  const satelliteName = includeSatName ? ` (${def.title.split(' - ')[0]})` : '';
  const { track } = def;
  const daynightValue = lodashGet(def, 'daynight[0]');
  if (track && daynightValue) {
    return `${lodashStartCase(track)}/${lodashStartCase(daynightValue)}${satelliteName}`;
  } if (track) {
    return `${lodashStartCase(track)}${satelliteName}`;
  } if (daynightValue) {
    return `${lodashStartCase(daynightValue)}${satelliteName}`;
  }
  return undefined;
}

/**
   * For subdaily layers, round the time down to nearest interval.
   * NOTE: Assumes intervals are the same for all ranges!
   * @param {object} def
   * @param {date} date
   * @return {date}
   */
export function nearestInterval(def, date) {
  const dateInterval = lodashGet(def, 'dateRanges[0].dateInterval');
  const interval = Number(dateInterval);
  const remainder = date.getMinutes() % interval;
  const newMinutes = date.getMinutes() - remainder;
  const newDate = new Date(
    date.getFullYear(),
    date.getMonth(),
    date.getDate(),
    date.getHours(),
    newMinutes,
  );
  return newDate;
}

/**
   * Find the closest previous date from an array of dates
   *
   * @param  {object} def       A layer definition
   * @param  {object} date      A date to compare against the array of dates
   * @param  {array} dateArray  An array of dates
   * @return {object}           The date object with normalized timezone.
   */
export function prevDateInDateRange(def, date, dateArray) {
  const closestAvailableDates = [];
  const currentDateValue = date.getTime();
  const currentDateOffsetCheck = util.getTimezoneOffsetDate(date);

  const isFirstDayOfMonth = currentDateOffsetCheck.getDate() === 1;
  const isFirstDayOfYear = currentDateOffsetCheck.getMonth() === 0;

  const isMonthPeriod = def.period === 'monthly';
  const isYearPeriod = def.period === 'yearly';

  if (!dateArray ||
    (isMonthPeriod && isFirstDayOfMonth) ||
    (isYearPeriod && isFirstDayOfMonth && isFirstDayOfYear)) {
    return date;
  }

  // populate closestAvailableDates if rangeDate is before or equal to input date
  lodashEach(dateArray, (rangeDate) => {
    const rangeDateValue = rangeDate.getTime();
    const isRangeDateBefore = rangeDateValue < currentDateValue;
    const isRangeDateEqual = rangeDateValue === currentDateValue;

    if (isRangeDateBefore || isRangeDateEqual) {
      closestAvailableDates.push(rangeDate);
    }
  });

  // use closest date index to find closest date in filtered closestAvailableDates
  const closestDateIndex = util.closestToIndex(closestAvailableDates, currentDateValue);
  const closestDate = closestAvailableDates[closestDateIndex];

  // check for potential next date in function passed dateArray
  const next = dateArray[closestDateIndex + 1] || null;
  const previous = closestDate ? new Date(closestDate.getTime()) : date;
  return { previous, next };
}

export function getOverlayGroups(layers, prevGroups = []) {
  const allGroupsMap = {};
  layers.forEach(({ id, group, layergroup }) => {
    if (group !== 'overlays') {
      return;
    }
    if (allGroupsMap[layergroup]) {
      allGroupsMap[layergroup].push(id);
    } else {
      allGroupsMap[layergroup] = [id];
    }
  });
  return Object.keys(allGroupsMap).map((groupName) => {
    const prevGroup = prevGroups.find((g) => g.groupName === groupName);
    return {
      groupName,
      layers: allGroupsMap[groupName],
      collapsed: prevGroup ? prevGroup.collapsed : false,
    };
  });
}

/**
 * Return revised maxEndDate based on given start/end date limits
 *
 * @method getRevisedMaxEndDate
 * @param  {Object} minDate        A date object
 * @param  {Object} maxEndDate     A date object
 * @param  {Object} startDateLimit
 *  A date object used as start date of timeline range for available data
 * @param  {Object} endDateLimit
 *  A date object used as end date of timeline range for available data
 * @return {Object}                A date object
 */
const getRevisedMaxEndDate = (minDate, maxEndDate, startDateLimit, endDateLimit) => {
  const minDateTime = minDate.getTime();
  const maxEndDateTime = maxEndDate.getTime();
  const startDateLimitTime = startDateLimit.getTime();
  const endDateLimitTime = endDateLimit.getTime();
  const frontDateWithinRange = startDateLimitTime >= minDateTime &&
  startDateLimitTime <= maxEndDateTime;
  const backDateWithinRange = endDateLimitTime <= maxEndDateTime && endDateLimitTime >= minDateTime;
  if (frontDateWithinRange || backDateWithinRange) {
    return endDateLimit;
  }
  return maxEndDate;
};

/**
 * Prevent earlier dates from being added after later dates while building dateArray
 *
 * @method getDateArrayLastDateInOrder
 * @param  {Object} timeUnit  A date object
 * @param  {Array} dateArray  An array of date objects
 * @return {Array} newDateArray  An array of date objects
 */
const getDateArrayLastDateInOrder = (timeUnit, dateArray) => {
  const newDateArray = [...dateArray];
  const arrLastIndex = newDateArray.length - 1;
  const timeUnitTime = timeUnit.getTime();
  if (timeUnit < newDateArray[arrLastIndex]) {
    let endDateFound = false;
    for (let j = arrLastIndex; j >= 0; j -= 1) {
      if (!endDateFound) {
        const dateCheck = newDateArray[j];
        const dateCheckTime = dateCheck.getTime();
        if (timeUnitTime <= dateCheckTime) {
          newDateArray.pop();
        } else {
          newDateArray.push(timeUnit);
          endDateFound = true;
        }
      }
    }
  }
  return newDateArray;
};

/**
 * Get min start date for partial date range coverage
 *
 * @method getMinStartDate
 * @param  {Number} timeDiff time difference based on intervals and unit
 * @param  {String} period
 * @param  {Number} interval
 * @param  {Object} startDateLimit A date object
 * @param  {Number} minYear
 * @param  {Number} minMonth
 * @param  {Number} minDay
 * @return {Object} minStartDate A date object
 */
const getMinStartDate = (timeDiff, period, interval, startDateLimit, minYear, minMonth, minDay) => {
  const startDateLimitTime = startDateLimit.getTime();
  let minStartDate;
  let prevDate;
  for (let i = 0; i <= (timeDiff + 1); i += 1) {
    if (!minStartDate) {
      let timeUnit;
      if (period === 'monthly') {
        timeUnit = new Date(minYear, minMonth + i * interval, minDay);
      } else if (period === 'daily') {
        timeUnit = new Date(minYear, minMonth, minDay + i * interval);
      }
      timeUnit = util.getTimezoneOffsetDate(timeUnit);
      const timeUnitTime = timeUnit.getTime();

      if (timeUnitTime > startDateLimitTime) {
        minStartDate = prevDate;
      } else {
        prevDate = timeUnit;
      }
    }
  }
  return minStartDate;
};

/**
   * Return an object of dates add/subtracted based on period
   *
   * @method addSubDatesBasedOnPeriod
   * @param  {Object}  A calculated time object based on period, current date, and date range
   * @return {Object}
   * @return    {Object}  dayBeforeCurrent    A date object
   * @return    {Object}  currentDateZeroed   A date object
   * @return    {Object}  dayAfterCurrent     A date object
   */
const addSubDatesBasedOnPeriod = ({
  period, minCurrentYear, minCurrentMonth, minCurrentDay, minStartMonth, minStartDay,
}) => {
  let dayBeforeCurrent;
  let currentDateZeroed;
  let dayAfterCurrent;
  if (period === 'yearly') {
    dayBeforeCurrent = new Date(minCurrentYear - 1, minStartMonth, minStartDay);
    currentDateZeroed = new Date(minCurrentYear, minStartMonth, minStartDay);
    dayAfterCurrent = new Date(minCurrentYear + 1, minStartMonth, minStartDay);
  }
  if (period === 'monthly') {
    dayBeforeCurrent = new Date(minCurrentYear, minCurrentMonth - 1, minStartDay);
    currentDateZeroed = new Date(minCurrentYear, minCurrentMonth, minStartDay);
    dayAfterCurrent = new Date(minCurrentYear, minCurrentMonth + 1, minStartDay);
  }
  if (period === 'daily') {
    dayBeforeCurrent = new Date(minCurrentYear, minCurrentMonth, minCurrentDay - 1);
    currentDateZeroed = new Date(minCurrentYear, minCurrentMonth, minCurrentDay);
    dayAfterCurrent = new Date(minCurrentYear, minCurrentMonth, minCurrentDay + 1);
  }

  return {
    dayBeforeCurrent,
    currentDateZeroed,
    dayAfterCurrent,
  };
};

/**
   * Return an array of limited dates of previous, current, and next dates (if available)
   *
   * @method getPrevCurrentNextDates
   * @param  {Object}  A calculated time object based on period, current date, and date range
   * @return {Array}   An array of dates - previous, current, and next dates (if available)
   */
const getPrevCurrentNextDates = ({
  currentDateZeroed, dayBeforeCurrent, dayAfterCurrent, breakMinDateTime, breakMaxDateTime,
}) => {
  const limitedDateRange = [];
  // handle adding previous date to range
  const dayBeforeCurrentTime = dayBeforeCurrent.getTime();
  if (dayBeforeCurrentTime >= breakMinDateTime) {
    const dayBeforeDate = util.getTimezoneOffsetDate(dayBeforeCurrent);
    limitedDateRange.push(dayBeforeDate);
  }

  // handle adding current date to range
  const currentDateDate = util.getTimezoneOffsetDate(currentDateZeroed);
  limitedDateRange.push(currentDateDate);

  // handle adding next date to range
  const dayAfterCurrentTime = dayAfterCurrent.getTime();
  if (dayAfterCurrentTime <= breakMaxDateTime) {
    const dayAfterDate = util.getTimezoneOffsetDate(dayAfterCurrent);
    limitedDateRange.push(dayAfterDate);
  }

  return limitedDateRange;
};

/**
   * Build max date to determine if date is within max date range
   *
   * @method getBreakMaxDate
   * @param  {String} period
   * @param  {Object} rangeEndDate  A date object
   * @return {Object} breakMaxDate  A date object
   */
const getBreakMaxDate = (period, rangeEndDate) => {
  const {
    breakMaxYear,
    breakMaxMonth,
    breakMaxDay,
  } = util.getUTCNumbers(rangeEndDate, 'breakMax');
  let breakMaxDate;
  if (period === 'yearly') {
    breakMaxDate = new Date(breakMaxYear + 1, breakMaxMonth, breakMaxDay);
  }
  if (period === 'monthly') {
    breakMaxDate = new Date(breakMaxYear, breakMaxMonth + 1, breakMaxDay);
  }
  if (period === 'daily') {
    breakMaxDate = new Date(breakMaxYear, breakMaxMonth, breakMaxDay + 1);
  }
  return breakMaxDate;
};

/**
   * Return an array of limited dates of previous, current, and next dates (if available)
   * Used on layers with a single date range and a date interval of 1
   *
   * @method getLimitedDateRange
   * @param  {Object} def           A layer object
   * @param  {Object} currentDate   A date object
   * @return {Array} An array of dates - previous, current, and next dates (if available)
   */
const getLimitedDateRange = (def, currentDate) => {
  const { period, dateRanges } = def;
  const dateRange = dateRanges[0];
  const { startDate, endDate } = dateRange;

  const rangeStartDate = new Date(startDate);
  const rangeEndDate = new Date(endDate);
  const currentDateTime = currentDate.getTime();
  const breakMinDateTime = rangeStartDate.getTime();

  // build test max date to determine if date is within max date range
  const breakMaxDate = getBreakMaxDate(period, rangeEndDate);
  const breakMaxDateTime = breakMaxDate.getTime();

  // get limitedDateRange of previous, current, and next dates (if available)
  let limitedDateRange = [];
  if (currentDateTime >= breakMinDateTime && currentDateTime <= breakMaxDateTime) {
    // get date building components
    const {
      minCurrentYear,
      minCurrentMonth,
      minCurrentDay,
    } = util.getUTCNumbers(currentDate, 'minCurrent');
    const {
      minStartMonth,
      minStartDay,
    } = util.getUTCNumbers(rangeStartDate, 'minStart');

    // calculated options used with addSubDatesBasedOnPeriod
    const addSubtractOptions = {
      period,
      minCurrentYear,
      minCurrentMonth,
      minCurrentDay,
      minStartMonth,
      minStartDay,
    };

    // period specific date addition/subtraction building
    const {
      dayBeforeCurrent,
      currentDateZeroed,
      dayAfterCurrent,
    } = addSubDatesBasedOnPeriod(addSubtractOptions);

    // calculated options used to determine prev/current/next dates
    const limitedDateRangeOptions = {
      currentDateZeroed,
      dayBeforeCurrent,
      dayAfterCurrent,
      breakMinDateTime,
      breakMaxDateTime,
    };

    // add previous/current/next dates in limitedDateRange
    limitedDateRange = getPrevCurrentNextDates(limitedDateRangeOptions);
  }
  return limitedDateRange;
};

/**
   * Return an array of dates from a yearly period layer based on the dateRange the current date
   * falls in.
   *
   * @method getYearDateRange
   * @param  {Number} currentDateTime  Current date milliseconds
   * @param  {Object} minDate          A date object used as min date
   * @param  {Object} maxDate          A date object used as max date
   * @param  {Number} interval         Temporal interval
   * @param  {Array} dateArray         An array of dates
   * @return {Array}                   An array of dates with normalized timezones
   */
const getYearDateRange = (currentDateTime, minDate, maxDate, interval, dateArray) => {
  const newDateArray = [...dateArray];
  const { maxYear, maxMonth, maxDay } = util.getUTCNumbers(maxDate, 'max');
  const { minYear, minMonth, minDay } = util.getUTCNumbers(minDate, 'min');

  const minDateTime = minDate.getTime();
  const maxYearDate = new Date(maxYear + interval, maxMonth, maxDay);
  const maxYearDateTime = maxYearDate.getTime();

  let yearDifference;
  if (currentDateTime >= minDateTime && currentDateTime <= maxYearDateTime) {
    yearDifference = util.yearDiff(minDate, maxYearDate);
  }

  for (let i = 0; i <= (yearDifference + 1); i += 1) {
    let year = new Date(minYear + i * interval, minMonth, minDay);
    if (year.getTime() < maxYearDateTime) {
      year = util.getTimezoneOffsetDate(year);
      newDateArray.push(year);
    }
  }
  return newDateArray;
};

/**
   * Return an array of dates from a monthly period layer based on the dateRange the current date
   * falls in.
   *
   * @method getMonthDateRange
   * @param  {Object}  A calculated time object based on period, current date, and date range
   * @return {Array}   An array of dates with normalized timezones
   */
const getMonthDateRange = ({
  rangeLimitsProvided, currentDateTime, startDateLimit,
  endDateLimit, minDate, maxDate, dateIntervalNum, dateArray,
}) => {
  let newDateArray = [...dateArray];
  const { maxYear, maxMonth, maxDay } = util.getUTCNumbers(maxDate, 'max');
  const { minYear, minMonth, minDay } = util.getUTCNumbers(minDate, 'min');

  // conditional revision of maxEndDate for data availability partial coverage
  const minDateTime = minDate.getTime();
  let maxMonthDate = new Date(maxYear, maxMonth + dateIntervalNum, maxDay);
  maxMonthDate = util.getTimezoneOffsetDate(maxMonthDate);

  let maxEndDate;
  let maxEndDateTime;
  if (rangeLimitsProvided) {
    maxEndDate = getRevisedMaxEndDate(minDate, maxMonthDate, startDateLimit, endDateLimit);
    maxEndDateTime = maxEndDate.getTime();
  } else {
    maxEndDateTime = maxMonthDate.getTime();
  }

  let monthDifference;
  if (currentDateTime >= minDateTime && currentDateTime <= maxEndDateTime) {
    monthDifference = util.monthDiff(minDate, maxMonthDate);
    // handle non-1 month dateIntervalNums to prevent over pushing unused dates to dateArray
    monthDifference = Math.ceil(monthDifference / dateIntervalNum);
  }

  let minStartMonthDate;
  if (rangeLimitsProvided) {
    // get minStartDate for partial range coverage starting date
    minStartMonthDate = monthDifference &&
      getMinStartDate(monthDifference, 'monthly', dateIntervalNum, startDateLimit, minYear, minMonth, minDay);
  }

  for (let i = 0; i <= (monthDifference + 1); i += 1) {
    let month = new Date(minYear, minMonth + i * dateIntervalNum, minDay);
    month = util.getTimezoneOffsetDate(month);
    const monthTime = month.getTime();
    if (monthTime < maxEndDateTime) {
      if (rangeLimitsProvided) {
        if (newDateArray.length > 0) {
          newDateArray = getDateArrayLastDateInOrder(month, newDateArray);
        }
        if (minStartMonthDate) {
          const minStartMonthDateTime = minStartMonthDate.getTime();
          const monthWithinRange = month > minStartMonthDate && month < maxMonthDate;
          if (monthTime === minStartMonthDateTime || monthWithinRange) {
            newDateArray.push(month);
          }
        } else {
          newDateArray.push(month);
        }
      } else {
        newDateArray.push(month);
      }
    }
  }
  return newDateArray;
};

/**
   * Return an array of dates from a daily period layer based on the dateRange the current date
   * falls in.
   *
   * @method getDayDateRange
   * @param  {Object}  A calculated time object based on period, current date, and date range
   * @return {Array}   An array of dates with normalized timezones
   */
const getDayDateRange = ({
  rangeLimitsProvided, currentDateTime, startDateLimit,
  endDateLimit, minDate, maxDate, dateIntervalNum, dateArray,
}) => {
  let newDateArray = [...dateArray];
  const { maxYear, maxMonth, maxDay } = util.getUTCNumbers(maxDate, 'max');
  const { minYear, minMonth, minDay } = util.getUTCNumbers(minDate, 'min');

  // conditional revision of maxEndDate for data availability partial coverage
  const minDateTime = minDate.getTime();
  const maxDayDate = new Date(maxYear, maxMonth, maxDay + dateIntervalNum);
  let maxEndDateTime;
  let maxEndDate;
  if (rangeLimitsProvided) {
    maxEndDate = getRevisedMaxEndDate(minDate, maxDayDate, startDateLimit, endDateLimit);
    maxEndDateTime = maxEndDate.getTime();
  } else {
    maxEndDate = maxDayDate;
    maxEndDateTime = maxDayDate.getTime();
  }

  let dayDifference;
  if (currentDateTime >= minDateTime && currentDateTime <= maxEndDateTime) {
    dayDifference = util.dayDiff(minDate, maxEndDate);
    // handle non-1 day dateIntervalNums to prevent over pushing unused dates to dateArray
    dayDifference = Math.ceil(dayDifference / dateIntervalNum);
  }

  let minStartDayDate;
  if (rangeLimitsProvided) {
    // get minStartDate for partial range coverage starting date
    minStartDayDate = dayDifference &&
    getMinStartDate(dayDifference, 'daily', dateIntervalNum, startDateLimit, minYear, minMonth, minDay);
  }

  for (let i = 0; i <= (dayDifference + 1); i += 1) {
    let day = new Date(minYear, minMonth, minDay + i * dateIntervalNum);
    day = util.getTimezoneOffsetDate(day);
    const dayTime = day.getTime();
    if (dayTime < maxEndDateTime) {
      if (rangeLimitsProvided) {
        if (newDateArray.length > 0) {
          newDateArray = getDateArrayLastDateInOrder(day, newDateArray);
        }
        if (minStartDayDate) {
          const minStartDayDateTime = minStartDayDate.getTime();
          const dayWithinRange = day > minStartDayDate && day < maxDayDate;
          if (dayTime === minStartDayDateTime || dayWithinRange) {
            newDateArray.push(day);
          }
        } else {
          newDateArray.push(day);
        }
      } else {
        newDateArray.push(day);
      }
    }
  }
  return newDateArray;
};

/**
   * Return an array of dates from a subdaily period layer based on the dateRange the current date
   * falls in.
   *
   * @method getSubdailyDateRange
   * @param  {Object}  A calculated time object based on period, current date, and date range
   * @return {Array}   An array of dates with normalized timezones
   */
const getSubdailyDateRange = ({
  rangeLimitsProvided, currentDateTime, startDateLimit,
  endDateLimit, minDate, maxDate, dateIntervalNum, dateArray,
}) => {
  const newDateArray = [...dateArray];
  const {
    maxYear,
    maxMonth,
    maxDay,
    maxHour,
    maxMinute,
  } = util.getUTCNumbers(maxDate, 'max');
  const {
    minYear,
    minMonth,
    minDay,
    minHour,
    minMinute,
  } = util.getUTCNumbers(minDate, 'min');

  let maxMinuteDate = new Date(maxYear, maxMonth, maxDay, maxHour, maxMinute + dateIntervalNum);
  let minMinuteDateMinusInterval;
  let minMinuteDateMinusIntervalOffset;
  let hourBeforeStartDateLimit;
  let hourAfterEndDateLimit;
  if (rangeLimitsProvided) {
    minMinuteDateMinusInterval = new Date(
      minYear,
      minMonth,
      minDay,
      minHour,
      minMinute - dateIntervalNum,
    );
    minMinuteDateMinusIntervalOffset = util.getTimezoneOffsetDate(minMinuteDateMinusInterval);

    const startDateLimitOffset = startDateLimit.getTimezoneOffset() * 60000;
    const endDateLimitOffset = endDateLimit.getTimezoneOffset() * 60000;
    const startDateLimitSetMinutes = new Date(startDateLimit).setMinutes(minMinute);
    const endDateLimitSetMinutes = new Date(endDateLimit).setMinutes(minMinute);

    hourBeforeStartDateLimit = new Date(
      startDateLimitSetMinutes - startDateLimitOffset - (60 * 60000),
    );
    hourAfterEndDateLimit = new Date(endDateLimitSetMinutes - endDateLimitOffset + (60 * 60000));
  } else {
    // limit date range request to +/- one hour from current date
    const currentSetMinutes = new Date(currentDateTime).setMinutes(minMinute);
    hourBeforeStartDateLimit = new Date(currentSetMinutes - (60 * 60000));
    hourAfterEndDateLimit = new Date(currentSetMinutes + (60 * 60000));
  }
  let minMinuteDate;
  if (rangeLimitsProvided) {
    const hourBeforeStartDateLimitCompare = hourBeforeStartDateLimit >
    minMinuteDateMinusIntervalOffset
      ? hourBeforeStartDateLimit
      : minDate;
    minMinuteDate = hourBeforeStartDateLimit < minDate
      ? hourBeforeStartDateLimit
      : hourBeforeStartDateLimitCompare;
  } else {
    minMinuteDate = hourBeforeStartDateLimit < minDate
      ? minDate
      : hourBeforeStartDateLimit;
  }
  maxMinuteDate = hourAfterEndDateLimit > maxMinuteDate
    ? maxMinuteDate
    : hourAfterEndDateLimit;

  const minMinuteDateTime = minMinuteDate.getTime();
  const maxMinuteDateTime = maxMinuteDate.getTime();
  let currentDateTimeCheck;
  if (rangeLimitsProvided) {
    const minCurrentDate = util.getTimezoneOffsetDate(new Date(currentDateTime));
    const minCurrentDateTime = minCurrentDate.getTime();
    currentDateTimeCheck = minCurrentDateTime;
  } else {
    currentDateTimeCheck = currentDateTime;
  }

  let minuteDifference;
  if (currentDateTimeCheck >= minMinuteDateTime && currentDateTimeCheck <= maxMinuteDateTime) {
    minuteDifference = util.minuteDiff(minMinuteDate, maxMinuteDate);
  }

  for (let i = 0; i <= (minuteDifference + 1); i += dateIntervalNum) {
    let subdailyTime = new Date(
      minMinuteDate.getUTCFullYear(),
      minMinuteDate.getUTCMonth(),
      minMinuteDate.getUTCDate(),
      minMinuteDate.getUTCHours(),
      minMinuteDate.getUTCMinutes() + i,
      0,
    );
    if (!rangeLimitsProvided) {
      subdailyTime = util.getTimezoneOffsetDate(subdailyTime);
    }
    const lessThanLastDateInCollection = newDateArray.length > 0
      ? subdailyTime.getTime() > newDateArray[newDateArray.length - 1].getTime()
      : true;
    if (subdailyTime.getTime() >= minMinuteDateTime && lessThanLastDateInCollection) {
      newDateArray.push(subdailyTime);
    }
  }
  return newDateArray;
};

/**
   * Return an array of dateRanges for subdaily layers
   *
   * @method fetchSubdailyDateRanges
   * @param  {String} def            The layer id
   * @return {Array}                 An array of dateRanges
   */
export async function fetchSubdailyDateRanges(id) {
  try {
    const response = await fetch(`config/dateRanges/${id}.json`);
    const result = await response.json();
    return result;
  } catch {
    return [];
  }
}

/**
   * Return the vectorstyles object of a given layer for live-reloading development purposes
   *
   * @method fetchVectorstyle
   * @param  {String} def            The layer id
   * @return {Promise<Object>}       The vectorstyles object
   */
export async function fetchVectorstyle(id) {
  try {
    const response = await fetch(`config/${id}.json`);
    const result = await response.json();
    return result;
  } catch {
    return null;
  }
}

/**
   * Return an array of dates based on the dateRange the current date falls in.
   *
   * @method datesInDateRanges
   * @param  {Object} def            A layer object
   * @param  {Object} date           A date object for currently selected date
   * @param  {Object} startDateLimit
   *  A date object used as start date of timeline range for available data
   * @param  {Object} endDateLimit
   *  A date object used as end date of timeline range for available data
   * @param  {Object} appNow         A date object of appNow (current date or set explicitly)
   * @return {Array}                 An array of dates with normalized timezones
   */
export async function datesInDateRanges(def, date, startDateLimit, endDateLimit, appNow) {
  const {
    futureTime,
    period,
    ongoing,
  } = def;
  let dateArray = [];
  if (!def.dateRanges && def.period === 'subdaily') {
    const result = await fetchSubdailyDateRanges(def.id);
    if (result) {
      def.dateRanges = result;
    }
  }
  const {
    dateRanges,
  } = def;
  if (!dateRanges) { return dateArray; }
  const rangeLimitsProvided = !!(startDateLimit && endDateLimit);
  let currentDate = new Date(date);

  let inputStartDate;
  let inputEndDate;
  let inputStartDateTime;
  let inputEndDateTime;
  let singleDateRangeAndInterval;
  if (rangeLimitsProvided) {
    inputStartDate = new Date(startDateLimit);
    inputEndDate = new Date(endDateLimit);
    inputStartDateTime = inputStartDate.getTime();
    inputEndDateTime = inputEndDate.getTime();
  } else {
    singleDateRangeAndInterval = dateRanges.length === 1 &&
    dateRanges[0].dateInterval === '1';
  }

  // at end of range, used to add "next" date
  let hitMaxLimitOfRange = false;
  // runningMinDate used for overlapping ranges
  let runningMinDate;
  lodashEach(dateRanges, (dateRange, index) => {
    const {
      startDate,
      endDate,
      dateInterval,
    } = dateRange;
    const dateIntervalNum = Number(dateInterval);
    let currentDateTime = currentDate.getTime();
    const lastDateInDateArray = dateArray[dateArray.length - 1];
    const minDate = new Date(startDate);
    let maxDate = new Date(endDate);

    const minDateTime = minDate.getTime();
    const maxDateTime = maxDate.getTime();

    const currentDateLessThanMinDate = currentDateTime < minDateTime;
    const currentDateGreaterThanMaxDate = currentDateTime > maxDateTime;

    // LAYER DATE RANGE SPECIFIC
    if (!rangeLimitsProvided) {
      // break out if currentDate is not within range by skipping current date range
      if (currentDateLessThanMinDate || currentDateGreaterThanMaxDate) {
        // handle adding next date (if available/not at end of range) as final date
        if (!hitMaxLimitOfRange && currentDateLessThanMinDate) {
          if (lastDateInDateArray) {
            // reorder last dates from overlapping end/start dateRanges
            if (lastDateInDateArray > minDate) {
              dateArray.pop();
              dateArray.push(minDate);
              dateArray.push(lastDateInDateArray);
            }
          } else {
            dateArray.push(minDate);
          }
          hitMaxLimitOfRange = true;
          return;
        }
      }
    }

    // LAYER COVERAGE PANEL SPECIFIC
    if (rangeLimitsProvided) {
      // handle single date coverage by adding date to date array
      if (startDate === endDate) {
        if (minDateTime >= inputStartDateTime && maxDate <= inputEndDateTime) {
          dateArray.push(minDate);
        }
        return;
      }

      // revise currentDate to minDate to reduce earlier minDate than needed
      const minDateWithinRangeLimits = minDateTime > inputStartDateTime &&
      minDateTime < inputEndDateTime;
      const runningMinDateAndLastDateEarlier = runningMinDate && lastDateInDateArray > minDate;
      if (currentDateLessThanMinDate &&
        (minDateWithinRangeLimits || runningMinDateAndLastDateEarlier)) {
        currentDate = minDate;
        currentDateTime = currentDate.getTime();
      }
      // set maxDate to current date if layer coverage is ongoing
      if (index === dateRanges.length - 1 && ongoing) {
        if (futureTime) {
          maxDate = new Date(endDate);
        } else {
          maxDate = new Date(appNow);
        }
      }
    }

    // single date range and interval allows only returning prev, current, and next dates
    // (if available) instead of full range traversal
    if (singleDateRangeAndInterval) {
      const limitedDateRange = getLimitedDateRange(def, currentDate);
      dateArray = [...limitedDateRange];
      return;
    }

    // Yearly layers
    if (period === 'yearly') {
      const yearArray = getYearDateRange(
        currentDateTime,
        minDate,
        maxDate,
        dateIntervalNum,
        dateArray,
      );
      dateArray = [...yearArray];
      // Monthly layers
    }

    const dateRangeBuildOptions = {
      rangeLimitsProvided,
      currentDateTime,
      startDateLimit,
      endDateLimit,
      minDate,
      maxDate,
      dateIntervalNum,
      dateArray,
    };
    if (period === 'monthly') {
      const monthArray = getMonthDateRange(dateRangeBuildOptions);
      dateArray = [...monthArray];
      // Daily layers
    } else if (period === 'daily') {
      const dayArray = getDayDateRange(dateRangeBuildOptions);
      dateArray = [...dayArray];
      // Subdaily layers
    } else if (period === 'subdaily') {
      const subdailyArray = getSubdailyDateRange(dateRangeBuildOptions);
      dateArray = [...subdailyArray];
    }
    runningMinDate = minDate;
  });
  return dateArray;
}

export function serializeLayers(layers, state, groupName) {
  const palettes = state.palettes[groupName];

  return layers.map((def, i) => {
    let item = {};

    if (def.id) {
      item = {
        id: def.id,
      };
    }
    if (!item.attributes) {
      item.attributes = [];
    }
    if (!def.visible) {
      item.attributes.push({
        id: 'hidden',
      });
    }
    if (def.opacity < 1) {
      item.attributes.push({
        id: 'opacity',
        value: def.opacity,
      });
    }
    if (def.bandCombo) {
      const bandComboString = JSON.stringify(def.bandCombo).replaceAll('(', '<')
        .replaceAll(')', '>')
        .replaceAll(',', ';');
      item.attributes.push({
        id: 'bandCombo',
        value: bandComboString,
      });
    }
    if (def.dayCount > DEFAULT_DAY_COUNT && getMaxDayRange(def)) {
      item.attributes.push({
        id: 'days',
        value: def.dayCount,
      });
    }
    if (def.type === 'granule') {
      const { count } = getGranuleLayer(state, def.id, groupName) || {};
      if (count && count !== DEFAULT_NUM_GRANULES) {
        item.attributes.push({
          id: 'count',
          value: count,
        });
      }
    }
    if (def.palette &&
      (def.custom || def.min || def.max || def.squash || def.noclip || def.disabled ||
        (palettes[def.id] && palettes[def.id].maps && palettes[def.id].maps.length > 1))) {
      // If layer has palette and palette attributes
      const paletteAttributeArray = getPaletteAttributeArray(
        def.id,
        palettes,
        state,
      );
      item.attributes = paletteAttributeArray.length
        ? item.attributes.concat(paletteAttributeArray)
        : item.attributes;
    } else if (def.vectorStyle && (def.custom || def.min || def.max)) {
      // If layer has vectorStyle and vectorStyle attributes
      const vectorStyleAttributeArray = getVectorStyleAttributeArray(def);

      item.attributes = vectorStyleAttributeArray.length
        ? item.attributes.concat(vectorStyleAttributeArray)
        : item.attributes;
    }

    return util.appendAttributesForURL(item);
  });
}

export function serializeGroupOverlays (groupOverlays, state, activeString) {
  const { parameters, compare } = state;
  const startingLayers = getStartingLayers(state);
  const layersOnState = lodashGet(state, `layers.${activeString}.layers`);
  const layersChanged = !lodashIsEqual(layersOnState, startingLayers);
  const layersParam = activeString === 'active' ? parameters.l : parameters.l1;
  const layerGroupParam = activeString === 'active' ? parameters.lg : parameters.lg1;

  // Old permalink; disable groups
  if (!!layersParam && !layerGroupParam) {
    return false;
  }
  // If any change is made to layers, include group param
  if (layersChanged) {
    return groupOverlays;
  }
  // If app was loaded without layer parameters, only include param if grouping disabled
  if (!layersParam && layerGroupParam === undefined && !compare.active) {
    return !groupOverlays ? groupOverlays : undefined;
  }
  // No need to include param when it's set to the default(true) and no layer params are present
  if (!layersParam && groupOverlays) {
    return undefined;
  }
  return groupOverlays;
}

const getLayerSpec = (attributes) => {
  let hidden = false;
  let opacity = 1.0;
  let max;
  let min;
  let squash;
  let noclip;
  let custom;
  let disabled;
  let count;
  let dayCount;
  let bandCombo;

  lodashEach(attributes, (attr) => {
    if (attr.id === 'hidden') {
      hidden = true;
    }
    if (attr.id === 'opacity') {
      opacity = util.clamp(parseFloat(attr.value), 0, 1);

      if (isNaN(opacity)) opacity = 0; // "opacity=0.0" is opacity in URL, resulting in NaN
    }
    if (attr.id === 'disabled') {
      const values = util.toArray(attr.value.split(';'));
      const disabledArray = [];
      lodashEach(values, (value, index) => {
        if (value === '') {
          disabledArray.push(undefined);
        } else {
          disabledArray.push(value);
        }
      });
      disabled = disabledArray;
    }

    if (attr.id === 'max' && typeof attr.value === 'string') {
      const maxArray = [];
      const values = util.toArray(attr.value.split(';'));
      lodashEach(values, (value, index) => {
        if (value === '') {
          maxArray.push(undefined);
          return;
        }
        const maxValue = parseFloat(value);
        if (lodashIsNaN(maxValue)) {
          console.warn(`Invalid max value: ${value}`);
        } else {
          maxArray.push(maxValue);
        }
      });
      max = maxArray.length ? maxArray : undefined;
    }
    if (attr.id === 'min' && typeof attr.value === 'string') {
      const minArray = [];
      const values = util.toArray(attr.value.split(';'));
      lodashEach(values, (value, index) => {
        if (value === '') {
          minArray.push(undefined);
          return;
        }
        const minValue = parseFloat(value);
        if (lodashIsNaN(minValue)) {
          console.warn(`Invalid min value: ${value}`);
        } else {
          minArray.push(minValue);
        }
      });
      min = minArray.length ? minArray : undefined;
    }
    if (attr.id === 'squash') {
      if (attr.value === true) {
        squash = [true];
      } else if (typeof attr.value === 'string') {
        const squashArray = [];
        const values = util.toArray(attr.value.split(';'));
        lodashEach(values, (value) => {
          squashArray.push(value === 'true');
        });
        squash = squashArray.length ? squashArray : undefined;
      }
    }
    if (attr.id === 'noclip') {
      if (attr.value === true) {
        noclip = [true];
      } else if (typeof attr.value === 'string') {
        const noClipArray = [];
        const values = util.toArray(attr.value.split(';'));
        lodashEach(values, (value) => {
          noClipArray.push(value === 'true');
        });
        noclip = noClipArray.length ? noClipArray : undefined;
      }
    }

    if (attr.id === 'bands') {
      const values = util.toArray(attr.value.split(';'));
      bandCombo = values;
    }

    if (attr.id === 'bandCombo') {
      const formattedString = attr.value.replaceAll(';', ',').replaceAll('<', '(')
        .replaceAll('>', ')');
      bandCombo = JSON.parse(formattedString);
    }

    if (attr.id === 'palette') {
      const values = util.toArray(attr.value.split(';'));
      custom = values;
    }
    if (attr.id === 'style') {
      const values = util.toArray(attr.value.split(';'));
      custom = values;
    }
    // granule specific count (defaults to 20 if no param)
    if (attr.id === 'count') {
      count = Number(attr.value);
    }
    // multi-day aggregation count (defaults to 1 if no param)
    if (attr.id === 'days') {
      const parsed = parseInt(attr.value, 10);
      if (!lodashIsNaN(parsed)) {
        dayCount = util.clamp(parsed, MIN_DAY_COUNT, MAX_DAY_COUNT);
      }
    }
  });

  return {
    hidden,
    opacity,
    count,
    dayCount,
    bandCombo,

    // only include palette attributes if Array.length condition
    // is true: https://stackoverflow.com/a/40560953/4589331
    ...isArray(custom) && { custom },
    ...isArray(min) && { min },
    ...isArray(squash) && { squash },
    ...isArray(noclip) && { noclip },
    ...isArray(max) && { max },
    ...isArray(disabled) && { disabled },
  };
};

const createLayerArrayFromState = function(layers, config) {
  let layerArray = [];
  if (lodashIsUndefined(layers)) {
    return layerArray;
  }
  layers.reverse().forEach((layerDef) => {
    if (!config.layers[layerDef.id]) {
      console.warn(`No such layer: ${layerDef.id}`);
      return;
    }
    layerArray = addLayer(
      layerDef.id,
      layerArray,
      config.layers,
      getLayerSpec(layerDef.attributes),
    );
  });
  return layerArray;
};

// this function takes an array of date ranges in this format:
// [{ layer.period, dateRanges.startDate: Date,
// dateRanges.endDate: Date, dateRanges.dateInterval: Number}]
// the array is first sorted, and then checked for any overlap
export function dateOverlap(period, dateRanges) {
  const sortedRanges = dateRanges.sort((previous, current) => {
    // get the start date from previous and current
    let previousTime = parseDate(previous.startDate);
    previousTime = previousTime.getTime();
    let currentTime = parseDate(current.startDate);
    currentTime = currentTime.getTime();

    // if the previous is earlier than the current
    if (previousTime < currentTime) {
      return -1;
    }

    // if the previous time is the same as the current time
    if (previousTime === currentTime) {
      return 0;
    }

    // if the previous time is later than the current time
    return 1;
  });

  const reducedRanges = sortedRanges.reduce(
    (resultArg, current, idx, arr) => {
      const result = resultArg;
      // get the previous range
      if (idx === 0) {
        return result;
      }
      const previous = arr[idx - 1];

      // check for any overlap
      let previousEnd = parseDate(previous.endDate);
      // Add dateInterval
      if (previous.dateInterval > 1 && period === 'daily') {
        previousEnd = new Date(
          previousEnd.setTime(
            previousEnd.getTime() +
            (previous.dateInterval * 86400000 - 86400000),
          ),
        );
      }
      if (period === 'monthly') {
        previousEnd = new Date(
          previousEnd.setMonth(
            previousEnd.getMonth() + (previous.dateInterval - 1),
          ),
        );
      } else if (period === 'yearly') {
        previousEnd = new Date(
          previousEnd.setFullYear(
            previousEnd.getFullYear() + (previous.dateInterval - 1),
          ),
        );
      }
      previousEnd = previousEnd.getTime();

      let currentStart = parseDate(current.startDate);
      currentStart = currentStart.getTime();

      const overlap = previousEnd >= currentStart;
      // store the result
      if (overlap) {
        // yes, there is overlap
        result.overlap = true;
        // store the specific ranges that overlap
        result.ranges.push({
          previous,
          current,
        });
      }

      return result;
    },
    {
      overlap: false,
      ranges: [],
    },
  );

  // return the final results
  return reducedRanges;
}
// Permalink versions 1.0 and 1.1
export function layersParse11(str, config) {
  const layers = [];
  const ids = str.split(/[~,.]/);
  lodashEach(ids, (idString) => {
    let id = idString;
    if (id === 'baselayers' || id === 'overlays') {
      return;
    }
    let visible = true;
    if (id.startsWith('!')) {
      visible = false;
      id = id.substring(1);
    }
    if (config.redirects && config.redirects.layers) {
      id = config.redirects.layers[id] || id;
    }
    if (!config.layers[id]) {
      console.warn(`No such layer: ${id}`);
      return;
    }
    const lstate = {
      id,
      attributes: [],
    };
    googleTagManager.pushEvent({
      event: 'layer_included_in_url',
      layers: {
        id,
      },
    });
    if (!visible) {
      lstate.attributes.push({
        id: 'hidden',
        value: true,
      });
    }
    layers.push(lstate);
  });
  return createLayerArrayFromState(layers, config);
}

// Permalink version 1.2
export function layersParse12(stateObj, config) {
  try {
    let parts;
    const str = stateObj;
    // Split by layer definitions (commas not in parens)
    const layerDefs = str.match(/[^(,]+(\([^)]*\))?,?/g);
    const lstates = [];
    lodashEach(layerDefs, (layerDef) => {
      // Get the text before any paren or comma
      const layerId = layerDef.match(/[^(,]+/)[0];
      const newLayerIds = [];
      if (config.redirects && config.redirects.layers) {
        if (config.redirects.layers[layerId] && Array.isArray(config.redirects.layers[layerId])) {
          newLayerIds.push(...config.redirects.layers[layerId]);
        } else {
          newLayerIds.push(config.redirects.layers[layerId] || layerId);
        }
      } else {
        newLayerIds.push(layerId);
      }
      newLayerIds.forEach((newLayerId) => {
        const lstate = {
          id: newLayerId,
          attributes: [],
        };
        googleTagManager.pushEvent({
          event: 'layer_included_in_url',
          layers: {
            id: newLayerId,
          },
        });
        // Everything inside parens
        const arrayAttr = layerDef.match(/\(.*\)/);
        if (arrayAttr) {
          // Get single match and remove parens
          const strAttr = arrayAttr[0].replace(/[()]/g, '');
          // Key value pairs
          const kvps = strAttr.split(',');
          lodashEach(kvps, (kvp) => {
            parts = kvp.split('=');
            if (parts.length === 1) {
              lstate.attributes.push({
                id: parts[0],
                value: true,
              });
            } else {
              lstate.attributes.push({
                id: parts[0],
                value: parts[1],
              });
            }
          });
        }
        lstates.push(lstate);
      });
    });
    return createLayerArrayFromState(lstates, config);
  } catch (e) {
    console.warn(`Error Parsing layers: ${e}`);

    console.log('reverting to default layers');
    return resetLayers(config);
  }
}

export function mapLocationToLayerState(
  parameters,
  stateFromLocation,
  state,
  config,
) {
  let newStateFromLocation = stateFromLocation;
  const { layers } = stateFromLocation;
  const { active, activeB } = layers;

  // No B group layers param but compare active param is present
  if (!parameters.l1 && parameters.ca !== undefined) {
    newStateFromLocation = update(newStateFromLocation, {
      layers: {
        activeB: {
          groupOverlays: { $set: false },
          layers: { $set: active.layers },
          overlayGroups: { $set: [] },
        },
      },
    });
  }

  // legacy layers permalink
  if (parameters.products && !parameters.l) {
    const parsedLayers = layersParse11(parameters.products, config);
    newStateFromLocation = update(newStateFromLocation, {
      layers: {
        active: {
          overlayGroups: {
            $set: getOverlayGroups(parsedLayers),
          },
          layers: { $set: parsedLayers },
        },
      },
    });
  }

  // If loading via permalink without group param, GROUPS DISABLED
  if (parameters.l && parameters.lg === undefined) {
    newStateFromLocation = update(newStateFromLocation, {
      layers: {
        active: {
          groupOverlays: { $set: false },
          overlayGroups: { $set: [] },
          layers: { $set: active.layers },
        },
      },
    });
  }

  if (parameters.l1 && parameters.lg1 === undefined) {
    newStateFromLocation = update(newStateFromLocation, {
      layers: {
        activeB: {
          groupOverlays: { $set: false },
          overlayGroups: { $set: [] },
          layers: { $set: activeB.layers },
        },
      },
    });
  }

  if (active && active.layers.length) {
    const {
      groupOverlays,
      overlayGroups,
      layers: stateLayers,
    } = newStateFromLocation.layers.active;
    const populateGroups = groupOverlays && !overlayGroups;
    newStateFromLocation = update(newStateFromLocation, {
      layers: {
        active: {
          overlayGroups: {
            $set: populateGroups ? getOverlayGroups(stateLayers) : [],
          },
        },
      },
    });
  }

  if (activeB && activeB.layers.length) {
    const {
      groupOverlays,
      overlayGroups,
      layers: stateLayers,
    } = newStateFromLocation.layers.activeB;
    const populateGroups = groupOverlays && !overlayGroups;
    newStateFromLocation = update(newStateFromLocation, {
      layers: {
        activeB: {
          overlayGroups: {
            $set: populateGroups ? getOverlayGroups(stateLayers) : [],
          },
        },
      },
    });
  }

  newStateFromLocation.layers = update(state.layers, {
    active: { $merge: newStateFromLocation.layers.active },
    activeB: { $merge: newStateFromLocation.layers.activeB },
  });

  return newStateFromLocation;
}

/**
 * Determine if active layers have a visible
 * vector layer
 *
 * @param {Array} activeLayers
 *
 * @return {Boolean}
 */
export const hasVectorLayers = (activeLayers) => {
  const len = activeLayers.length;
  // Used for loop
  // so break could be used
  let hasVectorTypeLayer = false;
  for (let i = 0; i < len; i += 1) {
    const def = activeLayers[i];
    if (def.type === 'vector' && def.visible) {
      hasVectorTypeLayer = true;
      break;
    }
  }
  return hasVectorTypeLayer;
};

/**
 * Determine if active layers have a vector layer that is
 * clickable at this zoom
 *
 * @param {Object} layersState
 * @param {Number} mapRes
 *
 * @return {Boolean}
 */
export const isVectorLayerClickable = (layer, mapRes, projId, isMobile) => {
  if (layer.id && layer.id.includes('AERONET')) return true;
  if (!mapRes) return false;
  let resolutionBreakPoint = lodashGet(layer, `breakPointLayer.projections.${projId}.resolutionBreakPoint`);
  if (resolutionBreakPoint) {
    if (isMobile) resolutionBreakPoint /= 2;
    return mapRes < resolutionBreakPoint;
  }
  return true;
};

/**
 * Determine if active layers have a vector layer
 * That is currently not clickable
 *
 * @param {Object} layersState
 * @param {Number} mapRes
 *
 * @return {Boolean}
 */
export const hasNonClickableVectorLayer = (activeLayers, mapRes, projId, isMobile) => {
  if (!mapRes) return false;
  let isNonClickableVectorLayer = false;
  const len = activeLayers.length;
  for (let i = 0; i < len; i += 1) {
    const def = activeLayers[i];
    if (def.type === 'vector' && def.visible) {
      isNonClickableVectorLayer = !isVectorLayerClickable(def, mapRes, projId, isMobile);
      if (isNonClickableVectorLayer) break;
    }
  }
  return isNonClickableVectorLayer;
};

/**
 * For geostationary layers that have 'availability' properties defined
 * adjust the start date and date ranges as necessary
 *
 * Applies to layer.startDate and layer.dateRanges[0].startDate
 * @param {*} layers
 */
export function adjustStartDates(layers) {
  const adjustDate = (days) => `${moment.utc()
    .subtract(days * 24, 'hours')
    .format('YYYY-MM-DDThh:mm:ss')}Z`;

  const applyDateAdjustment = (layerObj) => {
    const layer = layerObj;
    const { availability, dateRanges, endDate } = layer;
    if (!availability) {
      return;
    }
    const { rollingWindow, historicalRanges } = availability;

    if (Array.isArray(dateRanges) && dateRanges.length) {
      const [firstDateRange] = dateRanges;
      const adjustedDate = adjustDate(rollingWindow);

      // To prevent a startDate greater than endDate for layers with a rollingWindow and specific
      // start and end dates
      if (endDate && new Date(adjustedDate) > new Date(endDate)) {
        return;
      }

      firstDateRange.startDate = adjustedDate;
      layer.startDate = adjustedDate;
    } else {
      console.warn(`GetCapabilities is missing the time value for ${layer.id}`);
    }

    if (Array.isArray(historicalRanges) && historicalRanges.length) {
      layer.startDate = historicalRanges[0].startDate;
      historicalRanges.reverse().forEach((range) => {
        if (!layer.dateRanges) {
          layer.dateRanges = [];
        }
        layer.dateRanges.unshift(range);
      });
    } else {
      layer.startDate = adjustDate(rollingWindow);
    }
  };

  return Object.values(layers).forEach(applyDateAdjustment);
}

/**
 * For subdaily layers, if the layer date is within 30 minutes of current
 * time, set expiration to ten minutes from now
 */
export const getCacheOptions = (period, date, state) => {
  const tenMin = 10 * 60000;
  const thirtyMin = 30 * 60000;
  const now = new Date().getTime();
  const recentTime = Math.abs(now - date.getTime()) < thirtyMin;
  if (period !== 'subdaily' || !recentTime) {
    return {};
  }
  return {
    expirationAbsolute: new Date(now + tenMin),
  };
};

/**
 * For active, multi-interval layers with on going coverage,
 * date ranges are modified and added for layer config
 *
 * @method adjustActiveDateRanges
 * @param  {Array} layers array
 * @param  {Object} appNow - pageLoadTime date
 * @returns {Array} array of layers
 */
export function adjustActiveDateRanges(layers, appNow) {
  const appNowYear = appNow.getUTCFullYear();
  const applyDateRangeAdjustment = (layerObj) => {
    const layer = layerObj;
    const { dateRanges } = layer;
    const { ongoing, period } = layer;
    const failConditions = !ongoing ||
      !dateRanges ||
      period === 'subdaily';
    if (failConditions) {
      return;
    }

    const dateRangesModified = [...dateRanges];
    for (let i = 0; i < dateRangesModified.length; i += 1) {
      const dateRange = dateRangesModified[i];
      const {
        endDate,
        startDate,
        dateInterval,
      } = dateRange;

      const dateIntervalNum = Number(dateInterval);
      if (i === dateRangesModified.length - 1 && dateIntervalNum > 1) {
        // create/add dynamic dates to iterated dateRange
        const start = new Date(startDate);
        const startDateYear = start.getUTCFullYear();

        // splice in modifiedDateRange to set endDate to appNow
        if (startDateYear === appNowYear) {
          const modifiedDateRange = {
            startDate,
            endDate: util.toISOStringSeconds(appNow),
            dateInterval,
          };
          dateRangesModified.splice(i, 1, modifiedDateRange);
        }

        // check to see if dateRangesModified needs to be spliced or appended
        if (startDateYear < appNowYear) {
          const dynamicStartYear = start.getUTCFullYear() + 1;
          const dynamicStartDate = new Date(start.setUTCFullYear(dynamicStartYear));

          const end = new Date(endDate);
          const endDateYear = end.getUTCFullYear();
          const dynamicEndYear = end.getUTCFullYear() + 1;
          let dynamicEndDate = new Date(end.setUTCFullYear(dynamicEndYear));

          // don't extend endDate past appNow
          dynamicEndDate = dynamicEndDate < appNow
            ? dynamicEndDate
            : appNow;

          // extend endDate till end of year if before appNow year
          // ex: app build date 11/2020 and it's 04/2021 now, this will extend to end of 12/2020
          if (endDateYear < appNowYear) {
            let endOfYearDate = new Date('2021-12-31T00:00:00.000Z');
            endOfYearDate = new Date(endOfYearDate.setUTCFullYear(endDateYear));
            const modifiedDateRange = {
              startDate,
              endDate: util.toISOStringSeconds(endOfYearDate),
              dateInterval,
            };
            dateRangesModified.splice(i, 1, modifiedDateRange);
          }

          // add date range to modified layer dateRanges
          if (dynamicStartDate < appNow) {
            const dynamicDateRange = {
              startDate: util.toISOStringSeconds(dynamicStartDate),
              endDate: util.toISOStringSeconds(dynamicEndDate),
              dateInterval,
            };
            dateRangesModified.push(dynamicDateRange);
          }
        }
      }
    }
    layer.dateRanges = dateRangesModified;
  };

  return Object.values(layers).forEach(applyDateRangeAdjustment);
}

/**
 * Change end dates for future layers to add 'futureTime' (ex: '3D')
 * Adjust def.endDate and, if applicable, the last endDate in dateRange object
 *
 * @method adjustEndDates
 * @param  {Array} layers array
 * @returns {Array} array of layers
 */
export function adjustEndDates(layers) {
  const applyDateAdjustment = (layerObj) => {
    const layer = layerObj;
    const { futureTime, dateRanges } = layer;
    if (!futureTime) {
      return;
    }

    const futureEndDate = getFutureLayerEndDate(layer);
    layer.endDate = util.toISOStringSeconds(futureEndDate);

    if (dateRanges.length) {
      const lastDateRange = dateRanges[dateRanges.length - 1];
      lastDateRange.endDate = util.toISOStringSeconds(futureEndDate);
    }
  };

  return Object.values(layers).forEach(applyDateAdjustment);
}

/**
 * Add mockFutureTime value to target layer object futureTime key
 *
 * @method mockFutureTimeLayerOptions
 * @param  {Array} layers array
 * @param  {String} mockFutureLayerParameters 'targetLayerId, mockFutureTime'
 * @returns {Void}
 */
export function mockFutureTimeLayerOptions(layersObj, mockFutureLayerParameters) {
  const layers = layersObj;
  const urlParameters = mockFutureLayerParameters.split(',');
  const [targetLayerId, mockFutureTime] = urlParameters;

  if (targetLayerId && mockFutureTime && layers[targetLayerId]) {
    layers[targetLayerId].futureTime = mockFutureTime;
  }
}

export function getLayersFromGroups (state, groups) {
  const baselayers = getLayers(state, { group: 'baselayers' });
  const activeLayersMap = getActiveLayersMap(state);
  return groups
    ? groups.flatMap((g) => g.layers)
      .map((id) => activeLayersMap[id])
      .concat(baselayers)
    : [];
}

export function adjustMeasurementsValidUnitConversion(config) {
  const { measurements, layers } = config;
  const applyDisableUnitConversionCheck = (layerObj) => {
    const layer = layerObj;
    const { layergroup } = layer;
    if (!layergroup || !measurements[layergroup]) {
      return;
    }

    const { disableUnitConversion } = measurements[layergroup];
    if (disableUnitConversion) {
      layer.disableUnitConversion = true;
    }
  };

  return Object.values(layers).forEach(applyDisableUnitConversionCheck);
}