import { Injectable } from '@angular/core';
import { GCMockModule } from '@core/mocks/gc-module.mock';
import { SYSTEM_TAGS_SERVICE_MOCK } from '@core/mocks/system-tags.service.mock';
import { AdHocReportingAPI } from '@core/typings/api/ad-hoc-reporting.typing';
import { ReferenceFieldAPI } from '@core/typings/api/reference-fields.typing';
import { ApplicationStatuses } from '@core/typings/status.typing';
import { AdHocReportingUI } from '@core/typings/ui/ad-hoc-reporting.typing';
import { ReferenceFieldsUI } from '@core/typings/ui/reference-fields.typing';
import { FormAudience, FormDefinitionComponent, FormDefinitionForUi, FormTypes, ReportFieldDataOptions } from '@features/configure-forms/form.typing';
import { StandardReportTemplate } from '@features/platform-admin/standard-product-configuration/standard-product-configuration.typing';
import { AdvancedFilterGroup, ArrayHelpersService, FilterModalTypes, FilterOptions, OneOfFilterOption, SimpleStringMap, SwitchState } from '@yourcause/common';
import { BeforeEach, Spec, TestCase } from '@yourcause/test-decorators';
import { DescribeAngularService } from '@yourcause/test-decorators/angular';
import { expect } from 'chai';
import { ManageReportFormData } from '../pages/manage-ad-hoc-report-modal/manage-ad-hoc-report-modal.component';
import { AdHocReportingDefinitions } from './ad-hoc-reporting-definitions.service';
import { AdHocReportingService } from './ad-hoc-reporting.service';

@Injectable({ providedIn: 'root' })
@DescribeAngularService(AdHocReportingService, {
  imports: [
    GCMockModule
  ],
  providers: [SYSTEM_TAGS_SERVICE_MOCK]
})
export class AdHocReportingServiceSpec implements Spec<AdHocReportingServiceSpec, AdHocReportingService> {
  reportId = 1;
  formId = 3;
  userSavedReport: AdHocReportingAPI.UserSavedAdHocReport = {
    id: this.reportId,
    name: 'App Report',
    description: 'description',
    isUserOwnedReport: false,
    reportModelType: AdHocReportingAPI.AdHocReportModelType.Application,
    userSavedReportColumns: [],
    clientId: null,
    forms: [{
      id: this.formId,
      currentRevisionId: 2,
      name: '',
      description: '',
      formType: FormTypes.REQUEST,
      formDefinition: null
    }],
    reportOwnerClientUserId: null,
    accessType: AdHocReportingAPI.AdHocReportAccessType.VIEW,
    primaryFormId: 1,
    advancedFilterColumns: [],
    useLogicalOperatorAnd: true,
    referenceFieldTableId: null,
    referenceFieldTableKey: '',
    standardComponentIsPublished: false,
    reportType: AdHocReportingAPI.AdHocReportType.AdHoc
  };
  mockReportDetails: AdHocReportingAPI.UserSavedReportDetail = {
    description: 'description',
    name: 'name',
    users: [],
    schedule: null,
    standardComponentIsPublished: true,
    forms: [{
      id: this.formId,
      currentRevisionId: 2,
      name: '',
      description: '',
      formType: FormTypes.REQUEST,
      formDefinition: null
    }],
    reportModelType: 1,
    primaryFormId: 1,
    reportType: AdHocReportingAPI.AdHocReportType.AdHoc,
    id: 1,
    isUserOwnedReport: false,
    referenceFieldTableId: null,
    referenceFieldTableKey: '',
    userSavedReportColumns: [{
      id: 5921,
      userSavedFilterColumns: [{
        id: 756,
        filterType: 'eq',
        filterValue: 63990
      }],
      columnName: 'application.id',
      sortType: 1,
      sortPriority: 18,
      isVisible: true,
      displayName: '',
      isChartGroupingColumn: false,
      isChartAggregate: false,
      chartAggregateType: null,
      isChartSubGroupingColumn: false,
      referenceFieldId: null
    }, {
      id: 5922,
      userSavedFilterColumns: [],
      columnName: 'formData.1.textField',
      sortType: 1,
      sortPriority: 15,
      isVisible: true,
      displayName: '',
      isChartGroupingColumn: false,
      isChartAggregate: false,
      chartAggregateType: null,
      isChartSubGroupingColumn: false,
      referenceFieldId: null
    }],
    advancedFilterColumns: [],
    useLogicalOperatorAnd: false,
    clientId: null,
    reportOwnerClientUserId: null,
    accessType: 1
  };
  appStatusDef: AdHocReportingUI.ColumnDefinition = {
    display: 'Application status',
    i18nKey: 'GLOBAL:lblApplicationStatus',
    type: 'multi-list',
    filterOptions: [{
      label: 'Approved',
      value: ApplicationStatuses.Approved
    }],
    format: 'label',
    column: 'applicationStatus',
    supportsGrouping: true
  };
  categoryId = 1;
  categoryId2 = 2;
  categoryIdName = '1st Category';
  categoryIdName2 = '2nd Category';
  textFieldKey = 'textKey';
  textFieldColumn = `category.${this.categoryId}.${this.textFieldKey}`;
  textFieldId = 13;
  picklistKey = 'picklistKey';
  picklistColumn = `category.${this.categoryId2}.${this.picklistKey}`;
  picklistId = 15;
  tableId = 16;
  tableKey = 'table';
  allColumns: AdHocReportingUI.ColumnImplementation[] = [{
    sortType: 1,
    visibleInReport: true,
    filterColumn: {
      columnName: this.textFieldColumn,
      filters: []
    },
    columnNameOverride: '',
    definition: {
      column: this.textFieldKey,
      parentBucket: `category.${this.categoryId}`,
      parentBucketName: this.categoryIdName,
      type: 'text',
      format: null,
      display: 'What kind of disaster was it?',
      i18nKey: null,
      isReferenceField: true
    }
  }, {
    sortType: 1,
    visibleInReport: true,
    filterColumn: {
      columnName: 'grantProgram.name',
      filters: []
    },
    columnNameOverride: '',
    definition: {
      column: 'name',
      parentBucket: 'grantProgram',
      parentBucketName: 'Grant Program',
      type: 'text',
      format: null,
      display: 'Grant Program Name',
      i18nKey: null,
      isReferenceField: undefined,
      supportsGrouping: true
    }
  }, {
    sortType: 1,
    visibleInReport: true,
    filterColumn: {
      columnName: this.textFieldColumn,
      filters: []
    },
    columnNameOverride: '',
    definition: {
      column: 'applicationStatus',
      parentBucket: 'application',
      parentBucketName: 'Application',
      type: 'text',
      format: null,
      display: 'Application Status',
      i18nKey: null,
      isReferenceField: undefined,
      supportsGrouping: true
    }
  }, {
    sortType: 1,
    visibleInReport: true,
    filterColumn: {
      columnName: '',
      filters: []
    },
    columnNameOverride: '',
    definition: {
      column: this.picklistKey,
      parentBucket: `category.${this.categoryId2}`,
      parentBucketName: this.categoryIdName2,
      type: 'text',
      display: 'Picklist',
      i18nKey: null,
      isReferenceField: true
    }
  }];
  formComponentMap = {
    [1]: [{
      key: this.textFieldKey,
      type: `referenceFields-${this.textFieldKey}`,
      label: 'Text'
    }, {
      key: this.picklistKey,
      type: `referenceFields-${this.picklistKey}`,
      label: 'Picklist'
    }]
  };
  referenceFields: ReferenceFieldAPI.ReferenceFieldDisplayModel[] = [{
    aggregateType: null,
    customDataTableGuid: '',
    name: 'Text',
    description: '',
    type: ReferenceFieldsUI.ReferenceFieldTypes.TextField,
    key: this.textFieldKey,
    supportsMultiple: false,
    categoryId: this.categoryId,
    formAudience: FormAudience.APPLICANT,
    referenceFieldId: this.textFieldId,
    formCount: 1,
    usedOnReports: false,
    createdBy: '',
    createDate: '',
    updatedBy: '',
    updateDate: '',
    parentReferenceFieldId: null,
    isEncrypted: false,
    isMasked: false,
    isSingleResponse: true,
    isTableField: false,
    tableAllowsImport: false,
    aggregateTableReferenceFieldId: null,
    referenceFieldTableId: null,
    standardComponentIsPublished: true,
    isStandardProductField: false,
    subsetCollectionType: null
  }, {
    aggregateType: null,
    customDataTableGuid: 'guid',
    name: 'Picklist',
    description: '',
    type: ReferenceFieldsUI.ReferenceFieldTypes.CustomDataTable,
    key: this.picklistKey,
    supportsMultiple: false,
    categoryId: this.categoryId2,
    formAudience: FormAudience.APPLICANT,
    referenceFieldId: this.picklistId,
    formCount: 1,
    usedOnReports: false,
    createdBy: '',
    createDate: '',
    updatedBy: '',
    updateDate: '',
    parentReferenceFieldId: null,
    isEncrypted: false,
    isMasked: false,
    isSingleResponse: true,
    isTableField: false,
    tableAllowsImport: false,
    aggregateTableReferenceFieldId: null,
    referenceFieldTableId: null,
    standardComponentIsPublished: true,
    isStandardProductField: false,
    subsetCollectionType: null
  }, {
    aggregateType: null,
    customDataTableGuid: '',
    name: 'Table',
    description: '',
    type: ReferenceFieldsUI.ReferenceFieldTypes.Table,
    key: this.tableKey,
    supportsMultiple: false,
    categoryId: this.categoryId2,
    formAudience: FormAudience.APPLICANT,
    referenceFieldId: this.tableId,
    formCount: 1,
    usedOnReports: false,
    createdBy: '',
    createDate: '',
    updatedBy: '',
    updateDate: '',
    parentReferenceFieldId: null,
    isEncrypted: false,
    isMasked: false,
    isSingleResponse: true,
    isTableField: false,
    tableAllowsImport: false,
    aggregateTableReferenceFieldId: null,
    referenceFieldTableId: null,
    standardComponentIsPublished: true,
    isStandardProductField: false,
    subsetCollectionType: null
  }];
  categoryNameMap: SimpleStringMap<string> = {
    ['' + this.categoryId]: this.categoryIdName,
    ['' + this.categoryId2]: this.categoryIdName2
  };
  standardReportId = 3;
  standardReportTemplate: StandardReportTemplate = {
    id: this.standardReportId,
    name: 'Application Report',
    description: '',
    isUserOwnedReport: true,
    reportModelType: AdHocReportingAPI.AdHocReportModelType.Application,
    reportType: AdHocReportingAPI.AdHocReportType.AdHoc,
    userSavedReportColumns: [],
    createdDate: '',
    updatedDate: '',
    clientId: 5,
    forms: [],
    reportOwnerClientUserId: 3,
    accessType: AdHocReportingAPI.AdHocReportAccessType.MANAGE,
    primaryFormId: null,
    advancedFilterColumns: [],
    useLogicalOperatorAnd: true,
    referenceFieldTableId: null,
    referenceFieldTableKey: '',
    standardComponentIsPublished: true,
    isStandardReportTemplate: true,
    isMyReport: false
  };

  constructor (
    private adHocReportingDefinitions: AdHocReportingDefinitions,
    private arrayHelper: ArrayHelpersService
  ) { }

  @BeforeEach()
  async mock (service: AdHocReportingService) {
    service['adHocReportingDefinitions'] = this.adHocReportingDefinitions;
    service['set']('formComponentMap', this.formComponentMap);
    service['reportingResources'].getReportById = async () => {
      return this.userSavedReport;
    };
    service['reportingResources'].getSharedUsersForReport = async () => {
      return [];
    };
    service['reportingResources'].getScheduleForReport = async () => {
      return {} as AdHocReportingAPI.ReportScheduleFromApi;
    };
    service['referenceFieldService'].setAllReferenceFields(this.referenceFields);
    service['referenceFieldService']['set']('categoryNameMap', this.categoryNameMap);
    service['referenceFieldService']['customDataTablesService']['set']('customDataTableOptionsMap', {
      guid: []
    });
    service['adHocReportingDefinitions']['systemTagsService']['arrayHelper'] = this.arrayHelper;
    service['adHocReportingDefinitions']['systemTagsService']['set']('summaries', []);
    service['policyService']['system']['canManageBudgets'] = () => {
      return true;
    };
    service['policyService']['insights']['canViewBudgets'] = () => {
      return true;
    };
    service['policyService']['system']['canManageFundingSources'] = () => {
      return true;
    };
    service['policyService']['insights']['canViewFundingSources'] = () => {
      return true;
    };
    service['formsResolver']['formService']['formResources'].getForms = async () => {
      return [];
    };
    service['referenceFieldService']['referenceFieldsResources'].getTableFields = async () => {
      return [];
    };
    service['reportingResources'].getFormComponents = async () => {
      return [];
    };
    await service.prepareAdHocReportDetail(
      this.reportId
    );
  }

  @TestCase('should be able to set report details')
  async setReportDetailsTest (service: AdHocReportingService) {
    await service.fetchReportById(this.reportId);
    const testReportInfo = service.getReportById(this.reportId);
    // test parts of report instead of comparing whole object
    expect(testReportInfo.reportDescription).to.be.equal(
      this.userSavedReport.description
    );
    expect(testReportInfo.object).to.be.equal('application');
    expect(testReportInfo.forms).to.deep.equal(
      this.userSavedReport.forms.map((form) => form.id)
    );
    expect(testReportInfo.primaryFormId).to.be.equal(
      this.userSavedReport.primaryFormId
    );
  }

  @TestCase('should be able to get report columns when form component removed')
  getReportColumnsWhenFormCompRemoved (service: AdHocReportingService) {
    // 2 columns were saved in report
    // but the form data component column is not found because it was deleted from the form.
    // It should handle this by filtering it out.
    const response = service.getReportColumnsById(
      this.reportId,
      this.mockReportDetails
    );
    expect(response.length).to.be.equal(1);
    expect(response[0].definition.column).to.be.equal('id');
  }

  @TestCase('should be able to get report columns when form removed but column still exists')
  getReportColumnsWhenFormRemoved (service: AdHocReportingService) {
    // Form was added to report with a column, then the form was removed from report
    // It should handle this by filtering out this invalid column.
    const response = service.getReportColumnsById(
      this.reportId,
      {
        ...this.mockReportDetails,
        forms: []
      }
    );
    expect(response.length).to.be.equal(1);
    expect(response[0].definition.column).to.be.equal('id');
  }

  @TestCase('should be able to get buckets')
  getBuckets (service: AdHocReportingService) {
    const buckets = service.getBuckets(
      'application',
      [],
      [{
        definition: this.appStatusDef,
        sortType: AdHocReportingAPI.SortTypes.NoSort,
        filterColumn: null,
        visibleInReport: true,
        columnNameOverride: ''
      }]
    );
    const applicationBucket = buckets.find((bucket) => {
      return bucket.property === 'application';
    });
    expect(applicationBucket).to.not.be.undefined;
    const statusCol = applicationBucket.columns.find((col) => {
      return col.definition.column === 'application.applicationStatus';
    });
    expect(statusCol).to.be.undefined;
  }

  @TestCase('should be able to get endpoint by object name')
  getEndpointByObjectName (service: AdHocReportingService) {
    let endpoint = service.getEndpointByObjectName('application', 'editEndpoint');
    expect(endpoint).to.be.equal('applications');
    endpoint = service.getEndpointByObjectName('customForm', 'readOnlyEndpoint');
    expect(endpoint).to.be.equal('ApplicationForm');
  }

  @TestCase('should be able to get formIds for API')
  getFormIdsForAPI (service: AdHocReportingService) {
    const formIds = [1, 2];
    const primaryFormId = 3;
    const ids = service.getFormIdsForAPI(formIds, primaryFormId);
    expect(ids.length).to.be.equal(3);
    expect(ids.includes(primaryFormId)).to.be.true;
  }

  @TestCase('should be able to extract reference field ids')
  extractRefFieldIds (service: AdHocReportingService) {
    const ids = service.extractRefFieldIds(
      this.allColumns
    );
    expect(ids.length).to.be.equal(2);
    expect(ids[0]).to.be.equal(this.textFieldId);
  }

  @TestCase('should be able to set application token groups')
  setApplicationTokenGroups (service: AdHocReportingService) {
    service.setApplicationTokenGroups(
      AdHocReportingUI.Usage.TOKENS
    );
    const foundCat = service.applicationTokenGroups.find((group) => {
      return group.groupDisplay === this.categoryIdName;
    });
    expect(foundCat).to.not.be.undefined;
  }

  // Advanced filtering

  @TestCase('should be able to map a simple filter group to pagination filters')
  testShouldMapSimpleFilterGroupToPagination (
    service: AdHocReportingService
  ) {
    const basicFilterGroups: AdvancedFilterGroup[] = [{
      useAnd: SwitchState.Toggled,
      filters: [{
        column: {
          label: 'label',
          columnName: 'columnName',
          i18nKey: 'i18nKey',
          visible: true,
          type: null,
          filterOnly: false
        },
        filter: FilterOptions[0],
        value: 'value'
      }, {
        column: {
          label: 'label2',
          columnName: 'columnName2',
          i18nKey: 'i18nKey2',
          visible: true,
          type: null,
          filterOnly: false
        },
        filter: FilterOptions[0],
        value: 'value2'
      }]
    }];

    const mapped = service.adaptAdvancedUIFiltersToPaginationAPI(
      basicFilterGroups
    );

    const desired: AdHocReportingAPI.PaginationAdvancedFilterColumnModel[][] = [[{
      filter: {
        filterType: FilterOptions[0].api,
        filterValue: 'value',
        filterValues: [],
        useLogicalOperatorAnd: true
      },
      columnName: 'columnName'
    }, {
      filter: {
        filterType: FilterOptions[0].api,
        filterValue: 'value2',
        filterValues: [],
        useLogicalOperatorAnd: true
      },
      columnName: 'columnName2'
    }]];

    expect(mapped).to.deep.equal(desired);
  }

  @TestCase('should be able to map a simple filter group to report columns')
  testShouldMapSimpleFilterGroupToReportColumns (
    service: AdHocReportingService
  ) {
    const basicFilterGroups: AdvancedFilterGroup[] = [{
      useAnd: SwitchState.Toggled,
      filters: [{
        column: {
          label: 'label',
          columnName: 'columnName',
          i18nKey: 'i18nKey',
          visible: true,
          type: null,
          filterOnly: false
        },
        filter: FilterOptions[0],
        value: 'value'
      }, {
        column: {
          label: 'label2',
          columnName: 'columnName2',
          i18nKey: 'i18nKey2',
          visible: true,
          type: null,
          filterOnly: false
        },
        filter: FilterOptions[0],
        value: 'value2'
      }]
    }];

    const mapped = service.adaptAdvancedUIFiltersToReportAPI(
      basicFilterGroups
    );

    const desired: AdHocReportingAPI.AdvancedUserSavedFilterColumn[][] = [[{
      filterType: FilterOptions[0].api,
      filterValue: 'value',
      filterValues: [],
      useLogicalOperatorAnd: true,
      columnName: 'columnName'
    }, {
      filterType: FilterOptions[0].api,
      filterValue: 'value2',
      filterValues: [],
      useLogicalOperatorAnd: true,
      columnName: 'columnName2'
    }]];

    expect(mapped).to.deep.equal(desired);
  }

  @TestCase('should be able to map simple report columns to filter groups')
  testShouldMapSimpleReportColumnsToFilterGroups (
    service: AdHocReportingService
  ) {
    const basicFilters: AdHocReportingAPI.AdvancedUserSavedFilterColumn[][] = [[{
      filterType: FilterOptions[0].api,
      filterValue: 'value',
      filterValues: [],
      useLogicalOperatorAnd: true,
      columnName: 'bucket.columnName'
    }, {
      filterType: FilterOptions[1].api,
      filterValue: 'value2',
      filterValues: [],
      useLogicalOperatorAnd: true,
      columnName: 'bucket.columnName2'
    }]];


    const fakeColumns: AdHocReportingUI.ColumnDefinition[] = [{
      display: 'label',
      column: 'columnName',
      parentBucket: 'bucket',
      parentBucketName: 'Bucket',
      i18nKey: 'i18nKey',
      type: 'text'
    }, {
      display: 'label2',
      parentBucket: 'bucket',
      parentBucketName: 'Bucket',
      column: 'columnName2',
      i18nKey: 'i18nKey2',
      type: 'text'
    }];

    const mapped = service.adaptAdvancedAPIFiltersToUIGroups(
      basicFilters,
      fakeColumns
    );

    expect(mapped.length).to.equal(1);
    const [bucket] = mapped;
    expect(bucket.filters.length).to.equal(2);


    expect(bucket.filters[0].value).to.equal('value');
    expect(bucket.filters[1].value).to.equal('value2');

    expect(bucket.filters[0].filter).to.equal(FilterOptions[0]);
    expect(bucket.filters[1].filter).to.equal(FilterOptions[1]);

    expect(bucket.filters[0].column?.columnName).to.equal('bucket.columnName');
    expect(bucket.filters[1].column?.columnName).to.equal('bucket.columnName2');
  }

  @TestCase('should be able to map a boolean report column to a filter group')
  testShouldMapBooleanReportColumnsToFilterGroups (
    service: AdHocReportingService
  ) {
    const basicFilters: AdHocReportingAPI.AdvancedUserSavedFilterColumn[][] = [[{
      filterType: 'eq',
      filterValue: 'true',
      filterValues: [],
      useLogicalOperatorAnd: true,
      columnName: 'bucket.columnName'
    }, {
      filterType: 'eq',
      filterValue: 'false',
      filterValues: [],
      useLogicalOperatorAnd: true,
      columnName: 'bucket.columnName2'
    }]];


    const fakeColumns: AdHocReportingUI.ColumnDefinition[] = [{
      display: 'label',
      column: 'columnName',
      parentBucket: 'bucket',
      parentBucketName: 'Bucket',
      i18nKey: 'i18nKey',
      type: 'boolean'
    }, {
      display: 'label2',
      parentBucket: 'bucket',
      parentBucketName: 'Bucket',
      column: 'columnName2',
      i18nKey: 'i18nKey2',
      type: 'boolean'
    }];

    const mapped = service.adaptAdvancedAPIFiltersToUIGroups(
      basicFilters,
      fakeColumns
    );

    const booleanFilterOptions = FilterOptions.filter(filterOption => {
      return filterOption.types.includes('boolean');
    });

    const isTrueOption = booleanFilterOptions.find(option => option.display === 'Is true');
    const isFalseOption = booleanFilterOptions.find(option => option.display === 'Is false');

    expect(isTrueOption).not.to.be.undefined;
    expect(isFalseOption).not.to.be.undefined;

    expect(mapped.length).to.equal(1);
    const [bucket] = mapped;
    expect(bucket.filters.length).to.equal(2);

    expect(bucket.filters[0].filter).to.equal(isTrueOption);
    expect(bucket.filters[1].filter).to.equal(isFalseOption);
  }

  @TestCase('should be able to go from UI group to API filters (one of)')
  testShouldGoFromUItoAPIOneOf (
    service: AdHocReportingService
  ) {
    const oneOfGroup: [AdvancedFilterGroup] = [{
      useAnd: SwitchState.Toggled,
      filters: [{
        filter: FilterOptions.find(opt => opt.api === FilterModalTypes.equals && opt !== OneOfFilterOption),
        column: {
          label: 'label',
          columnName: 'columnName',
          i18nKey: 'i18nKey',
          visible: true,
          type: null,
          filterOnly: false
        },
        value: 'firstValue'
      }, {
        filter: OneOfFilterOption,
        column: {
          label: 'label',
          columnName: 'columnName2',
          i18nKey: 'i18nKey',
          visible: true,
          type: null,
          filterOnly: false
        },
        value: [1, 2, 3]
      }]
    }];

    const desired: AdHocReportingAPI.AdvancedUserSavedFilterColumn[][] = [[{
      filterType: FilterModalTypes.equals,
      filterValue: 'firstValue',
      filterValues: [],
      useLogicalOperatorAnd: true,
      columnName: 'columnName'
    }, {
      filterType: FilterModalTypes.equals,
      filterValue: 1,
      filterValues: [],
      useLogicalOperatorAnd: false,
      columnName: 'columnName2'
    }, {
      filterType: FilterModalTypes.equals,
      filterValue: 2,
      filterValues: [],
      useLogicalOperatorAnd: false,
      columnName: 'columnName2'
    }, {
      filterType: FilterModalTypes.equals,
      filterValue: 3,
      filterValues: [],
      useLogicalOperatorAnd: true,
      columnName: 'columnName2'
    }]];

    const mapped = service.adaptAdvancedUIFiltersToReportAPI(oneOfGroup);

    expect(mapped).to.deep.equal(desired);
  }

  @TestCase('should be able to get detail link info for application')
  getDetailLinkInfoForApplication (service: AdHocReportingService) {
    const info = service.getDetailLinkInfo('application');
    expect(info.showBudgetDetailLink).to.be.false;
    expect(info.showFsDetailLink).to.be.false;
  }

  @TestCase('should be able to get detail link info for budget')
  getDetailLinkInfoForBudget (service: AdHocReportingService) {
    const info = service.getDetailLinkInfo('budgets');
    expect(info.showBudgetDetailLink).to.be.true;
    expect(info.showFsDetailLink).to.be.false;
  }

  @TestCase('should be able to detect reference field columns')
  testShouldBeAbleToDetectRefFieldColumns (service: AdHocReportingService) {
    const refFieldKey = 'referenceFields.key';
    const categoryRefFieldKey = 'category.123.key';
    const nonRefFieldKey = 'application.id';

    expect(service['checkColumnIsReferenceField'](refFieldKey)).to.be.true;
    expect(service['checkColumnIsReferenceField'](categoryRefFieldKey)).to.be.true;
    expect(service['checkColumnIsReferenceField'](nonRefFieldKey)).to.be.false;
  }

  @TestCase('should be able to check if column header is invalid')
  isColumnHeaderValid (service: AdHocReportingService) {
    let columnHeader = 'Normal column header (1234)';
    let valid = service.isColumnHeaderValid(columnHeader);
    expect(valid).to.be.true;
    columnHeader = '<Invalid Column Header>';
    valid = service.isColumnHeaderValid(columnHeader);
    expect(valid).to.be.false;
    columnHeader = 'Valid : Column Header';
    valid = service.isColumnHeaderValid(columnHeader);
    expect(valid).to.be.true;
  }

  @TestCase('should be able to get invalid column headers')
  getInvalidColumnHeaders (service: AdHocReportingService) {
    const validHeader = 'Normal column header (1234)';
    const invalidHeader = '<Invalid Column Header>';
    const headers = [validHeader, invalidHeader];
    const invalidHeaders = service.getInvalidColumnHeaders(headers);
    expect(invalidHeaders).to.deep.equal([invalidHeader]);
  }

  @TestCase('should be able to fetch standard template report by ID')
  async fetchStandardReportById (service: AdHocReportingService) {
    await service.fetchReportById(this.standardReportId, this.standardReportTemplate);
    const report = service.reportDetails[this.standardReportId];
    expect(report.name).to.be.equal(this.standardReportTemplate.name);
    expect(report.userSavedReportColumns).to.deep.equal(
      this.standardReportTemplate.userSavedReportColumns
    );
  }

  @TestCase('should be able to fetch client report by ID')
  async fetchClientReportById (service: AdHocReportingService) {
    await service.fetchReportById(this.reportId);
    const report = service.reportDetails[this.reportId];
    expect(report.name).to.be.equal(this.userSavedReport.name);
    expect(report.reportType).to.be.equal(this.userSavedReport.reportType);
  }

  @TestCase('should be able to get record ids from modal response')
  getRecordIdsFromModalResponse (service: AdHocReportingService) {
    const modalResponse: ManageReportFormData = {
      object: 'table',
      reportName: 'Table report',
      reportDescription: '',
      program: null,
      primaryFormId: null,
      referenceFieldTableKey: this.tableKey,
      forms: [],
      startFromTemplate: null
    };
    const recordIds = service.getRecordIdsFromModalResponse(modalResponse);
    expect(recordIds.length).to.be.equal(1);
    expect(recordIds[0]).to.be.equal(this.tableId);
  }

  @TestCase('should be able to get record ids from report id')
  async getRecordIdsFromReportId (service: AdHocReportingService) {
    await service.fetchReportById(this.reportId);
    const recordIds = service.getRecordIdsFromReportId(this.reportId);
    expect(recordIds.length).to.be.equal(1);
    expect(recordIds[0]).to.be.equal(this.formId);
  }

  @TestCase('should be able to get report field columns')
  getReportFieldColumns (service: AdHocReportingService) {
    const reportFieldDisplay = 'totalCashPaymentAmount';
    const reportFieldDataOptions: ReportFieldDataOptions = {
      reportFieldObject: 'object',
      reportFieldDisplay
    };
    const comp = {
      type: 'reportField',
      key: 'reportKey',
      label: 'super cool custom label',
      reportFieldDataOptions
    } as FormDefinitionComponent;
    const currentFormDef: FormDefinitionForUi[] = [{
      index: 0,
      logic: null,
      tabName: 'name',
      components: [comp]
    }];
    const reportFieldColumns = service.getReportFieldColumns(
      currentFormDef
    );
    const allFieldsReturnedAreReportFields = reportFieldColumns.every((col) => {
      return col.column.includes('reportFieldResponse');
    });
    const reportFieldOptionUsesLabelFromConfig = reportFieldColumns
      .filter((column) => {
        return column.column.includes('totalCashPaymentAmount' as any);
      })
      .every((col) => {
      return col.label === comp.label;
    });
    expect(allFieldsReturnedAreReportFields).to.be.true;
    expect(reportFieldOptionUsesLabelFromConfig).to.be.true;
  }
}