selectors.ts

// Libraries
import { createSelector } from '@ngrx/store';

// Models
import { GlobalState } from '@app/core/state';
import { Year } from '@app/core/models/year';
import { Note } from '@app/core/models/note';
import { Course } from '@app/core/models/course';
import { PlannedTerm } from '@app/core/models/planned-term';
import { DegreePlannerState } from './state';

export const getDegreePlannerState = ({ degreePlanner }: GlobalState) => {
  return degreePlanner;
};

export const hasLoadedDegreePlan = createSelector(
  getDegreePlannerState,
  state => state.visibleDegreePlan !== undefined,
);

export const getSavedForLaterCourses = createSelector(
  getDegreePlannerState,
  state => state.savedForLaterCourses,
);

export const firstActiveTermCode = createSelector(
  getDegreePlannerState,
  state => {
    if (state.activeTermCodes.length > 0) {
      return state.activeTermCodes[0];
    } else {
      return undefined;
    }
  },
);

export const getAllDegreePlans = createSelector(
  getDegreePlannerState,
  state => state.allDegreePlans,
);

export const getVisibleRoadmapId = createSelector(
  getDegreePlannerState,
  state => {
    return state.visibleDegreePlan
      ? state.visibleDegreePlan.roadmapId
      : undefined;
  },
);

export const getVisibleDegreePlan = createSelector(
  getDegreePlannerState,
  state => state.visibleDegreePlan,
);

export const getAllVisibleTerms = createSelector(
  getDegreePlannerState,
  state => state.visibleTerms,
);

export const getAllVisibleTermsByYear = createSelector(
  getDegreePlannerState,
  state => {
    const unqiueYears = state.visibleTerms
      .map(term => term.termCode.slice(0, 3))
      .filter(year => year.match(/^\d{3}/))
      .filter((year, index, self) => self.indexOf(year) === index)
      .sort();

    return unqiueYears.map<Year>(year => {
      const century = year[0] === '0' ? 0 : 1;
      const twoDigitYearCode = parseInt(year.substr(1, 2), 10);
      return {
        century,
        twoDigitYearCode,
        fall: getTermForCode(`${year}2`, state.visibleTerms),
        spring: getTermForCode(`${year}4`, state.visibleTerms),
        summer: getTermForCode(`${year}6`, state.visibleTerms),
        expandedState:
          state.expandedYears.indexOf(twoDigitYearCode.toString()) > -1,
      };
    });
  },
);

export const getDropZones = createSelector(
  getDegreePlannerState,
  (state: DegreePlannerState) => {
    // Get the most recent active term
    const currentTermCode = state.activeTermCodes[0];

    // Get only current / future terms
    const activeTerms = state.visibleTerms.filter(
      term => term.termCode >= currentTermCode,
    );

    // Return a list of current and future drop zone ID's
    return [
      'saved-courses',
      ...activeTerms.map(term => `term-${term.termCode}`),
    ];
  },
);

export const isPastTerm = (termCode: string) =>
  createSelector(
    getDegreePlannerState,
    (state: DegreePlannerState) => {
      const currentTermCode = state.activeTermCodes[0];

      return termCode < currentTermCode;
    },
  );

const getTermForCode = (termCode: string, terms: PlannedTerm[]) => {
  const foundTerm = terms.find(term => term.termCode === termCode);

  if (foundTerm !== undefined) {
    return foundTerm;
  }

  return { termCode, courses: [] };
};