selectors.ts

import { createSelector } from '@ngrx/store';
import { GlobalState } from '@app/core/state';
import { PlannedTerm } from '@app/core/models/planned-term';
import { DegreePlannerState } from './state';
import { parseTermCode } from '../shared/utils';
import { YearMapping, Year } from '@app/core/models/year';

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

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

export const selectVisibleDegreePlan = createSelector(
  (state: GlobalState) => state.degreePlanner,
  state => state.visibleDegreePlan,
);

export const selectAllDegreePlans = createSelector(
  (state: GlobalState) => state.degreePlanner,
  state => state.allDegreePlans,
);

export const getSavedForLaterCourses = createSelector(
  (state: GlobalState) => state.degreePlanner,
  state => state.savedForLaterCourses,
);

export const getSubjects = createSelector(
  (state: GlobalState) => state.degreePlanner,
  state => state.subjects,
);

export const selectSubjects = getSubjects;

export const getActiveTerms = createSelector(
  (state: GlobalState) => state.degreePlanner,
  state => state.activeTermCodes,
);

export const selectActiveTermCodes = getActiveTerms;

export const selectAllVisibleYears = createSelector(
  (state: GlobalState) => state.degreePlanner,
  state => state.visibleYears,
);

export const selectYearExpandedState = createSelector(
  (state: GlobalState, params: { yearCode: string }): Year | undefined => {
    return state.degreePlanner.visibleYears[params.yearCode];
  },
  year => {
    if (year) {
      return year.isExpanded;
    } else {
      return false;
    }
  },
);

export const selectVisibleTerm = createSelector(
  (state: GlobalState) => state.degreePlanner.visibleYears,
  (years: YearMapping, params: { termCode: string }) => {
    const { yearCode, termName } = parseTermCode(params.termCode);
    const year = years[yearCode] as Year | undefined;
    if (year) {
      return year[termName];
    } else {
      return undefined;
    }
  },
);

export const getSubjectDescriptions = createSelector(
  getDegreePlannerState,
  (state: DegreePlannerState) => {
    return state.subjectDescriptions;
  },
);

export const isCourseSearchOpen = createSelector(
  getDegreePlannerState,
  (state: DegreePlannerState) => {
    return state.search.visible;
  },
);

export const getSelectedSearchTerm = createSelector(
  getDegreePlannerState,
  (state: DegreePlannerState) => {
    return state.search.selectedTerm;
  },
);

export const getActiveSelectedSearchTerm = createSelector(
  getDegreePlannerState,
  (state: DegreePlannerState) => {
    const { selectedTerm } = state.search;
    return state.activeTermCodes.includes(selectedTerm) ? selectedTerm : '0000';
  },
);

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

      return termCode === currentTermCode;
    },
  );

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

      return termCode < currentTermCode;
    },
  );
export const isLoadingPlan = createSelector(
  getDegreePlannerState,
  (state: DegreePlannerState) => state.isLoadingPlan,
);

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

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

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