Skip to content

Interactive interface for browsing global, full-resolution satellite imagery

55.7 KB
Raw Blame
import update from 'immutability-helper';
import util from '../../util/util';
import fixtures from '../../fixtures';
import {
  addLayer,
  getLayers,
  resetLayers,
  dateRange,
  pushToBottom,
  moveBefore,
  getFutureLayerEndDate,
  hasSubDaily,
  getSubDaily,
  hasMeasurementSetting,
  hasMeasurementSource,
  getTitles,
  getFilteredOverlayGroups,
  getActiveLayers,
  getActiveOverlayGroups,
  getActiveVisibleLayersAtDate,
  getCollections,
  findEventLayers,
  replaceSubGroup,
  makeGetDescription,
  getSmallestIntervalValue,
  activateLayersForEventCategory,
  getZotsForActiveLayers,
  getAnyOverZoom,
  getMaxZoomLevelLayerCollection,
  getMaxDayRange,
  getLayerDayCount,
} from './selectors';

const config = fixtures.config();
function getState(layers) {
  return {
    config,
    proj: { id: 'geographic', selected: config.projections.geographic },
    layers: {
      active: {
        layers,
      },
    },
    compare: { isCompareA: true, activeString: 'active' },
    date: { selected: new Date(Date.UTC(2014, 0, 1)) },
  };
}
function getDescriptionState(layerOverrides = {}, measurementOverrides = {}) {
  return {
    config: {
      layers: {
        'terra-aod': {
          id: 'terra-aod',
          layergroup: 'AOD',
          ...layerOverrides,
        },
        'orbital-track': {
          id: 'orbital-track',
          layergroup: 'Orbital Track',
        },
      },
      measurements: {
        'Aerosol Optical Depth': {
          sources: {
            MODIS_Terra: {
              description: 'aerosol-optical-depth/v3',
              settings: ['terra-aod'],
              ...measurementOverrides,
            },
          },
        },
        'Featured Aerosol': {
          sources: {
            MODIS_Terra: {
              description: 'featured/aerosol',
              settings: ['terra-aod'],
            },
          },
        },
      },
    },
  };
}

function getIntervalState(layers) {
  return {
    layers: {
      active: { layers },
    },
    compare: { activeString: 'active' },
  };
}

function getEventState(activeLayers, categoryLayers) {
  return {
    config: {
      ...config,
      naturalEvents: {
        layers: {
          geographic: {
            fires: categoryLayers,
          },
        },
      },
    },
    proj: { id: 'geographic', selected: config.projections.geographic },
    layers: {
      active: { layers: activeLayers },
      layerConfig: config.layers,
    },
    compare: { isCompareA: true, activeString: 'active' },
    date: { selected: new Date(Date.UTC(2014, 0, 1)) },
  };
}

function makeView(zoom) {
  return { getView: () => ({ getZoom: () => zoom }) };
}

const emptyNotifications = { object: { layerNotices: [] } };

function getZotState({ activeLayers, zoom, notifications = emptyNotifications, sources = {} }) {
  return {
    config: {
      ...config,
      sources,
    },
    proj: { id: 'geographic', selected: config.projections.geographic },
    layers: {
      active: { layers: activeLayers },
    },
    compare: { isCompareA: true, activeString: 'active' },
    date: { selected: new Date(Date.UTC(2014, 0, 1)) },
    map: { ui: { selected: makeView(zoom) } },
    notifications,
  };
}
// A layer with no matrixSet so getZoomLevel always returns null,
// and minZoom at or below the current zoom so underZoom is not triggered.
function makeSimpleLayer(id, projection = 'geographic', minZoom = 0) {
  return {
    id,
    group: 'overlays',
    visible: true,
    opacity: 1,
    minZoom,
    projections: {
      [projection]: { matrixSet: undefined, source: 'GIBS:geographic' },
    },
  };
}

// A layer with a matrixSet backed by a resolutions array so overZoom can trigger.
function makeZoomableLayer(id, resolutionCount, minZoom = 0) {
  return {
    id,
    group: 'overlays',
    visible: true,
    opacity: 1,
    type: 'wmts',
    minZoom,
    projections: {
      geographic: { matrixSet: 'EPSG4326_2km', source: 'GIBS:geographic' },
    },
  };
}

function makeZoomableSources(resolutionCount) {
  return {
    'GIBS:geographic': {
      matrixSets: {
        EPSG4326_2km: {
          resolutions: Array(resolutionCount).fill(0.5),
        },
      },
    },
  };
}

function makeLayer(id, proj, matrixSet, source, type = 'wmts') {
  return {
    id,
    type,
    projections: {
      [proj]: { matrixSet, source },
    },
  };
}

function makeSources(sourceName, matrixSetName, resolutionCount) {
  return {
    [sourceName]: {
      matrixSets: {
        [matrixSetName]: {
          resolutions: Array(resolutionCount).fill(0.5),
        },
      },
    },
  };
}

const realNow = util.now.bind(util);

beforeAll(() => {
  util.now = realNow;
});

afterEach(() => {
  util.now = realNow;
});

test('adds base layer', () => {
  let layers = addLayer('terra-cr', [], config.layers, {}, 0);
  layers = addLayer('terra-aod', layers, config.layers, {}, 0);
  layers = addLayer('mask', layers, config.layers, {}, 1);

  const layerList = getLayers(getState(layers), {}).map((x) => x.id);

  expect(layerList).toEqual(['mask', 'terra-cr', 'terra-aod']);
});

test('adds overlay layer', () => {
  let layers = addLayer('terra-cr', [], config.layers, {}, 0);
  layers = addLayer('terra-aod', layers, config.layers, {}, 0);
  layers = addLayer('combo-aod', layers, config.layers, {}, 1);

  const layerList = getLayers(getState(layers), {}).map((x) => x.id);
  expect(layerList).toEqual(['terra-cr', 'combo-aod', 'terra-aod']);
});

test('does not add duplicate layer', () => {
  let layers = addLayer('terra-cr', [], config.layers, {}, 0);
  layers = addLayer('terra-aod', layers, config.layers, {}, 0);
  layers = addLayer('terra-cr', layers, config.layers, {}, 1);

  const layerList = getLayers(getState(layers)).map((x) => x.id);
  expect(layerList).toEqual(['terra-cr', 'terra-aod']);
});

test('resets to default layers', () => {
  const layers = resetLayers(config);
  const layerList = getLayers(getState(layers)).map((x) => x.id);
  expect(layerList).toEqual(['aqua-cr', 'terra-cr', 'terra-aod']);
});

test('gets layers in reverse', () => {
  let layers = addLayer('terra-cr', [], config.layers);
  layers = addLayer('aqua-cr', layers, config.layers);
  layers = addLayer('terra-aod', layers, config.layers);
  layers = addLayer('aqua-aod', layers, config.layers);

  const layerList = getLayers(getState(layers), { reverse: true }).map(
    (x) => x.id,
  );
  expect(layerList).toEqual(['terra-cr', 'aqua-cr', 'terra-aod', 'aqua-aod']);
});

test('gets base layers', () => {
  let layers = addLayer('terra-cr', [], config.layers);
  layers = addLayer('aqua-cr', layers, config.layers);
  layers = addLayer('terra-aod', layers, config.layers);
  layers = addLayer('aqua-aod', layers, config.layers);
  const layerList = getLayers(
    getState(layers),
    { group: 'baselayers' },
  ).map((x) => x.id);
  expect(layerList).toEqual(['aqua-cr', 'terra-cr']);
});

test('gets overlay layers', () => {
  let layers = addLayer('terra-cr', [], config.layers);
  layers = addLayer('aqua-cr', layers, config.layers);
  layers = addLayer('terra-aod', layers, config.layers);
  layers = addLayer('aqua-aod', layers, config.layers);
  const layerList = getLayers(
    getState(layers),
    { group: 'overlays' },
  ).map((x) => x.id);
  expect(layerList).toEqual(['aqua-aod', 'terra-aod']);
});

test('gets all groups', () => {
  let layers = addLayer('terra-cr', [], config.layers);
  layers = addLayer('aqua-cr', layers, config.layers);
  layers = addLayer('terra-aod', layers, config.layers);
  layers = addLayer('aqua-aod', layers, config.layers);

  const layerList = getLayers(getState(layers), { group: 'all' });
  expect(layerList.baselayers[0].id).toBe('aqua-cr');
  expect(layerList.baselayers[1].id).toBe('terra-cr');
  expect(layerList.overlays[0].id).toBe('aqua-aod');
  expect(layerList.overlays[1].id).toBe('terra-aod');
});

// NOTE: Not currently using getLayers to get layers from any
// projection other than the currently active proj

// test('gets layers for other projection', () => {
//   let layers = addLayer('terra-cr', {}, [], config.layers);
//   layers = addLayer('aqua-cr', {}, layers, config.layers);
//   layers = addLayer('terra-aod', {}, layers, config.layers);
//   layers = addLayer('aqua-aod', {}, layers, config.layers);
//   const layerList = getLayers(getState(layers), { proj: 'arctic' }).map(
//     (x) => x.id,
//   );
//   expect(layerList).toEqual(['aqua-cr', 'terra-cr']);
// });

test('obscured base layer is not renderable', () => {
  let layers = addLayer('terra-cr', [], config.layers);
  layers = addLayer('aqua-cr', layers, config.layers);
  layers = addLayer('terra-aod', layers, config.layers);
  layers = addLayer('aqua-aod', layers, config.layers);
  const layerList = getLayers(getState(layers), { renderable: true }).map(
    (x) => x.id,
  );
  expect(layerList).toEqual(['aqua-cr', 'aqua-aod', 'terra-aod']);
});

test('base layer is not obscured by a hidden layer', () => {
  let layers = addLayer('terra-cr', [], config.layers);
  layers = addLayer('aqua-cr', layers, config.layers, { visible: false });
  layers = addLayer('terra-aod', layers, config.layers);
  layers = addLayer('aqua-aod', layers, config.layers);

  const layerList = getLayers(getState(layers), { renderable: true }).map(
    (x) => x.id,
  );
  expect(layerList).toEqual(['terra-cr', 'aqua-aod', 'terra-aod']);
});

test('layer with zero opacity is not renderable', () => {
  let layers = addLayer('terra-cr', [], config.layers);
  layers = addLayer('aqua-cr', layers, config.layers);
  layers = addLayer('terra-aod', layers, config.layers);
  layers = addLayer('aqua-aod', layers, config.layers, { opacity: 0 });

  const layerList = getLayers(getState(layers), { renderable: true }).map(
    (x) => x.id,
  );
  expect(layerList).toEqual(['aqua-cr', 'terra-aod']);
});

test('layer outside date range is not renderable', () => {
  let layers = addLayer('terra-cr', [], config.layers);
  layers = addLayer('aqua-cr', layers, config.layers);
  layers = addLayer('terra-aod', layers, config.layers);
  layers = addLayer('aqua-aod', layers, config.layers);
  let state = getState(layers);
  state = update(state, {
    date: { selected: { $set: new Date(Date.UTC(2001, 0, 1)) } },
  });

  const layerList = getLayers(state, { renderable: true }).map((x) => x.id);
  expect(layerList).toEqual(['terra-cr', 'terra-aod']);
});

test('all layers are visible', () => {
  let layers = addLayer('terra-cr', [], config.layers);
  layers = addLayer('aqua-cr', layers, config.layers);
  layers = addLayer('terra-aod', layers, config.layers);
  layers = addLayer('aqua-aod', layers, config.layers);

  const layerList = getLayers(getState(layers)).map(
    (x) => x.id,
  );
  expect(layerList).toEqual(['aqua-cr', 'terra-cr', 'aqua-aod', 'terra-aod']);
});

// NOTE: Not currently using getLayers to retrieve layers that are
// specifically either visible or not visible

// test('only visible layers', () => {
//   let layers = addLayer('terra-cr', { visible: false }, [], config.layers);
//   layers = addLayer('aqua-cr', {}, layers, config.layers);
//   layers = addLayer('terra-aod', { visible: false }, layers, config.layers);
//   layers = addLayer('aqua-aod', {}, layers, config.layers);

//   const layerList = getLayers(getState(layers), { visible: true }).map(
//     (x) => x.id,
//   );
//   expect(layerList).toEqual(['aqua-cr', 'aqua-aod']);
// });

test('push overlay to bottom', () => {
  let layers = addLayer('terra-cr', [], config.layers);
  layers = addLayer('aqua-cr', layers, config.layers);
  layers = addLayer('terra-aod', layers, config.layers);
  layers = addLayer('aqua-aod', layers, config.layers);
  layers = pushToBottom('aqua-cr', layers);
  const layerList = getLayers(getState(layers)).map((x) => x.id);
  expect(layerList).toEqual(['terra-cr', 'aqua-cr', 'aqua-aod', 'terra-aod']);
});

test('move base layer before', () => {
  let layers = addLayer('terra-cr', [], config.layers);
  layers = addLayer('aqua-cr', layers, config.layers);
  layers = addLayer('terra-aod', layers, config.layers);
  layers = addLayer('aqua-aod', layers, config.layers);
  moveBefore('terra-cr', 'aqua-cr', layers);

  const layerList = getLayers(getState(layers), {}).map((x) => x.id);
  expect(layerList).toEqual(['terra-cr', 'aqua-cr', 'aqua-aod', 'terra-aod']);
});

test('move overlay before', () => {
  let layers = addLayer('terra-cr', [], config.layers);
  layers = addLayer('aqua-cr', layers, config.layers);
  layers = addLayer('terra-aod', layers, config.layers);
  layers = addLayer('aqua-aod', layers, config.layers);
  moveBefore('terra-aod', 'aqua-aod', layers);

  const layerList = getLayers(getState(layers)).map((x) => x.id);
  expect(layerList).toEqual(['aqua-cr', 'terra-cr', 'terra-aod', 'aqua-aod']);
});

// Date Ranges
function getDateRangesTestState(stateObj) {
  let state = stateObj;
  const today = new Date(Date.UTC(2010, 0, 1));
  util.now = () => today;
  const layers = {
    historical_1: {
      id: 'historical_1',
      startDate: '2000-01-01',
      endDate: '2002-01-01',
      group: 'baselayers',
      ongoing: true,
      projections: {
        geographic: {},
      },
    },
    historical_2: {
      id: 'historical_2',
      startDate: '2001-01-01',
      endDate: '2003-01-01',
      group: 'overlays',
      ongoing: true,
      projections: {
        geographic: {},
      },
    },
    active_1: {
      id: 'active_1',
      startDate: '2005-01-01',
      group: 'overlays',
      projections: {
        geographic: {},
      },
    },
    static: {
      id: 'static',
      group: 'overlays',
      projections: {
        geographic: {},
      },
    },
  };
  state = update(state, {
    date: { selected: { $set: today } },
  });
  state = update(state, {
    config: { defaults: { projection: { $set: 'geographic' } } },
  });
  state = update(state, {
    config: { projections: { geographic: { id: { $set: 'geographic' } } } },
  });
  state = update(state, {
    config: { layers: { $set: layers } },
  });
  return state;
}

test('date range for ongoing layers', () => {
  let layers = addLayer('terra-cr', [], config.layers);
  layers = addLayer('aqua-cr', layers, config.layers);
  layers = addLayer('terra-aod', layers, config.layers);
  layers = addLayer('aqua-aod', layers, config.layers);
  const range = dateRange({}, layers, config);

  expect(range.start).toEqual(new Date(Date.UTC(2000, 0, 1)));
  expect(range.start).toEqual(new Date(Date.UTC(2000, 0, 1)));
});

test('date range for ended layers', () => {
  const layersConfig = {};
  layersConfig.end1 = {
    id: 'end1',
    group: 'overlays',
    projections: {
      geographic: {},
    },
    startDate: '1990-01-01',
    endDate: '2005-01-01',
    ongoing: false,
  };
  layersConfig.end2 = {
    id: 'end1',
    group: 'overlays',
    projections: {
      geographic: {},
    },
    startDate: '1992-01-01',
    endDate: '2007-01-01',
    ongoing: false,
  };
  const adjustedConfig = update(config, { layers: { $set: layersConfig } });
  let layers = addLayer('end1', [], layersConfig);
  layers = addLayer('end2', layers, layersConfig);
  const range = dateRange({}, layers, adjustedConfig);

  expect(range.start).toEqual(new Date(Date.UTC(1990, 0, 1)));
  expect(range.end).toEqual(new Date(Date.UTC(2007, 0, 1)));
});

test('date range with one layer', () => {
  let state = getState([]);
  state = getDateRangesTestState(state);
  const layers = addLayer('historical_1', [], state.config.layers);
  const range = dateRange({}, layers, state.config);
  const expectedStartTime = new Date(Date.UTC(2000, 0, 1)).getTime();
  const expectedEndTime = new Date(Date.UTC(2010, 0, 1, 0, 0, 59)).getTime();
  expect(range.start.getTime()).toEqual(expectedStartTime);
  expect(range.end.getTime()).toEqual(expectedEndTime);
});

test('date range with two layers', () => {
  let state = getState([]);
  state = getDateRangesTestState(state);
  let layers = addLayer('historical_1', [], state.config.layers);
  layers = addLayer('historical_2', layers, state.config.layers);
  const range = dateRange({}, layers, state.config);
  const expectedStartTime = new Date(Date.UTC(2000, 0, 1)).getTime();
  const expectedEndTime = new Date(Date.UTC(2010, 0, 1, 0, 0, 59)).getTime();
  expect(range.start.getTime()).toEqual(expectedStartTime);
  expect(range.end.getTime()).toEqual(expectedEndTime);
});

test('end of date range is today if no end date', () => {
  let state = getState([]);
  state = getDateRangesTestState(state);
  const layers = addLayer('active_1', [], state.config.layers);
  const range = dateRange({}, layers, state.config);
  const expectedStartTime = new Date(Date.UTC(2005, 0, 1)).getTime();
  const expectedEndTime = new Date(Date.UTC(2010, 0, 1, 0, 0, 59)).getTime();
  expect(range.start.getTime()).toEqual(expectedStartTime);
  expect(range.end.getTime()).toEqual(expectedEndTime);
});

test('no date range with static', () => {
  let state = getState([]);
  state = getDateRangesTestState(state);
  const layers = addLayer('static', [], state.config.layers);
  const range = dateRange({}, layers, state.config);

  expect(range).toBeFalsy();
});

test('get future layer end date is 5 days after mock current date', () => {
  const testLayer = { futureTime: '5D' };
  // current date floored to quarter hour
  const currentDate = util.roundTimeQuarterHour(util.now());
  // test date to compare is floored to quarter hour and added 5 days using util
  const testDate = util.dateAdd(util.roundTimeQuarterHour(util.now()), 'day', 5);
  const futureEndDate = getFutureLayerEndDate(testLayer);

  const testDateMinutes = testDate.getUTCMinutes();
  const testDateHours = testDate.getUTCHours();
  const testDateDays = testDate.getUTCDate();

  const minutesCompareFuture = futureEndDate.getUTCMinutes();
  const hoursCompareFuture = futureEndDate.getUTCHours();
  const daysCompareFuture = futureEndDate.getUTCDate();

  // check that future date time is greater than current time (ms)
  expect(futureEndDate.getTime()).toBeGreaterThan(currentDate.getTime());
  // check for equality of unchanged date units (minutes/hours) and changed (days)
  expect(testDateMinutes).toEqual(minutesCompareFuture);
  expect(testDateHours).toEqual(hoursCompareFuture);
  expect(testDateDays).toEqual(daysCompareFuture);
});

// ─── hasSubDaily ─────────────────────────────────────────────────────────────
test('hasSubDaily returns true when a subdaily layer is present', () => {
  const layers = [{ period: 'daily' }, { period: 'subdaily' }];
  expect(hasSubDaily(layers)).toBe(true);
});

test('hasSubDaily returns false when no subdaily layer is present', () => {
  const layers = [{ period: 'daily' }, { period: 'monthly' }];
  expect(hasSubDaily(layers)).toBe(false);
});

test('hasSubDaily returns false for empty array', () => {
  expect(hasSubDaily([])).toBe(false);
});

test('hasSubDaily returns false for null/undefined', () => {
  expect(hasSubDaily(null)).toBe(false);
  expect(hasSubDaily(undefined)).toBe(false);
});

// ─── getSubDaily ─────────────────────────────────────────────────────────────
test('getSubDaily returns only subdaily layers', () => {
  const layers = [{ id: 'a', period: 'daily' }, { id: 'b', period: 'subdaily' }];
  const result = getSubDaily(layers);
  expect(result).toHaveLength(1);
  expect(result[0].id).toBe('b');
});

test('getSubDaily returns empty array when no subdaily layers', () => {
  const layers = [{ id: 'a', period: 'daily' }];
  expect(getSubDaily(layers)).toEqual([]);
});

test('getSubDaily returns empty array for null input', () => {
  expect(getSubDaily(null)).toEqual([]);
});

// ─── getFutureLayerEndDate – month and year intervals ────────────────────────
test('getFutureLayerEndDate adds months correctly', () => {
  const now = util.now();
  const expected = new Date(now);
  expected.setUTCMonth(expected.getUTCMonth() + 3);
  const result = getFutureLayerEndDate({ futureTime: '3M' });
  expect(result.getUTCMonth()).toBe(util.roundTimeQuarterHour(expected).getUTCMonth());
});

test('getFutureLayerEndDate adds years correctly', () => {
  const now = util.now();
  const expected = new Date(now);
  expected.setUTCFullYear(expected.getUTCFullYear() + 1);
  const result = getFutureLayerEndDate({ futureTime: '1Y' });
  expect(result.getUTCFullYear()).toBe(util.roundTimeQuarterHour(expected).getUTCFullYear());
});

// ─── dateRange – debugGIBS / ignoreDateRange shortcuts ───────────────────────
test('dateRange returns epoch-to-now when debugGIBS is true', () => {
  const layers = addLayer('terra-cr', [], config.layers);
  const result = dateRange({}, layers, { debugGIBS: true });
  expect(result.start).toEqual(new Date(Date.UTC(1970, 0, 1)));
});

test('dateRange returns epoch-to-now when ignoreDateRange is true', () => {
  const layers = addLayer('terra-cr', [], config.layers);
  const result = dateRange({}, layers, { ignoreDateRange: true });
  expect(result.start).toEqual(new Date(Date.UTC(1970, 0, 1)));
});

// ─── dateRange – specific layer id lookup ────────────────────────────────────
test('dateRange with specific layer id returns range for that layer only', () => {
  let layers = addLayer('terra-cr', [], config.layers);
  layers = addLayer('terra-aod', layers, config.layers);
  const result = dateRange({ layer: 'terra-cr' }, layers);
  expect(result).toBeTruthy();
  expect(result.start).toBeDefined();
});

test('dateRange returns undefined when specific layer id not found in active list', () => {
  const layers = addLayer('terra-cr', [], config.layers);
  const result = dateRange({ layer: 'nonexistent-layer' }, layers);
  expect(result).toBeUndefined();
});

// ─── dateRange – futureTime with endDate branch ──────────────────────────────
test('dateRange handles layer with futureTime and endDate', () => {
  const layersConfig = {
    future_with_end: {
      id: 'future_with_end',
      group: 'overlays',
      projections: { geographic: {} },
      startDate: '2020-01-01',
      endDate: '2030-01-01',
      futureTime: '10D',
      ongoing: true,
    },
  };
  const layers = addLayer('future_with_end', [], layersConfig);
  const result = dateRange({}, layers);
  expect(result).toBeTruthy();
  expect(result.end).toEqual(new Date(Date.UTC(2030, 0, 1)));
});

test('dateRange handles layer with futureTime and no endDate', () => {
  const layersConfig = {
    future_no_end: {
      id: 'future_no_end',
      group: 'overlays',
      projections: { geographic: {} },
      startDate: '2020-01-01',
      futureTime: '7D',
    },
  };
  const layers = addLayer('future_no_end', [], layersConfig);
  const result = dateRange({}, layers);
  console.log(result.end.getTime(), Date.now());
  expect(result).toBeTruthy();
  expect(result.end.getTime()).toBeGreaterThan(Date.now());
});

// ─── pushToBottom – error on inactive layer ───────────────────────────────────
test('pushToBottom throws when layer is not active', () => {
  const layers = addLayer('terra-cr', [], config.layers);
  expect(() => pushToBottom('non-existent', layers)).toThrow();
});

// ─── pushToBottom – overlay uses layerSplit ───────────────────────────────────
test('pushToBottom moves overlay to correct position using layerSplit', () => {
  let layers = addLayer('terra-cr', [], config.layers);
  layers = addLayer('aqua-cr', layers, config.layers);
  layers = addLayer('terra-aod', layers, config.layers);
  layers = addLayer('aqua-aod', layers, config.layers);
  const overlayCount = layers.filter((l) => l.group === 'overlays').length;
  layers = pushToBottom('terra-aod', layers, overlayCount + 1);
  const ids = getLayers(getState(layers)).map((x) => x.id);
  expect(ids).toContain('terra-aod');
});

// ─── moveBefore – error cases ─────────────────────────────────────────────────
test('moveBefore throws when source layer is not active', () => {
  const layers = addLayer('terra-cr', [], config.layers);
  layers.push({ id: 'aqua-cr', group: 'baselayers' });
  expect(() => moveBefore('non-existent', 'aqua-cr', layers)).toThrow();
});

test('moveBefore throws when target layer is not active', () => {
  let layers = addLayer('terra-cr', [], config.layers);
  layers = addLayer('aqua-cr', layers, config.layers);
  expect(() => moveBefore('terra-cr', 'non-existent', layers)).toThrow();
});

test('moveBefore moves source after target when source comes after target', () => {
  let layers = addLayer('terra-cr', [], config.layers);
  layers = addLayer('aqua-cr', layers, config.layers);
  layers = addLayer('terra-aod', layers, config.layers);
  layers = addLayer('aqua-aod', layers, config.layers);
  moveBefore('aqua-aod', 'terra-aod', layers);
  const ids = getLayers(getState(layers)).map((x) => x.id);
  expect(ids.indexOf('aqua-aod')).toBeLessThan(ids.indexOf('terra-aod'));
});

// ─── replaceSubGroup ──────────────────────────────────────────────────────────
test('replaceSubGroup calls moveBefore when nextLayerId is provided', () => {
  let layers = addLayer('terra-cr', [], config.layers);
  layers = addLayer('aqua-cr', layers, config.layers);
  layers = addLayer('terra-aod', layers, config.layers);
  layers = addLayer('aqua-aod', layers, config.layers);
  const result = replaceSubGroup('aqua-cr', 'terra-cr', layers, 2);
  const ids = getLayers(getState(result)).map((x) => x.id);
  expect(ids.indexOf('aqua-cr')).toBeLessThan(ids.indexOf('terra-cr'));
});

test('replaceSubGroup calls pushToBottom when nextLayerId is null', () => {
  let layers = addLayer('terra-cr', [], config.layers);
  layers = addLayer('aqua-cr', layers, config.layers);
  const result = replaceSubGroup('aqua-cr', null, layers, 1);
  expect(result.map((l) => l.id)).toContain('aqua-cr');
});

// ─── getActiveLayers – embed mode filters hidden layers ───────────────────────
test('getActiveLayers in embed mode returns only visible layers', () => {
  let layers = addLayer('terra-cr', [], config.layers);
  layers = addLayer('aqua-cr', layers, config.layers, { visible: false });
  const state = {
    ...getState(layers),
    embed: { isEmbedModeActive: true },
  };
  const result = getActiveLayers(state);
  expect(result.every((l) => l.visible)).toBe(true);
  expect(result.find((l) => l.id === 'aqua-cr')).toBeUndefined();
});

test('getActiveLayers in embed mode returns all layers when all are visible', () => {
  let layers = addLayer('terra-cr', [], config.layers);
  layers = addLayer('aqua-cr', layers, config.layers);
  const state = {
    ...getState(layers),
    embed: { isEmbedModeActive: true },
  };
  const result = getActiveLayers(state);
  expect(result).toHaveLength(2);
});

// ─── getActiveVisibleLayersAtDate ─────────────────────────────────────────────
test('getActiveVisibleLayersAtDate returns renderable layers at date', () => {
  let layers = addLayer('terra-cr', [], config.layers);
  layers = addLayer('aqua-cr', layers, config.layers);
  layers = addLayer('terra-aod', layers, config.layers);
  const state = getState(layers);
  const result = getActiveVisibleLayersAtDate(state, new Date(Date.UTC(2014, 0, 1)));
  expect(Array.isArray(result)).toBe(true);
  expect(result.length).toBeGreaterThan(0);
});

// ─── getCollections ───────────────────────────────────────────────────────────
test('getCollections returns undefined when layer id not in collections', () => {
  const layersState = { collections: {} };
  const result = getCollections(layersState, '2021-01-01', null, { id: 'terra-cr' }, 'geographic');
  expect(result).toBeUndefined();
});

test('getCollections returns matching entry by dailyDate and projection', () => {
  const layersState = {
    collections: {
      'terra-cr': {
        dates: [
          { date: '2021-01-01', projection: 'geographic', type: 'cmr', version: '006' },
          { date: '2021-01-02', projection: 'geographic', type: 'cmr', version: '006' },
        ],
      },
    },
  };
  const result = getCollections(layersState, '2021-01-01', null, { id: 'terra-cr' }, 'geographic');
  expect(result).toBeDefined();
  expect(result.date).toBe('2021-01-01');
});

test('getCollections returns matching entry by subdailyDate', () => {
  const layersState = {
    collections: {
      'terra-cr': {
        dates: [
          { date: '2021-01-01T12:00:00Z', projection: 'geographic', type: 'cmr', version: '006' },
        ],
      },
    },
  };
  const result = getCollections(layersState, null, '2021-01-01T12:00:00Z', { id: 'terra-cr' }, 'geographic');
  expect(result).toBeDefined();
});

test('getCollections returns undefined when date does not match', () => {
  const layersState = {
    collections: {
      'terra-cr': {
        dates: [
          { date: '2021-01-01', projection: 'geographic', type: 'cmr', version: '006' },
        ],
      },
    },
  };
  const result = getCollections(layersState, '2022-06-01', null, { id: 'terra-cr' }, 'geographic');
  expect(result).toBeUndefined();
});

// ─── getFilteredOverlayGroups ─────────────────────────────────────────────────
test('getFilteredOverlayGroups removes Reference group', () => {
  const overlayGroups = [
    { groupName: 'AOD', layers: ['terra-aod'] },
    { groupName: 'Reference', layers: ['mask'] },
  ];
  const overlays = [{ id: 'terra-aod' }];
  const result = getFilteredOverlayGroups(overlayGroups, overlays);
  expect(result.find((g) => g.groupName === 'Reference')).toBeUndefined();
  expect(result.find((g) => g.groupName === 'AOD')).toBeDefined();
});

test('getFilteredOverlayGroups filters out layers not in active overlays', () => {
  const overlayGroups = [
    { groupName: 'AOD', layers: ['terra-aod', 'aqua-aod'] },
  ];
  const overlays = [{ id: 'terra-aod' }];
  const result = getFilteredOverlayGroups(overlayGroups, overlays);
  expect(result[0].layers).toEqual(['terra-aod']);
});

// ─── getActiveOverlayGroups ───────────────────────────────────────────────────
test('getActiveOverlayGroups returns groups with layers valid for projection', () => {
  let layers = addLayer('terra-cr', [], config.layers);
  layers = addLayer('terra-aod', layers, config.layers);
  const state = {
    ...getState(layers),
    layers: {
      active: {
        layers,
        overlayGroups: [{ groupName: 'AOD', layers: ['terra-aod'] }],
      },
    },
  };
  const result = getActiveOverlayGroups(state);
  expect(result).toHaveLength(1);
  expect(result[0].groupName).toBe('AOD');
});

test('getActiveOverlayGroups in embed mode filters Reference groups and hidden layers', () => {
  let layers = addLayer('terra-aod', [], config.layers);
  layers = addLayer('terra-cr', layers, config.layers, { visible: false });
  const state = {
    ...getState(layers),
    embed: { isEmbedModeActive: true },
    layers: {
      active: {
        layers,
        overlayGroups: [
          { groupName: 'AOD', layers: ['terra-aod'] },
          { groupName: 'Reference', layers: ['terra-cr'] },
        ],
      },
    },
  };
  const result = getActiveOverlayGroups(state);
  expect(result.find((g) => g.groupName === 'Reference')).toBeUndefined();
});

// ─── hasMeasurementSetting ────────────────────────────────────────────────────
test('hasMeasurementSetting returns true for valid non-orbital-track layer in projection', () => {
  const mockConfig = {
    layers: {
      'terra-aod': {
        id: 'terra-aod',
        layergroup: 'AOD',
        projections: { geographic: {} },
      },
    },
  };
  const source = { settings: ['terra-aod'] };
  const current = { id: 'some-measurement' };
  const result = hasMeasurementSetting(current, source, mockConfig, 'geographic');
  expect(result).toBe(true);
});

test('hasMeasurementSetting returns undefined when layer not in config', () => {
  const mockConfig = { layers: {} };
  const source = { settings: ['nonexistent-layer'] };
  const current = { id: 'some-measurement' };
  const result = hasMeasurementSetting(current, source, mockConfig, 'geographic');
  expect(result).toBeUndefined();
});

test('hasMeasurementSetting returns undefined when layer not in requested projection', () => {
  const mockConfig = {
    layers: {
      'terra-aod': {
        id: 'terra-aod',
        layergroup: 'AOD',
        projections: { arctic: {} },
      },
    },
  };
  const source = { settings: ['terra-aod'] };
  const current = { id: 'some-measurement' };
  const result = hasMeasurementSetting(current, source, mockConfig, 'geographic');
  expect(result).toBeUndefined();
});

test('hasMeasurementSetting returns true for orbital-track layer when current id matches', () => {
  const mockConfig = {
    layers: {
      'orbital-track': {
        id: 'orbital-track',
        layergroup: 'Orbital Track',
        projections: { geographic: {} },
      },
    },
  };
  const source = { settings: ['orbital-track'] };
  const current = { id: 'orbital-track' };
  const result = hasMeasurementSetting(current, source, mockConfig, 'geographic');
  expect(result).toBe(true);
});

test('hasMeasurementSetting returns undefined for orbital-track when current id does not match', () => {
  const mockConfig = {
    layers: {
      'orbital-track': {
        id: 'orbital-track',
        layergroup: 'Orbital Track',
        projections: { geographic: {} },
      },
    },
  };
  const source = { settings: ['orbital-track'] };
  const current = { id: 'some-other-measurement' };
  const result = hasMeasurementSetting(current, source, mockConfig, 'geographic');
  expect(result).toBeUndefined();
});

// ─── hasMeasurementSource ─────────────────────────────────────────────────────
test('hasMeasurementSource returns true when at least one source has a valid setting', () => {
  const mockConfig = {
    layers: {
      'terra-aod': {
        id: 'terra-aod',
        layergroup: 'AOD',
        projections: { geographic: {} },
      },
    },
  };
  const current = {
    id: 'aod-measurement',
    sources: {
      MODIS_Terra: { settings: ['terra-aod'] },
    },
  };
  const result = hasMeasurementSource(current, mockConfig, 'geographic');
  expect(result).toBe(true);
});

test('hasMeasurementSource returns undefined when no sources have valid settings', () => {
  const mockConfig = { layers: {} };
  const current = {
    id: 'aod-measurement',
    sources: {
      MODIS_Terra: { settings: ['nonexistent'] },
    },
  };
  const result = hasMeasurementSource(current, mockConfig, 'geographic');
  expect(result).toBeUndefined();
});

// ─── getTitles ────────────────────────────────────────────────────────────────
test('getTitles returns layer title, subtitle, and tags', () => {
  const result = getTitles(config, 'terra-cr', 'geographic');
  expect(result.title).toBeDefined();
  expect(result.subtitle).toBeDefined();
  expect(result.tags).toBeDefined();
});

test('getTitles throws when layerId does not exist in config', () => {
  expect(() => getTitles(config, 'nonexistent-layer', 'geographic')).toThrow();
});

// ─── findEventLayers ──────────────────────────────────────────────────────────
test('findEventLayers returns ids of layers in newLayers not in originalLayers', () => {
  const original = [{ id: 'terra-cr' }, { id: 'aqua-cr' }];
  const next = [{ id: 'terra-cr' }, { id: 'aqua-cr' }, { id: 'modis-fires' }];
  const result = findEventLayers(original, next);
  expect(result).toEqual(['modis-fires']);
});

test('findEventLayers returns empty array when no new layers added', () => {
  const original = [{ id: 'terra-cr' }];
  const next = [{ id: 'terra-cr' }];
  expect(findEventLayers(original, next)).toEqual([]);
});

test('makeGetDescription returns description for a valid layer', () => {
  const getDescription = makeGetDescription();
  const state = getDescriptionState();
  const result = getDescription(state, { layer: { id: 'terra-aod' } });
  expect(result).toBe('aerosol-optical-depth/v3');
});

test('makeGetDescription returns undefined when layerId is not provided', () => {
  const getDescription = makeGetDescription();
  const state = getDescriptionState();
  const result = getDescription(state, { layer: null });
  expect(result).toBeUndefined();
});

test('makeGetDescription returns undefined for Orbital Track layers', () => {
  const getDescription = makeGetDescription();
  const state = getDescriptionState();
  const result = getDescription(state, { layer: { id: 'orbital-track' } });
  expect(result).toBeUndefined();
});

test('makeGetDescription ignores Featured measurements when resolving description', () => {
  const getDescription = makeGetDescription();
  const state = getDescriptionState();
  const result = getDescription(state, { layer: { id: 'terra-aod' } });
  expect(result).not.toBe('featured/aerosol');
  expect(result).toBe('aerosol-optical-depth/v3');
});

test('makeGetDescription returns undefined when layer exists in config but has no matching measurement source', () => {
  const getDescription = makeGetDescription();
  const state = {
    config: {
      layers: {
        'terra-aod': { id: 'terra-aod', layergroup: 'AOD' },
      },
      measurements: {
        'Some Measurement': {
          sources: {
            MODIS_Terra: {
              description: 'some/path',
              settings: ['aqua-aod'],
            },
          },
        },
      },
    },
  };
  const result = getDescription(state, { layer: { id: 'terra-aod' } });
  expect(result).toBeUndefined();
});

test('each makeGetDescription() call creates an independent memoized selector', () => {
  const getDescriptionA = makeGetDescription();
  const getDescriptionB = makeGetDescription();
  const state = getDescriptionState();
  expect(getDescriptionA).not.toBe(getDescriptionB);
  expect(getDescriptionA(state, { layer: { id: 'terra-aod' } }))
    .toBe(getDescriptionB(state, { layer: { id: 'terra-aod' } }));
});

test('returns 1440 (default) when there are no layers', () => {
  const state = getIntervalState([]);
  expect(getSmallestIntervalValue(state)).toBe(1440);
});

test('returns 1440 (default) when no layers have subdaily period', () => {
  const state = getIntervalState([
    { id: 'terra-cr', period: 'daily', dateRanges: [{ dateInterval: '1' }] },
    { id: 'aqua-cr', period: 'monthly', dateRanges: [{ dateInterval: '30' }] },
  ]);
  expect(getSmallestIntervalValue(state)).toBe(1440);
});

test('returns the interval of a single subdaily layer', () => {
  const state = getIntervalState([
    { id: 'viirs-subdaily', period: 'subdaily', dateRanges: [{ dateInterval: '10' }] },
  ]);
  expect(getSmallestIntervalValue(state)).toBe(10);
});

test('returns the smallest interval across multiple subdaily layers', () => {
  const state = getIntervalState([
    { id: 'layer-a', period: 'subdaily', dateRanges: [{ dateInterval: '60' }] },
    { id: 'layer-b', period: 'subdaily', dateRanges: [{ dateInterval: '10' }] },
    { id: 'layer-c', period: 'subdaily', dateRanges: [{ dateInterval: '30' }] },
  ]);
  expect(getSmallestIntervalValue(state)).toBe(10);
});

test('ignores non-subdaily layers when selecting smallest interval', () => {
  const state = getIntervalState([
    { id: 'daily-layer', period: 'daily', dateRanges: [{ dateInterval: '1' }] },
    { id: 'subdaily-layer', period: 'subdaily', dateRanges: [{ dateInterval: '20' }] },
  ]);
  expect(getSmallestIntervalValue(state)).toBe(20);
});

test('returns 1440 when subdaily layer has no dateRanges', () => {
  const state = getIntervalState([
    { id: 'subdaily-no-range', period: 'subdaily' },
  ]);
  expect(getSmallestIntervalValue(state)).toBe(1440);
});

test('returns 1440 when subdaily layer dateRanges is empty', () => {
  const state = getIntervalState([
    { id: 'subdaily-empty-range', period: 'subdaily', dateRanges: [] },
  ]);
  expect(getSmallestIntervalValue(state)).toBe(1440);
});

test('handles string interval values by coercing to number', () => {
  const state = getIntervalState([
    { id: 'layer-a', period: 'subdaily', dateRanges: [{ dateInterval: '5' }] },
  ]);
  const result = getSmallestIntervalValue(state);
  expect(result).toBe(5);
  expect(typeof result).toBe('number');
});

test('does not update smallestDelta when interval is larger than current smallest', () => {
  const state = getIntervalState([
    { id: 'layer-a', period: 'subdaily', dateRanges: [{ dateInterval: '10' }] },
    { id: 'layer-b', period: 'subdaily', dateRanges: [{ dateInterval: '120' }] },
  ]);
  expect(getSmallestIntervalValue(state)).toBe(10);
});

test('returns active layers unchanged when category has no layers defined for projection', () => {
  let activeLayers = addLayer('terra-cr', [], config.layers);
  activeLayers = addLayer('terra-aod', activeLayers, config.layers);
  const state = getEventState(activeLayers, undefined);
  const result = activateLayersForEventCategory(state, 'fires');
  expect(result.map((l) => l.id)).toEqual(activeLayers.map((l) => l.id));
});

test('turns off all current layers before applying event category layers', () => {
  let activeLayers = addLayer('terra-cr', [], config.layers);
  activeLayers = addLayer('terra-aod', activeLayers, config.layers);
  const state = getEventState(activeLayers, [['terra-cr', true]]);
  const result = activateLayersForEventCategory(state, 'fires');
  const terAod = result.find((l) => l.id === 'terra-aod');
  expect(terAod.visible).toBe(false);
});

test('turns on a layer that already exists in the active list', () => {
  let activeLayers = addLayer('terra-cr', [], config.layers);
  activeLayers = addLayer('terra-aod', activeLayers, config.layers);
  const state = getEventState(activeLayers, [['terra-cr', true]]);
  const result = activateLayersForEventCategory(state, 'fires');
  const terraCr = result.find((l) => l.id === 'terra-cr');
  expect(terraCr.visible).toBe(true);
});

test('keeps a layer hidden when category specifies it as not visible', () => {
  let activeLayers = addLayer('terra-cr', [], config.layers);
  activeLayers = addLayer('terra-aod', activeLayers, config.layers);
  const state = getEventState(activeLayers, [['terra-cr', false]]);
  const result = activateLayersForEventCategory(state, 'fires');
  const terraCr = result.find((l) => l.id === 'terra-cr');
  expect(terraCr.visible).toBe(false);
});

test('adds a layer that does not yet exist in the active list', () => {
  const activeLayers = addLayer('terra-cr', [], config.layers);
  const state = getEventState(activeLayers, [['terra-aod', true]]);
  const result = activateLayersForEventCategory(state, 'fires');
  const newLayer = result.find((l) => l.id === 'terra-aod');
  expect(newLayer).toBeDefined();
  expect(newLayer.visible).toBe(true);
});

test('adds a new layer with visible set to false when category specifies hidden', () => {
  const activeLayers = addLayer('terra-cr', [], config.layers);
  const state = getEventState(activeLayers, [['terra-aod', false]]);
  const result = activateLayersForEventCategory(state, 'fires');
  const newLayer = result.find((l) => l.id === 'terra-aod');
  expect(newLayer).toBeDefined();
  expect(newLayer.visible).toBe(false);
});

test('handles multiple category layers — turning on existing and adding new', () => {
  let activeLayers = addLayer('terra-cr', [], config.layers);
  activeLayers = addLayer('aqua-cr', activeLayers, config.layers);
  const state = getEventState(activeLayers, [
    ['terra-cr', true],
    ['terra-aod', true],
  ]);
  const result = activateLayersForEventCategory(state, 'fires');
  expect(result.find((l) => l.id === 'terra-cr').visible).toBe(true);
  expect(result.find((l) => l.id === 'aqua-cr').visible).toBe(false);
  expect(result.find((l) => l.id === 'terra-aod')).toBeDefined();
  expect(result.find((l) => l.id === 'terra-aod').visible).toBe(true);
});

test('returns an array', () => {
  const activeLayers = addLayer('terra-cr', [], config.layers);
  const state = getEventState(activeLayers, [['terra-cr', true]]);
  const result = activateLayersForEventCategory(state, 'fires');
  expect(Array.isArray(result)).toBe(true);
});

test('does not mutate the original active layers array', () => {
  let activeLayers = addLayer('terra-cr', [], config.layers);
  activeLayers = addLayer('terra-aod', activeLayers, config.layers);
  const originalIds = activeLayers.map((l) => l.id);
  const state = getEventState(activeLayers, [['terra-cr', true]]);
  activateLayersForEventCategory(state, 'fires');
  expect(activeLayers.map((l) => l.id)).toEqual(originalIds);
});

test('returns an empty object when no layers are active', () => {
  const state = getZotState({ activeLayers: [], zoom: 5 });
  expect(getZotsForActiveLayers(state)).toEqual({});
});

test('returns an empty object when no zot conditions are met', () => {
  const layer = makeSimpleLayer('terra-aod');
  const state = getZotState({ activeLayers: [layer], zoom: 3 });
  const result = getZotsForActiveLayers(state);
  expect(result['terra-aod']).toBeUndefined();
});

test('includes a layer entry when overZoom is triggered', () => {
  const resolutionCount = 4; // zoomLimit = 3
  const layer = makeZoomableLayer('terra-aod', resolutionCount);
  const sources = makeZoomableSources(resolutionCount);
  const state = getZotState({ activeLayers: [layer], zoom: 5, sources });
  const result = getZotsForActiveLayers(state);
  expect(result['terra-aod']).toBeDefined();
  expect(result['terra-aod'].overZoomValue).toBeGreaterThan(0);
});

test('overZoomValue is calculated as zoom minus zoomLimit rounded to 2 decimals', () => {
  const resolutionCount = 4; // zoomLimit = 3
  const layer = makeZoomableLayer('terra-aod', resolutionCount);
  const sources = makeZoomableSources(resolutionCount);
  const state = getZotState({ activeLayers: [layer], zoom: 5, sources });
  const result = getZotsForActiveLayers(state);
  expect(result['terra-aod'].overZoomValue).toBe(2); // 5 - 3 = 2
});

test('does not include a layer entry when zoom is exactly at the zoomLimit', () => {
  const resolutionCount = 4; // zoomLimit = 3
  const layer = makeZoomableLayer('terra-aod', resolutionCount);
  const sources = makeZoomableSources(resolutionCount);
  const state = getZotState({ activeLayers: [layer], zoom: 3, sources });
  const result = getZotsForActiveLayers(state);
  expect(result['terra-aod']).toBeUndefined();
});

test('includes a layer entry when underZoom is triggered (minZoom > zoom)', () => {
  const layer = makeSimpleLayer('terra-aod', 'geographic', 8);
  const state = getZotState({ activeLayers: [layer], zoom: 4 });
  const result = getZotsForActiveLayers(state);
  expect(result['terra-aod']).toBeDefined();
  expect(result['terra-aod'].underZoomValue).toBeGreaterThan(0);
});

test('underZoomValue is calculated as minZoom minus zoom rounded to 2 decimals', () => {
  const layer = makeSimpleLayer('terra-aod', 'geographic', 8);
  const state = getZotState({ activeLayers: [layer], zoom: 5 });
  const result = getZotsForActiveLayers(state);
  expect(result['terra-aod'].underZoomValue).toBe(3); // 8 - 5 = 3
});

test('does not include a layer entry when underZoomValue is zero', () => {
  const layer = makeSimpleLayer('terra-aod', 'geographic', 5);
  const state = getZotState({ activeLayers: [layer], zoom: 5 });
  const result = getZotsForActiveLayers(state);
  expect(result['terra-aod']).toBeUndefined();
});

test('skips layers that are not available in the current projection', () => {
  const layer = makeSimpleLayer('arctic-layer', 'arctic', 0);
  const state = getZotState({ activeLayers: [layer], zoom: 10 });
  const result = getZotsForActiveLayers(state);
  expect(result['arctic-layer']).toBeUndefined();
});

test('returns entries for multiple layers with independent zot conditions', () => {
  const resolutionCount = 4;
  const overZoomedLayer = makeZoomableLayer('layer-a', resolutionCount, 0);
  const underZoomedLayer = makeSimpleLayer('layer-b', 'geographic', 10);
  const normalLayer = makeSimpleLayer('layer-c', 'geographic', 0);
  const sources = makeZoomableSources(resolutionCount);
  const state = getZotState({
    activeLayers: [overZoomedLayer, underZoomedLayer, normalLayer],
    zoom: 6,
    sources,
  });
  const result = getZotsForActiveLayers(state);
  expect(result['layer-a']).toBeDefined();
  expect(result['layer-b']).toBeDefined();
  expect(result['layer-c']).toBeUndefined();
});

test('returns false when no layers are active', () => {
  const state = getZotState({ activeLayers: [] });
  expect(getAnyOverZoom(state, 5)).toEqual(false);
});

test('returns false when not overzoomed', () => {
  const layer = makeSimpleLayer('terra-aod');
  const state = getZotState({ activeLayers: [layer] });
  const result = getAnyOverZoom(state, 3);
  expect(result).toEqual(false);
});

test('returns true when overzoomed', () => {
  const resolutionCount = 4; // zoomLimit = 3
  const layer = makeZoomableLayer('terra-aod', resolutionCount);
  const sources = makeZoomableSources(resolutionCount);
  const state = getZotState({ activeLayers: [layer], sources });
  const result = getAnyOverZoom(state, 5);
  expect(result).toEqual(true);
});

test('returns fallback zoom when layers array is empty', () => {
  expect(getMaxZoomLevelLayerCollection([], 8, 'geographic', {})).toBe(8);
});

test('returns fallback zoom when layer has no matrixSet', () => {
  const layer = makeLayer('layer-a', 'geographic', undefined, 'GIBS:geographic');
  const sources = makeSources('GIBS:geographic', 'EPSG4326_2km', 6);
  expect(getMaxZoomLevelLayerCollection([layer], 8, 'geographic', sources)).toBe(8);
});

test('returns fallback zoom when layer type is vector', () => {
  const layer = makeLayer('layer-a', 'geographic', 'EPSG4326_2km', 'GIBS:geographic', 'vector');
  const sources = makeSources('GIBS:geographic', 'EPSG4326_2km', 6);
  expect(getMaxZoomLevelLayerCollection([layer], 8, 'geographic', sources)).toBe(8);
});

test('returns fallback zoom when resolutions array is missing', () => {
  const layer = makeLayer('layer-a', 'geographic', 'EPSG4326_2km', 'GIBS:geographic');
  const sources = { 'GIBS:geographic': { matrixSets: { EPSG4326_2km: {} } } };
  expect(getMaxZoomLevelLayerCollection([layer], 8, 'geographic', sources)).toBe(8);
});

test('returns fallback zoom when sources is undefined', () => {
  const layer = makeLayer('layer-a', 'geographic', 'EPSG4326_2km', 'GIBS:geographic');
  expect(getMaxZoomLevelLayerCollection([layer], 8, 'geographic', undefined)).toBe(8);
});

test('returns correct zoomLimit for a single qualifying layer', () => {
  const layer = makeLayer('layer-a', 'geographic', 'EPSG4326_2km', 'GIBS:geographic');
  const sources = makeSources('GIBS:geographic', 'EPSG4326_2km', 6); // zoomLimit = 5
  expect(getMaxZoomLevelLayerCollection([layer], 8, 'geographic', sources)).toBe(5);
});

test('returns the smallest zoomLimit across multiple qualifying layers', () => {
  const layerA = makeLayer('layer-a', 'geographic', 'EPSG4326_2km', 'GIBS:geographic');
  const layerB = makeLayer('layer-b', 'geographic', 'EPSG4326_500m', 'GIBS:geographic');
  const sources = {
    'GIBS:geographic': {
      matrixSets: {
        EPSG4326_2km: { resolutions: Array(6).fill(0.5) },   // zoomLimit = 5
        EPSG4326_500m: { resolutions: Array(9).fill(0.25) },  // zoomLimit = 8
      },
    },
  };
  expect(getMaxZoomLevelLayerCollection([layerA, layerB], 10, 'geographic', sources)).toBe(5);
});

test('ignores non-qualifying layers when computing the minimum', () => {
  const qualifyingLayer = makeLayer('layer-a', 'geographic', 'EPSG4326_2km', 'GIBS:geographic');
  const vectorLayer = makeLayer('layer-b', 'geographic', 'EPSG4326_2km', 'GIBS:geographic', 'vector');
  const sources = makeSources('GIBS:geographic', 'EPSG4326_2km', 6); // zoomLimit = 5
  expect(getMaxZoomLevelLayerCollection([qualifyingLayer, vectorLayer], 10, 'geographic', sources)).toBe(5);
});

test('applies zoomOffset of 1 for arctic projection', () => {
  const layer = makeLayer('layer-a', 'arctic', 'EPSG3413_2km', 'GIBS:arctic');
  const sources = makeSources('GIBS:arctic', 'EPSG3413_2km', 6); // zoomLimit = 5 + 1 = 6
  expect(getMaxZoomLevelLayerCollection([layer], 10, 'arctic', sources)).toBe(6);
});

test('applies zoomOffset of 1 for antarctic projection', () => {
  const layer = makeLayer('layer-a', 'antarctic', 'EPSG3031_2km', 'GIBS:antarctic');
  const sources = makeSources('GIBS:antarctic', 'EPSG3031_2km', 6); // zoomLimit = 5 + 1 = 6
  expect(getMaxZoomLevelLayerCollection([layer], 10, 'antarctic', sources)).toBe(6);
});

test('does not apply zoomOffset for geographic projection', () => {
  const layer = makeLayer('layer-a', 'geographic', 'EPSG4326_2km', 'GIBS:geographic');
  const sources = makeSources('GIBS:geographic', 'EPSG4326_2km', 6); // zoomLimit = 5 + 0 = 5
  expect(getMaxZoomLevelLayerCollection([layer], 10, 'geographic', sources)).toBe(5);
});

test('returns fallback zoom when all layers are non-qualifying', () => {
  const layerA = makeLayer('layer-a', 'geographic', undefined, 'GIBS:geographic');
  const layerB = makeLayer('layer-b', 'geographic', 'EPSG4326_2km', 'GIBS:geographic', 'vector');
  const sources = makeSources('GIBS:geographic', 'EPSG4326_2km', 6);
  expect(getMaxZoomLevelLayerCollection([layerA, layerB], 7, 'geographic', sources)).toBe(7);
});

test('returns fallback zoom of 0 when passed 0 and no qualifying layers', () => {
  expect(getMaxZoomLevelLayerCollection([], 0, 'geographic', {})).toBe(0);
});

describe('getMaxDayRange', () => {
  test('returns 0 when layer has no maxDayRange', () => {
    expect(getMaxDayRange({ id: 'foo' })).toBe(0);
  });

  test('returns 0 when maxDayRange is 1 (no aggregation possible)', () => {
    expect(getMaxDayRange({ id: 'foo', maxDayRange: 1 })).toBe(0);
  });

  test('returns the configured maxDayRange', () => {
    expect(getMaxDayRange({ id: 'foo', maxDayRange: 12 })).toBe(12);
  });

  test('clamps to MAX_DAY_COUNT', () => {
    expect(getMaxDayRange({ id: 'foo', maxDayRange: 999 })).toBe(12);
  });
});

describe('getLayerDayCount', () => {
  function getDayCountState(layer, activeString = 'active') {
    return {
      layers: {
        [activeString]: { layers: [layer] },
      },
      compare: { activeString: 'active' },
    };
  }

  test('defaults to 1 when layer has no maxDayRange', () => {
    const state = getDayCountState({ id: 'foo', dayCount: 5 });
    expect(getLayerDayCount(state, 'foo')).toBe(1);
  });

  test('reads dayCount when within maxDayRange', () => {
    const state = getDayCountState({ id: 'foo', maxDayRange: 12, dayCount: 5 });
    expect(getLayerDayCount(state, 'foo')).toBe(5);
  });

  test('clamps dayCount above maxDayRange', () => {
    const state = getDayCountState({ id: 'foo', maxDayRange: 12, dayCount: 99 });
    expect(getLayerDayCount(state, 'foo')).toBe(12);
  });

  test('defaults to 1 when dayCount is unset', () => {
    const state = getDayCountState({ id: 'foo', maxDayRange: 12 });
    expect(getLayerDayCount(state, 'foo')).toBe(1);
  });

  test('reads the requested side in compare mode', () => {
    const state = getDayCountState({ id: 'foo', maxDayRange: 12, dayCount: 7 }, 'activeB');
    expect(getLayerDayCount(state, 'foo', 'activeB')).toBe(7);
  });

  test('tolerates a side with no layers array', () => {
    const state = { layers: { active: {} }, compare: { activeString: 'active' } };
    expect(getLayerDayCount(state, 'foo')).toBe(1);
  });
});