import { Injectable } from '@angular/core';
import { ReferenceFieldsUI } from '@core/typings/ui/reference-fields.typing';
import { FormAudience, FormTypes } from '@features/configure-forms/form.typing';
import { FormBuilderService } from '@features/formio/form-builder/services/form-builder/form-builder.service';
import { ReferenceFieldsService } from '@features/reference-fields/services/reference-fields.service';
import { AdHocReportingService } from '@features/reporting/services/ad-hoc-reporting.service';
import { ArrayHelpersService } from '@yourcause/common';
import { I18nService } from '@yourcause/common/i18n';

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

  constructor (
    private referenceFieldsService: ReferenceFieldsService,
    private formBuilderService: FormBuilderService,
    private i18n: I18nService,
    private arrayHelper: ArrayHelpersService,
    private adHocReportingService: AdHocReportingService
  ) { }

  getQuickAddGroupsForApplicant (
    componentBuckets: ReferenceFieldsUI.QuickAddComponentsForAccordion
  ) {
    return componentBuckets.filter((bucketGroup) => {
      return bucketGroup.type === ReferenceFieldsUI.QuickAddFieldType.APPLICANT;
    });
  };

  getQuickAddGroupsForManager (
    componentBuckets: ReferenceFieldsUI.QuickAddComponentsForAccordion
  ) {
    return componentBuckets.filter((bucketGroup) => {
      return bucketGroup.type === ReferenceFieldsUI.QuickAddFieldType.MANAGER;
    });
  };

  findStandardComponentsForQuickAdd (
    componentBuckets: ReferenceFieldsUI.QuickAddComponentsForAccordion
  ) {
    return componentBuckets.find((compBucket) => compBucket.type === ReferenceFieldsUI.QuickAddFieldType.STANDARD) as ReferenceFieldsUI.StandardQuickAddComponentsForAccordion;
  }

  getReportGroupsForQuickAdd (
    componentBuckets: ReferenceFieldsUI.QuickAddComponentsForAccordion
  ) {
    return componentBuckets.find((compBucket) => compBucket.type === ReferenceFieldsUI.QuickAddFieldType.REPORT) as ReferenceFieldsUI.StandardQuickAddComponentsForAccordion;
  }

  getAllComponentsFlatListForQuickAdd (
    componentBuckets: ReferenceFieldsUI.QuickAddComponentsForAccordion
  ) {
    return componentBuckets.find((compBucket) => compBucket.type === ReferenceFieldsUI.QuickAddFieldType.ALL).components as ReferenceFieldsUI.QuickAddField[];
  }

  prepFieldsForQuickAddModal (
    fieldAudience: FormAudience,
    formAudience: FormAudience,
    fieldsOnForm: ReferenceFieldsUI.QuickAddField[],
    componentsToAdd: ReferenceFieldsUI.QuickAddField[]
  ): { name: string; components: ReferenceFieldsUI.QuickAddField[] }[] {
    const referenceFieldTypeList = ReferenceFieldsUI.ReferenceFieldTypeList;

    return referenceFieldTypeList.reduce((acc, curr) => {
      const typesToFilterOut = [
        ReferenceFieldsUI.ReferenceFieldTypes.DataPoint,
        ReferenceFieldsUI.ReferenceFieldTypes.ExternalAPI
      ];
      if (!typesToFilterOut.includes(curr as ReferenceFieldsUI.ReferenceFieldTypes)) {
        const fields = this.referenceFieldsService.getFormFieldsByTypeAndAudience(
          curr as ReferenceFieldsUI.ReferenceFieldTypes,
          fieldAudience,
          formAudience,
          false
        );

        const filteredFields = fields.filter((field) => {
          return !field.isTableField &&
            !fieldsOnForm.some((fieldOnForm) => {
              if ('referenceFieldId' in fieldOnForm) {
                return fieldOnForm.referenceFieldId === field.referenceFieldId;
              } else {
                return false;
              }
            }) && !componentsToAdd.some((comp) => {
              if ('referenceFieldId' in comp) {
                return comp.referenceFieldId === field.referenceFieldId;
              } else {
                return false;
              }
            });
        });
        const translatedType = this.referenceFieldsService.getFieldTypeTranslatedWithIcon(curr);

        return [
          ...acc,
          {
            name: translatedType.label,
            components: filteredFields
          }
        ];
      } else {
        return [
          ...acc
        ];
      }
    }, []);
  }

  getFieldsForQuickAddModal (
    formAudience: FormAudience,
    fieldsOnForm: ReferenceFieldsUI.QuickAddField[],
    formType: FormTypes,
    componentsToAdd: ReferenceFieldsUI.QuickAddField[]
  ): ReferenceFieldsUI.QuickAddComponentsForAccordion {
    const applicantFields = this.prepFieldsForQuickAddModal(
      FormAudience.APPLICANT,
      formAudience,
      fieldsOnForm,
      componentsToAdd
    );
    const sortedApplicantFields = this.arrayHelper.sort(applicantFields, 'name');

    const managerFields = this.prepFieldsForQuickAddModal(
      FormAudience.MANAGER,
      formAudience,
      fieldsOnForm,
      componentsToAdd
    );
    const sortedManagerFields = this.arrayHelper.sort(managerFields, 'name');

    const standardComponents = this.formBuilderService.getStandardComponents(
      formType,
      formAudience,
      componentsToAdd.map((comp) => comp.type),
      ''
    ).filter((comp) => {
      return !comp.hidden;
    });

    const applicantAndManagerFields = [
      ...sortedApplicantFields,
      ...sortedManagerFields
    ];
    const reportFieldBuckets = this.adHocReportingService.getReportfieldBuckets();
    const reportFields = reportFieldBuckets.reduce((acc, curr) => {
      const columns = this.adHocReportingService.getReportFieldColumnsByBucket(reportFieldBuckets, curr.property);

      const options = columns.map((column) => {
        const columnName = this.i18n.translate(column.definition.i18nKey, {}, column.definition.display);
        const label = columnName + ' - (' + column.definition.parentBucketName + ')';

        return {
          key: column.definition.column,
          label,
          name: label,
          type: 'reportField',
          isReportField: true,
          showRequired: false,
          reportFieldConfigType: {
            reportFieldObject: column.definition.parentBucket,
            reportFieldDisplay: column.definition.column
          }
        };
      });

      return [
        ...acc,
        ...options
      ];
    }, []).filter((field) => {
      return !componentsToAdd.find((compToAdd) => compToAdd.key === field.key);
    });
    const applicantAndGMFieldsFlatList = applicantAndManagerFields.reduce((acc, curr) => {
      return [
        ...acc,
        ...curr.components
      ];
    }, []);
    const accordionGroupsWithComps = [
      {
        name: this.i18n.translate(
          'common:hdrStandardComponents',
          {},
          'Standard components'
        ),
        type: ReferenceFieldsUI.QuickAddFieldType.STANDARD,
        components: standardComponents
      },
      {
        name: this.i18n.translate(
          'common:hdrApplicantFields',
          {},
          'Applicant fields'
        ),
        type: ReferenceFieldsUI.QuickAddFieldType.APPLICANT,
        components: sortedApplicantFields
      },
      {
        name: this.i18n.translate(
          'common:hdrManagerFields',
          {},
          'Manager fields'
        ),
        type: ReferenceFieldsUI.QuickAddFieldType.MANAGER,
        components: sortedManagerFields
      },
      {
        name: this.i18n.translate(
          'common:hdrReportFields',
          {},
          'Report fields'
        ),
        type: ReferenceFieldsUI.QuickAddFieldType.REPORT,
        components: reportFields
      },
      {
        name: 'all',
        type: ReferenceFieldsUI.QuickAddFieldType.ALL,
        components: [
          ...applicantAndGMFieldsFlatList,
          ...standardComponents,
          ...reportFields
        ]
      }
    ];

    return accordionGroupsWithComps as any;
  }


}