import { Injectable } from '@angular/core';
import { StatusState } from '@core/states/status.state';
import applicationStatuses from '@core/static-assets/application-statuses';
import archiveReasonCodes from '@core/static-assets/archive-reason-codes';
import paymentStatuses from '@core/static-assets/payment-statuses';
import { ApplicantFormForUI, PortalFormAvailabilityInfo } from '@core/typings/application.typing';
import { ApplicationStatuses, BATCH_STATUS, PaymentSubStatus, ReasonCode, StatusMap, StatusOptions } from '@core/typings/status.typing';
import { CancelReasons } from '@core/typings/ui/cancel-application.typing';
import { AvailabilityOptions, DateOption, FormStatuses, FORM_STATUS } from '@features/configure-forms/form.typing';
import { ALL_SKIP_FILTER, SimpleStringMap, TypeaheadSelectOption } from '@yourcause/common';
import { I18nService } from '@yourcause/common/i18n';
import { AttachYCState, BaseYCService } from '@yourcause/common/state';
import moment from 'moment';
export const DRAFT = 'draft';

@AttachYCState(StatusState)
@Injectable({ providedIn: 'root' })
export class StatusService extends BaseYCService<StatusState> {

  constructor (
    private i18n: I18nService
  ) {
    super();
    this.i18n.language$.subscribe(() => {
      this.reset();
    });
  }

  get paymentStatusMap () {
    return this.get('paymentStatusMap');
  }

  get paymentSubStatusMap () {
    return this.get('paymentSubStatusMap');
  }

  get paymentStatusOptions () {
    return this.get('paymentStatusOptions');
  }

  get formStatusMap () {
    return this.get('formStatusMap');
  }

  get applicationStatusMap () {
    return this.get('applicationStatusMap');
  }

  get formStatusOptions () {
    return this.get('formStatusOptions');
  }

  get adHocStatusOptions () {
    return this.get('adHocAppStatusOptions');
  }

  get appStatusOptions () {
    return this.get('appStatusOptions');
  }

  get archiveReasonCodeMap () {
    return this.get('archiveReasonCodeMap');
  }

  get notSubmittedAsOfToday () {
    return this.i18n.translate(
      'GLOBAL:textNotSubmittedAsOfToday',
      {
        date: moment().format('ll')
      },
      'Not submitted as of __date__'
    );
  }

  getDynamicStatusString (
    formStatus: FormStatuses,
    updatedDate: string,
    submittedDate: string,
    revisionLastSentDate: string,
    portalAvailabilityInfo?: PortalFormAvailabilityInfo
  ) {
    if (formStatus) {
      if ((formStatus === FormStatuses.NotSent) &&
        (
          !portalAvailabilityInfo ||
          [
            AvailabilityOptions.MANUAL,
            AvailabilityOptions.AUTO
          ].includes(portalAvailabilityInfo?.portalFormAvailabilityType)
        )
      ) {
        // Not sent
        return this.i18n.translate('GLOBAL:textNotSent', {}, 'Not sent');
      } else if (
        [
          FormStatuses.Sent,
          FormStatuses.DraftSaved
        ].includes(formStatus)
      ) {
        // Not submitted, Draft saved
        return this.notSubmittedAsOfToday;
      } else if (formStatus === FormStatuses.NotSent) {
        const statusDate = this.getStatusDate(
          formStatus,
          updatedDate,
          submittedDate,
          revisionLastSentDate,
          portalAvailabilityInfo
        );

        return this.getDynamicSendingString(statusDate, portalAvailabilityInfo);
      }

      return this.i18n.translate(
        'APPLY:textStatusOnDateDynamic',
        {
          status: this.formStatusMap[formStatus].translated,
          date: this.getStatusDate(
            formStatus,
            updatedDate,
            submittedDate,
            revisionLastSentDate,
            portalAvailabilityInfo
          )
        },
        '__status__ on __date__'
      );
    }

    return '';
  }

  getDynamicStatusStringForListView (
    response: ApplicantFormForUI,
    portalAvailabilityInfo?: PortalFormAvailabilityInfo
  ) {
    if (response) {
      if ((response.formStatus === FormStatuses.NotSent) &&
        ((!portalAvailabilityInfo || !portalAvailabilityInfo.portalFormAvailabilityType) ||
        (portalAvailabilityInfo.portalFormAvailabilityType === AvailabilityOptions.MANUAL ||
        (portalAvailabilityInfo.portalFormAvailabilityType === AvailabilityOptions.AUTO)))) {
        // Not sent
        return this.i18n.translate('GLOBAL:textNotSent', {}, 'Not sent');
      } else if (
        [
          FormStatuses.Sent,
          FormStatuses.DraftSaved
        ].includes(response.formStatus)
      ) {
        // Not submitted, Draft saved
        return this.notSubmittedAsOfToday;
      } else if (response.formStatus === FormStatuses.NotSent) {
        const statusDate = this.getStatusDateForListView(response,  portalAvailabilityInfo);

        return this.getDynamicSendingString(statusDate, portalAvailabilityInfo);
      }

      return this.i18n.translate(
        'APPLY:textStatusOnDateDynamic',
        {
          status: this.formStatusMap[response.formStatus].translated,
          date: this.getStatusDateForListView(response,  portalAvailabilityInfo)
        },
        '__status__ on __date__'
      );
    }

    return '';
  }

  getDynamicSendingString (
    date: string,
    portalAvailabilityInfo: PortalFormAvailabilityInfo
  ) {
    switch (portalAvailabilityInfo.portalFormAvailabilityDateOption) {
      case DateOption.APPLICATION_APPROVAL_DATE:
        if (portalAvailabilityInfo.portalFormAvailabilityDynamicDateApplicationApproval) {
          return this.i18n.translate(
            'APPLY:textSendingDate',
            {
              date
            },
            'Sending on __date__'
          );
        } else {
          return this.i18n.translate(
            'APPLY:textSendingApprovalDate',
            {
              offset: portalAvailabilityInfo.portalFormAvailabilityDateOffset
            },
            'Sending __offset__ days after application approval'
          );
        }
      case DateOption.APPLICATION_SUBMITTED_DATE:
        if (portalAvailabilityInfo.portalFormAvailabilityDynamicDateApplicationSubmission) {
          return this.i18n.translate(
            'APPLY:textSendingDate',
            {
              date
            },
            'Sending on __date__'
          );
        } else {
          return this.i18n.translate(
            'APPLY:textSendingDate',
            {
              date
            },
            'Sending on __date__'
          );
        }
      case DateOption.AWARD_DATE:
        if (portalAvailabilityInfo.portalFormAvailabilityDynamicDateAwardCreation) {
          return this.i18n.translate(
            'APPLY:textSendingDate',
            {
              date
            },
            'Sending on __date__'
          );
        } else {
          return this.i18n.translate(
            'APPLY:textSendingAwardDate',
            {
              offset: portalAvailabilityInfo.portalFormAvailabilityDateOffset
            },
            'Sending __offset__ days after last award date'
          );
        }
      case DateOption.WORKFLOW_LEVEL_ENTRY_DATE:
        if (portalAvailabilityInfo.portalFormAvailabilityDynamicDateWorkflowLevelEntry) {
          return this.i18n.translate(
            'APPLY:textSendingDate',
            {
              date
            },
            'Sending on __date__'
          );
        } else {
          return this.i18n.translate(
            'APPLY:textSendingDate',
            {
              date
            },
            'Sending on __date__'
          );
        }
      default:
        return this.i18n.translate(
          'APPLY:textSendingDate',
          {
            date
          },
          'Sending on __date__'
        );
    }
  }

  setPaymentSubStatusMap () {
    const map: StatusMap = {
      [PaymentSubStatus.RETURNED]: {
        name: 'Returned',
        translated: this.i18n.translate(
          'GLOBAL:textReturned',
          {},
          'Returned'
        )
      },
      [PaymentSubStatus.CANCELLED]: {
        name: 'Canceled',
        translated: this.i18n.translate(
          'GLOBAL:textCanceled',
          {},
          'Canceled'
        )
      },
      [PaymentSubStatus.REJECTED_ADDRES_REQUEST]: {
        name: 'Rejected address request',
        translated: this.i18n.translate(
          'GLOBAL:textRejectedAddressRequest',
          {},
          'Rejected address request'
        )
      },
      [PaymentSubStatus.ALTERNATE_ADDRESS_REQUEST]: {
        name: 'Alternate address request',
        translated: this.i18n.translate(
          'MANAGE:textAlternateAddressRequest',
          {},
          'Alternate address request'
        )
      }
    };
    this.set('paymentSubStatusMap', map);
  }

  prepareStatuses () {
    this.preparePaymentStatuses();
    this.prepareApplicationStatuses();
    this.prepareFormStatuses();
  }

  preparePaymentStatuses () {
    this.getPaymentStatusMap();
    this.setPaymentSubStatusMap();
    this.setPaymentStatusOptions();
    this.setPaymentSubStatusOptions();
  }

  prepareApplicationStatuses () {
    this.getApplicationStatusMap();
    this.setAppStatusOptions();
  }

  prepareFormStatuses () {
    this.getFormStatusMap();
    this.setFormStatusOptions();
  }

  setPaymentStatusOptions () {
    const map = this.paymentStatusMap;
    const statusOptions = Object.keys(map)
      .filter((stat) => +stat !== 0)
      .map((value) => {
        return {
          label: map[value].translated,
          value: +value
        };
      });
    this.set('paymentStatusOptions', statusOptions);
  }

  setPaymentSubStatusOptions () {
    const map = this.paymentSubStatusMap;
    const statusOptions = Object.keys(map)
      .filter((stat) => +stat !== 0)
      .map((value) => {
        return {
          label: map[value].translated,
          value: +value
        };
      });
    this.set('paymentSubStatusOptions', statusOptions);
  }

  setAppStatusOptions () {
    const map = this.applicationStatusMap;
    const adHocOptions = Object.keys(map).map((val) => {
      const label = map[val].translated;
      // Use string values b/c that's what the API returns in Ad Hoc
      let value = '' + val;
      let hidden = false;
      if (value === '0') {
      // Draft is not technically a status, it comes back as null
      // So for Ad hoc, we need it to match on null for draft
        value = null;
        hidden = true;
      }

      return {
        label,
        value,
        hidden
      };
    });
    this.set('adHocAppStatusOptions', adHocOptions);

    // Regular app status options does not use draft and uses the number value
    const appOptions = adHocOptions.filter((opt) => {
      return !!opt.value;
    }).map((opt) => {
      return {
        ...opt,
        value: +opt.value
      };
    });

    this.set('appStatusOptions', appOptions);
  }

  setFormStatusOptions () {
    const map = this.formStatusMap;
    const statusOptions = Object.keys(map).map((val) => {
      const label = map[val].translated;

      return {
        label,
        value: +val
      };
    });

    this.set(
      'formStatusOptions',
      statusOptions
    );
  }

  getFormStatusMap () {
    if (!this.get('form')) {
      this.set('form', FORM_STATUS);
    }
    if (!this.formStatusMap) {
      const statusMap = this.setStatusMap(FORM_STATUS);
      this.set('formStatusMap', statusMap);

      return statusMap;
    }

    return this.get('formStatusMap');
  }

  getPaymentStatusMap () {
    if (!this.get('payment')) {
      this.set('payment', paymentStatuses);
    }
    if (!this.paymentStatusMap) {
      const statusMap = this.setStatusMap(paymentStatuses);
      this.set('paymentStatusMap', statusMap);

      return statusMap;
    }

    return this.get('formStatusMap');
  }

  getApplicationStatusMap () {
    if (!this.get('application')) {
      this.set('application', applicationStatuses);
    }
    if (!this.applicationStatusMap) {
      const statusMap = this.setStatusMap(applicationStatuses, true);
      this.set('applicationStatusMap', statusMap);

      return statusMap;
    }

    return this.get('applicationStatusMap');
  }

  getBatchStatusMap () {
    if (!this.get('batch')) {
      this.set('batch', BATCH_STATUS);
    }
    if (!this.get('batchStatusMap')) {
      const statusMap = this.setStatusMap(BATCH_STATUS);
      this.set('batchStatusMap', statusMap);

      return statusMap;
    }

    return this.get('batchStatusMap');
  }

  setStatusMap (statusOptions: StatusOptions[], includeDraft = false) {
    const statusMap: StatusMap = includeDraft ? {
      0: {
        name: 'Draft',
        translated: this.i18n.translate('common:textDraft'),
        icon: 'pencil',
        iconClass: 'text-primary'
      }
    } : {};
    statusOptions.forEach((opt) => {
      if (opt.name === 'Hold') {
        opt.name = 'On hold';
      }
      statusMap[opt.id] = {
        name: opt.name,
        translated: this.getStatusIconAndTranslation(opt.name).translated,
        icon: this.getStatusIconAndTranslation(opt.name).icon,
        iconClass: this.getStatusIconAndTranslation(opt.name).class
      };
    });

    return statusMap;
  }

  getStatusIconAndTranslation (name: string) {
    switch (name) {
      case 'Awaiting Review':
        return {
          icon: 'ellipsis-h',
          class: 'text-info',
          translated: this.i18n.translate('GLOBAL:lblAwaitingReview', {}, 'Awaiting review')
        };
      case 'In Progress':
        return {
          icon: 'spinner',
          class: 'text-info',
          translated: this.i18n.translate('GLOBAL:lblInProgress', {}, 'In progress')
        };
      case 'Approved':
       return {
         icon: 'check',
         class: 'text-success',
         translated: this.i18n.translate('GLOBAL:textApproved')
       };
      case 'Declined':
        return {
          icon: 'times',
          class: 'text-danger',
          translated: this.i18n.translate('GLOBAL:textDeclined')
        };
      case 'On hold':
        return {
          icon: 'clock',
          class: 'text-warning',
          translated: this.i18n.translate('GLOBAL:textOnHold', {}, 'On hold')
        };
      case 'Not sent':
        return {
          icon: 'times-circle',
          class: 'text-danger',
          translated: this.i18n.translate('GLOBAL:textNotSent', {}, 'Not sent')
        };
      case 'Not submitted':
        return {
          icon: 'exclamation-circle',
          class: 'text-warning',
          translated: this.i18n.translate('GLOBAL:textNotSubmitted', {}, 'Not submitted')
        };
      case 'Draft saved':
        return {
          icon: 'file-edit',
          class: 'text-info',
          translated: this.i18n.translate('GLOBAL:textDraftSaved', {}, 'Draft saved')
        };
      case 'Submitted':
        return {
          icon: 'check-circle',
          class: 'text-success',
          translated: this.i18n.translate('GLOBAL:textSubmitted')
        };
      case 'Revision requested':
        return {
          icon: 'exclamation-circle',
          class: 'text-warning',
          translated: this.i18n.translate('GLOBAL:textRevisionRequested', {}, 'Revision requested')
        };
      case 'Open':
        return {
          icon: 'circle',
          class: 'text-primary',
          translated: this.i18n.translate('GLOBAL:textOpen')
        };
      case 'Reviewed':
        return {
          icon: 'thumbs-up',
          class: 'text-primary',
          translated: this.i18n.translate('GLOBAL:textReviewed')
        };
      case 'Sent to processing - Pending':
        return {
          icon: 'paper-plane',
          class: 'text-primary',
          translated: this.i18n.translate('GLOBAL:textSentToProcessingPending', {}, 'Sent to processing - Pending')
        };
      case 'Funded':
        return {
          icon: 'credit-card',
          class: 'text-success',
          translated: this.i18n.translate('GLOBAL:textFunded')
        };
      case 'Disbursed':
        return {
          icon: 'envelope',
          class: 'text-success',
          translated: this.i18n.translate('GLOBAL:lblDisbursed')
        };
      case 'Complete':
        return {
          icon: 'check-circle',
          class: 'text-success',
          translated: this.i18n.translate('GLOBAL:textComplete')
        };
      case 'Pending':
        return {
          icon: 'circle',
          class: 'text-primary',
          translated: this.i18n.translate('common:lblPending')
        };
      case 'Scheduled':
        return {
          icon: 'calendar-alt',
          class: 'text-primary',
          translated: this.i18n.translate('GLOBAL:textScheduled')
        };
      case 'Processing':
        return {
          icon: 'spinner',
          class: 'text-primary',
          translated: this.i18n.translate('GLOBAL:textProcessing')
        };
      case 'Outstanding':
        return {
          icon: 'envelope',
          class: 'text-primary',
          translated: this.i18n.translate('GLOBAL:textOutstanding')
        };
      case 'Cleared':
        return {
          icon: 'check',
          class: 'text-success',
          translated: this.i18n.translate('GLOBAL:lblCleared')
        };
      case 'Voided':
        return {
          icon: 'ban',
          class: 'text-danger',
          translated: this.i18n.translate('GLOBAL:textVoided')
        };
      case 'Fulfilled':
        return {
          icon: 'check',
          class: 'text-success',
          translated: this.i18n.translate('GLOBAL:textFulfilled')
        };
      case 'Cancelled':
        return {
          icon: 'trash-alt',
          class: 'text-danger',
          translated: this.i18n.translate('GLOBAL:textCanceled')
        };
      case 'ProcessingHold':
        return {
          icon: 'hand-paper',
          class: 'text-warning',
          translated: this.i18n.translate(
            'GLOBAL:textProcessingHold',
            {},
            'Processing - Hold'
          )
        };
    }

    return {};
  }

  getStatusDate (
    formStatus: FormStatuses,
    updatedDate: string,
    submittedDate: string,
    revisionLastSentDate: string,
    portalAvailabilityInfo: PortalFormAvailabilityInfo
  ) {
    return this.getFormStatusDate(
      formStatus,
      updatedDate,
      submittedDate,
      revisionLastSentDate,
      portalAvailabilityInfo
    );
  }

  getStatusDateForListView (
    response: ApplicantFormForUI,
    portalAvailabilityInfo: PortalFormAvailabilityInfo
  ) {
    return this.getFormStatusDateForListView(
      response.formStatus,
      response.statusUpdatedDate,
      response.formSubmittedOn,
      null,
      portalAvailabilityInfo
    );
  }

  getFormStatusDate (
    statusId: number,
    updatedDate: string,
    submittedDate: string,
    revisionLastSent: string,
    portalAvailabilityInfo?: PortalFormAvailabilityInfo
  ) {
    const formStatusMap = this.getFormStatusMap();
    switch (formStatusMap[statusId].name) {
      case 'Not submitted':
      case 'Draft saved':
      default:
        return moment(updatedDate).format('ll');
      case 'Submitted':
        return moment(submittedDate).format('ll');
      case 'Revision requested':
        return moment(revisionLastSent || updatedDate).format('ll');
      case 'Not sent':
        if (portalAvailabilityInfo) {
          if (portalAvailabilityInfo.portalFormAvailabilityType === AvailabilityOptions.DATE) {
            return moment(portalAvailabilityInfo.portalFormAvailabilityDate).format('ll');
          } else {
            switch (portalAvailabilityInfo.portalFormAvailabilityDateOption) {
              case DateOption.APPLICATION_APPROVAL_DATE:
                return moment(portalAvailabilityInfo.portalFormAvailabilityDynamicDateApplicationApproval)
                  .add(portalAvailabilityInfo.portalFormAvailabilityDateOffset, 'days')
                  .format('ll');
              case DateOption.APPLICATION_SUBMITTED_DATE:
                return moment(portalAvailabilityInfo.portalFormAvailabilityDynamicDateApplicationSubmission)
                  .add(portalAvailabilityInfo.portalFormAvailabilityDateOffset, 'days')
                  .format('ll');
              case DateOption.AWARD_DATE:
                return moment(portalAvailabilityInfo.portalFormAvailabilityDynamicDateAwardCreation)
                  .add(portalAvailabilityInfo.portalFormAvailabilityDateOffset, 'days')
                  .format('ll');
              case DateOption.WORKFLOW_LEVEL_ENTRY_DATE:
                return moment(portalAvailabilityInfo.portalFormAvailabilityDynamicDateWorkflowLevelEntry)
                  .add(portalAvailabilityInfo.portalFormAvailabilityDateOffset, 'days')
                  .format('ll');
              default:
                return moment(portalAvailabilityInfo.portalFormAvailabilityDate).format('ll');
            }
          }
        }

        return '';
    }
  }

  getFormStatusDateForListView (
    statusId: number,
    updatedDate: string,
    submittedDate: string,
    revisionLastSent: string,
    portalAvailabilityInfo: PortalFormAvailabilityInfo
  ) {
    switch (statusId) {
      case FormStatuses.DraftSaved:
      default:
        return moment(updatedDate).format('ll');
      case FormStatuses.Submitted:
        return moment(submittedDate).format('ll');
      case FormStatuses.RevisionRequested:
        return moment(revisionLastSent || updatedDate).format('ll');
      case FormStatuses.NotSent:
        if (portalAvailabilityInfo.portalFormAvailabilityType === AvailabilityOptions.DATE) {
          return moment(portalAvailabilityInfo.portalFormAvailabilityDate).format('ll');
        } else {
          switch (portalAvailabilityInfo.portalFormAvailabilityDateOption) {
            case DateOption.APPLICATION_APPROVAL_DATE:
              return moment(portalAvailabilityInfo.portalFormAvailabilityDynamicDateApplicationApproval)
                .add(portalAvailabilityInfo.portalFormAvailabilityDateOffset, 'days')
                .format('ll');
            case DateOption.APPLICATION_SUBMITTED_DATE:
              return moment(portalAvailabilityInfo.portalFormAvailabilityDynamicDateApplicationSubmission)
                .add(portalAvailabilityInfo.portalFormAvailabilityDateOffset, 'days')
                .format('ll');
            case DateOption.AWARD_DATE:
              return moment(portalAvailabilityInfo.portalFormAvailabilityDynamicDateAwardCreation)
                .add(portalAvailabilityInfo.portalFormAvailabilityDateOffset, 'days')
                .format('ll');
            case DateOption.WORKFLOW_LEVEL_ENTRY_DATE:
              return moment(portalAvailabilityInfo.portalFormAvailabilityDynamicDateWorkflowLevelEntry)
                .add(portalAvailabilityInfo.portalFormAvailabilityDateOffset, 'days')
                .format('ll');
            default:
              return moment(portalAvailabilityInfo.portalFormAvailabilityDate).format('ll');
          }
        }
    }
  }

  setArchiveReasonCodes () {
    if (!this.get('archiveReasonCodes')) {
      const codes = archiveReasonCodes;
      const map: SimpleStringMap<string> = {};
      const reasonCodes = codes.map((code: ReasonCode) => {
        const label = this.getReasonDisplay(code.name);
        map[code.code] = label;

        return {
          label,
          value: code.code
        };
      });
      this.set('archiveReasonCodes', reasonCodes);
      this.set('archiveReasonCodeMap', map);
    }
  }

  getReasonDisplay (name: string) {
    switch (name) {
      case 'Completed':
        return this.i18n.translate('GLOBAL:textCompleted');
      case 'Terminated':
        return this.i18n.translate('GLOBAL:textTerminated');
      case 'Declined':
        return this.i18n.translate('GLOBAL:textDeclined');
      case 'Duplicate':
        return this.i18n.translate('GLOBAL:textDuplicate');
      case 'Program Archived':
        return this.i18n.translate('GLOBAL:textProgramArchived', {}, 'Program archived');
      case 'Other':
        return this.i18n.translate('common:textOther');
      default:
        return '';
    }
  }
  getCancelApplicationTypeaheadOptions (): TypeaheadSelectOption[] {
    return [{
      value: CancelReasons.FundingNoLongerRequired,
      label: this.i18n.translate('common:textFundingNoLongerRequired', {}, 'Funding no longer required')
    }, {
      value: CancelReasons.ProjectOrProgramCancelledOrDiscontinued,
      label: this.i18n.translate('common:textProjectOrProgramCanceled', {}, 'Project or program is canceled or discontinued')
    }, {
      value: CancelReasons.DuplicateApplication,
      label: this.i18n.translate('common:textDuplicateApplication', {}, 'Duplicate application')
    }, {
      value: CancelReasons.ChangeInCircumstances,
      label: this.i18n.translate('common:textChangeInCircumstance,s', {}, 'Change in circumstances')
    }, {
      value: CancelReasons.NoLongerEligibleForFunding,
      label: this.i18n.translate('common:textNoLongerEligibleForFunding', {}, 'No longer eligible for funding')
    }, {
      value: CancelReasons.Other,
      label: this.i18n.translate('common:textOther', {}, 'Other')
    }];
  }

  getCancelationReasonMap () {
    return {
      [CancelReasons.FundingNoLongerRequired]: this.i18n.translate(
        'common:textFundingNoLongerRequired',
        {},
        'Funding no longer required'
      ),
      [CancelReasons.ProjectOrProgramCancelledOrDiscontinued]: this.i18n.translate(
        'common:textProjectOrProgramCanceled',
        {},
        'Project or program is canceled or discontinued'
      ),
      [CancelReasons.DuplicateApplication]: this.i18n.translate(
        'common:textDuplicateApplication',
        {},
        'Duplicate application'
      ),
      [CancelReasons.ChangeInCircumstances]: this.i18n.translate(
        'common:textChangeInCircumstance,s',
        {},
        'Change in circumstances'
      ),
      [CancelReasons.NoLongerEligibleForFunding]: this.i18n.translate(
        'common:textNoLongerEligibleForFunding',
        {},
        'No longer eligible for funding'
      ),
      [CancelReasons.Other]: this.i18n.translate(
        'common:textOther',
        {},
        'Other'
      )
    };
  }

  getApplicationStatusTypeaheadOptions (): TypeaheadSelectOption[] {
    return [{
      value: ALL_SKIP_FILTER,
      label: this.i18n.translate('common:lblAllCap')
    }, {
      value: DRAFT,
      label: this.i18n.translate('common:textDraft')
    }, {
      value: ApplicationStatuses.AwaitingReview,
      label: this.i18n.translate('GLOBAL:lblAwaitingReview', {}, 'Awaiting review')
    }, {
      value: ApplicationStatuses.InProgress,
      label: this.i18n.translate('GLOBAL:lblInProgress', {}, 'In progress')
    }, {
      value: ApplicationStatuses.Approved,
      label: this.i18n.translate('GLOBAL:textApproved')
    }, {
      value: ApplicationStatuses.Declined,
      label: this.i18n.translate('GLOBAL:textDeclined')
    }, {
      value: ApplicationStatuses.Hold,
      label: this.i18n.translate('GLOBAL:textOnHold', {}, 'On hold')
    }];
  }

  getAppFilterStatusSelects (
    isNomination = false,
    skipAwardedAndPaid = false
  ) {
    const statusOptions = {
      selectOptions: [{
        value: ApplicationStatuses.Draft,
        customValue: true,
        customColumn: 'isDraft',
        label: this.i18n.translate('common:textDraft')
      }, {
        value: ApplicationStatuses.AwaitingReview,
        label: this.i18n.translate('GLOBAL:lblAwaitingReview', {}, 'Awaiting review')
      }, {
        value: ApplicationStatuses.InProgress,
        label: this.i18n.translate('GLOBAL:lblInProgress', {}, 'In progress')
      }, {
        value: ApplicationStatuses.Approved,
        label: this.i18n.translate('GLOBAL:textApproved')
      }, {
        value: ApplicationStatuses.Declined,
        label: this.i18n.translate('GLOBAL:textDeclined')
      }, {
        value: ApplicationStatuses.Canceled,
        label: this.i18n.translate('GLOBAL:textCanceled')
      }, {
        value: ApplicationStatuses.Hold,
        label: this.i18n.translate('GLOBAL:textOnHold', {}, 'On hold')
      }, !isNomination && !skipAwardedAndPaid ? {
        value: 'Not awarded',
        customValue: false,
        customColumn: 'hasAwards',
        label: this.i18n.translate(
          'GLOBAL:textNotAwarded',
          {},
          'Not awarded'
        )
      } : null, !isNomination && !skipAwardedAndPaid ? {
        value: 'Not paid',
        customValue: false,
        customColumn: 'hasPayments',
        label: this.i18n.translate(
          'GLOBAL:textNotPaid',
          {},
          'Not paid'
        )
      } : null].filter((item) => !!item),
      filterObjectName: this.i18n.translate(
        'common:hdrStatus', {}
      ).toLowerCase(),
      filterObjectNamePlural: this.i18n.translate(
        'common:hdrStatuses', {}
      ).toLowerCase()
    };
    const activeStatusOptions = {
      selectOptions: [{
        label: this.i18n.translate(
          isNomination ?
            'common:textAllNominations' :
            'common:textAllApplications',
          {},
          isNomination ? 'All nominations' : 'All applications'
        ),
        value: ALL_SKIP_FILTER
      },
      {
        label: this.i18n.translate(
          isNomination ?
            'common:textActiveNominations' :
            'common:textActiveApplications',
          {},
          isNomination ? 'Active nominations' : 'Active applications'
        ),
        value: false
      },
      {
        label: this.i18n.translate(
          isNomination ?
            'common:textArchivedNominations' :
            'common:textArchivedApplications',
          {},
          isNomination ? 'Archived nominations' : 'Archived applications'
        ),
        value: true
      }]
    };

    return {
      statusOptions,
      activeStatusOptions
    };
  }

  reset () {
    this.set('applicationStatusMap', undefined);
    this.set('formStatusMap', undefined);
    this.set('paymentStatusMap',  undefined);
    this.prepareStatuses();
  }
}