import { createFeatureSelector, createSelector, MemoizedSelector, ActionReducerMap } from '@ngrx/store';
import * as fromCoreReferenceData from './core-reference-data.reducer';
import * as fromCaseDetails from './case-details.reducer';
import * as fromCaseNotes from './case-notes.reducer';
import * as fromExemptEp from './exempt-ep.reducer';
import { Dictionary, EntitySelectors } from '@ngrx/entity/src/models';
import { ReferenceData } from '../../shared/models/reference-data';
import { TypedReferenceData } from '../../shared/models/typed-reference-data';
import { CaseDetails } from '../models/case-details';
import { CaseNotes } from '../models/case-notes/case-notes';

export interface CoreState {
  referenceData: fromCoreReferenceData.LocalState;
  caseDetails: fromCaseDetails.LocalState;
  caseNotes: fromCaseNotes.LocalState;
  exemptEp: fromExemptEp.LocalState;
}

export const reducers: ActionReducerMap<CoreState> = {
  referenceData: fromCoreReferenceData.reducer,
  caseDetails: fromCaseDetails.reducer,
  caseNotes: fromCaseNotes.reducer,
  exemptEp: fromExemptEp.reducer,
};

export interface State {
  coreState: CoreState;
}

export const getCoreState: MemoizedSelector<any, any> = createFeatureSelector<CoreState>( 'core-data' );

// reference data
export const getCoreReferenceDataEntitiesState: MemoizedSelector<any, any> = createSelector(
  getCoreState, state => state.referenceData,
);
export const {
  selectIds: getReferenceDataIds,
  selectEntities: getReferenceDataEntities,
  selectAll: getAllReferenceData,
  selectTotal: getTotalReferenceData,
}: EntitySelectors<TypedReferenceData<ReferenceData>, any> =
  fromCoreReferenceData.adapter.getSelectors( getCoreReferenceDataEntitiesState );

// case summary details
export const getCaseDetailsEntitiesState: MemoizedSelector<any, any> = createSelector(
  getCoreState, (state: CoreState) => state.caseDetails,
);

export const getCaseDetailsLoading: MemoizedSelector<any, any> =
createSelector(getCaseDetailsEntitiesState, fromCaseDetails.getLoading);

export const getCaseDetails: MemoizedSelector<any, any> =
createSelector(getCaseDetailsEntitiesState, fromCaseDetails.getCaseDetails);

export const getCaseDetailsErrors: MemoizedSelector<any, any> =
createSelector(getCaseDetailsEntitiesState, fromCaseDetails.getErrors);

export const getSelectedCaseId: MemoizedSelector<any, any> =
createSelector(getCaseDetailsEntitiesState, fromCaseDetails.getSelectedCaseId);

export const {
  selectEntities: getCaseDetailsEntities,
}: EntitySelectors<CaseDetails, State> = fromCaseDetails.adapter.getSelectors( getCaseDetailsEntitiesState );

export const getSelectedCaseDetails: MemoizedSelector<any, any> = createSelector(
  getCaseDetailsEntities,
  getSelectedCaseId,
  ( caseDetailsEntities, caseId ) => { return caseDetailsEntities[caseId]; },
);

export const getCaseNotesEntitiesState: MemoizedSelector<object, fromCaseNotes.LocalState> = createSelector(
  getCoreState, (state: CoreState) => state.caseNotes,
);

export const getSelectedCaseIdForNotes: MemoizedSelector<object, number> =
createSelector(getCaseNotesEntitiesState, fromCaseNotes.getSelectedCaseId);

export const getCaseNotesLoading: MemoizedSelector<object, boolean> =
createSelector(getCaseNotesEntitiesState, fromCaseNotes.getLoading);

export const {
  selectEntities: getCaseNotesEntities,
  selectAll: getAllCaseNotes,
}: EntitySelectors<CaseNotes, State> = fromCaseNotes.adapter.getSelectors( getCaseNotesEntitiesState );

export const getSelectedCaseNotes: MemoizedSelector<any, any> = createSelector(
  getCaseNotesEntities,
  getSelectedCaseIdForNotes,
  ( caseNotesEntities: Dictionary<CaseNotes>, id: number ) => { return caseNotesEntities[id]; },
);

// Exempt EP

export const getExemptEpEntitiesState: MemoizedSelector<object, fromExemptEp.LocalState> = createSelector(
  getCoreState, (state: CoreState) => state.exemptEp,
);

export const getExemptEpLoading: MemoizedSelector<object, boolean> =
createSelector(getExemptEpEntitiesState, fromExemptEp.getLoading);

export const getCloseExemptEpModal: MemoizedSelector<object, boolean> =
createSelector(getExemptEpEntitiesState, fromExemptEp.getCloseExemptEpModal);