import { Injectable } from '@angular/core';
import { ApplicationFormService } from '@features/application-forms/services/application-forms.service';
import { FormManagerResources } from '@features/application-manager/resources/form-manager.resources';
import { FormAudience, FormManagerRecordForUi, FormManagerRecordFromApi, ViewFormResponse } from '@features/configure-forms/form.typing';
import { APIResultData, FilterHelpersService, FilterModalTypes, PaginationOptions } from '@yourcause/common';

@Injectable({ providedIn: 'root' })
export class FormManagerService {

  constructor (
    private formManagerResources: FormManagerResources,
    private applicationFormService: ApplicationFormService,
    private filterHelperService: FilterHelpersService
  ) { }

  /**
   * Gets the records for form manager table
   *
   * @param options: pagination options
   * @returns records for form manager table
   */
  async getRecordsForFormManager (
    options: PaginationOptions<FormManagerRecordFromApi>
  ): Promise<APIResultData<FormManagerRecordFromApi>> {
   const {
     formattedOptions,
     isManager,
     startDateFilter,
     endDateFilter
    } = this.formatPaginationOptionsForFormManager(options);

    return this.formManagerResources.getFormManagerRecords(
      formattedOptions,
      isManager ? FormAudience.MANAGER : FormAudience.APPLICANT,
      startDateFilter,
      endDateFilter
    );
  }

  /**
   * Get and adapt form manager record for view
   *
   * @param row: form manager row
   * @param audience: form audience
   * @returns the adapted record
   */
  async getFormFromFormManagerRecord (
    row: FormManagerRecordForUi,
    audience: FormAudience
  ): Promise<ViewFormResponse> {
    if (audience === FormAudience.APPLICANT) {
      const forms = await this.applicationFormService.getApplicantFormsForApplication(
        row.applicationId,
        row.applicationStatus
      );
      const form =  forms.find((_form) => {
        return _form.applicationFormId === row.applicationFormId;
      });

      return this.applicationFormService.adaptApplicantFormToViewFormResponse(form);
    } else {
      const forms = await this.applicationFormService.getAllApplicationForms(
        row.applicationId,
        row.isApplicationInClientUserWorkflowLevel,
        row.applicationStatus
      );
      const form = forms.find((f) => {
        return f.formId === row.formId;
      });
      if (form) {
        const foundResponse = form.responses.find((response) => {
          return response.applicationFormId === row.applicationFormId;
        });
        if (foundResponse) {
          return this.applicationFormService.adaptFormResponseToViewFormResponse(
            foundResponse,
            form.formId,
            form.formType,
            form.name,
            form.comments
          );
        }
      }
    }

    return null;
  }

   /**
    * Format the pagination options for form manager table
    *
    * @param options: pagination options to format
    * @returns formatted pagination options
    */
  formatPaginationOptionsForFormManager (
    options: PaginationOptions<FormManagerRecordForUi>
  ): {
    isManager: boolean;
    formattedOptions: PaginationOptions<FormManagerRecordForUi>;
    startDateFilter: string;
    endDateFilter: string;
  } {
    let isManager = true;
    const managerFormFilter = options.filterColumns.find((column) => {
      return column.columnName === 'formAudience';
    });
    if (managerFormFilter) {
      isManager = managerFormFilter.filters[0]?.filterValue === FormAudience.MANAGER;
    }
    let startDateFilter;
    let endDateFilter;
    const filterColumns = options.filterColumns.filter((column) => {
      if (column.columnName === 'relativeDate') {
        const filterType = column.filters[0].filterType as FilterModalTypes;
        const dates = this.filterHelperService.getClientSideRelativeDates(
          filterType
        );
        if (dates) {
          startDateFilter = dates[0];
          endDateFilter = dates[1];
        }

        return false;
      }

      return column.columnName !== 'formAudience';
    });

    const formattedOptions = {
      ...options,
      filterColumns
    };

    return {
      isManager,
      formattedOptions,
      startDateFilter,
      endDateFilter
    };
  }


  /**
   * Returns whether forms pass revision request criteria
   *
   * @param forms: forms to check
   * @param isReminder: is for reminder?
   * @returns if revision request can be performed
   */
  formsPassRevisionRequestCriteria (
    forms: FormManagerRecordForUi[],
    isReminder = false
  ) {
    return forms.every((form) => {
      const formsHaveSameProgram = form.grantProgramId === forms[0].grantProgramId;
      const formsAreTheSame = form.formId === forms[0].formId;
      const formsPassReminderCheck = isReminder ? !!form.formRevisionId : true;
      const formsMeetRevisionRequestCriteria = this.applicationFormService.checkRevisionRequestCriteria(
        form.formAudience,
        form.applicationStatus,
        form.applicationFormStatusId,
        isReminder
      );

      return formsHaveSameProgram &&
        formsAreTheSame &&
        !form.notSubmitted &&
        formsPassReminderCheck &&
        formsMeetRevisionRequestCriteria;
    });
  }
}