import { Injectable } from '@angular/core';
import { CLIENT_SETTINGS_SERVICE_MOCK } from '@core/mocks/client-settings.service.mock';
import { CURRENCY_SERVICE_MOCK } from '@core/mocks/currency.service.mock';
import { GCMockModule } from '@core/mocks/gc-module.mock';
import { TimeZoneService } from '@core/services/time-zone.service';
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 } from '@features/configure-forms/form.typing';
import { BeforeEach, Spec, TestCase } from '@yourcause/test-decorators';
import { DescribeAngularService } from '@yourcause/test-decorators/angular';
import { expect } from 'chai';
import { AdHocReportingDefinitions } from './ad-hoc-reporting-definitions.service';
import { AdHocReportingMappingService } from './ad-hoc-reporting-mapping.service';

@Injectable({ providedIn: 'root' })
@DescribeAngularService(AdHocReportingMappingService, {
  imports: [
    GCMockModule
  ],
  providers: [
    CURRENCY_SERVICE_MOCK,
    CLIENT_SETTINGS_SERVICE_MOCK
  ]
})
export class AdHocReportingMappingServiceSpec implements Spec<AdHocReportingMappingServiceSpec, AdHocReportingMappingService> {
  hireDateDef: AdHocReportingUI.ColumnDefinition = {
    display: 'Hire Date',
    i18nKey: '',
    type: 'date',
    column: 'hireDate',
    format: 'date',
    supportsGrouping: true,
    parentBucketName: 'Application / Nomination',
    parentBucket: 'application'
  };
  appStatusDef: AdHocReportingUI.ColumnDefinition = {
    display: 'Application status',
    i18nKey: 'GLOBAL:lblApplicationStatus',
    type: 'multi-list',
    filterOptions: [{
      label: 'Approved',
      value: ApplicationStatuses.Approved
    }],
    format: 'label',
    column: 'applicationStatus',
    supportsGrouping: true
  };
  userSavedReportColumns: AdHocReportingAPI.UserSavedReportColumn[] = [{
    columnName: 'application.id',
    sortType: AdHocReportingAPI.SortTypes.NoSort,
    sortPriority: null,
    userSavedFilterColumns: [],
    displayName: '',
    isChartGroupingColumn: false,
    isChartSubGroupingColumn: false,
    isChartAggregate: true,
    chartAggregateType: AdHocReportingAPI.ChartAggregateType.Count,
    referenceFieldId: null
  }, {
    columnName: 'grantProgram.name',
    sortType: AdHocReportingAPI.SortTypes.NoSort,
    sortPriority: null,
    userSavedFilterColumns: [],
    displayName: '',
    isChartGroupingColumn: true,
    isChartSubGroupingColumn: false,
    isChartAggregate: false,
    chartAggregateType: null,
    referenceFieldId: null
  }, {
    columnName: 'application.applicationStatus',
    sortType: AdHocReportingAPI.SortTypes.NoSort,
    sortPriority: 1,
    userSavedFilterColumns: [],
    displayName: '',
    isChartGroupingColumn: true,
    isChartSubGroupingColumn: true,
    isChartAggregate: false,
    chartAggregateType: null,
    referenceFieldId: null
  }];
  categoryId1 = 1;
  categoryId2 = 2;
  multiTextAreaKey = 'multiTextArea';
  fileUploadKey = 'fileUpload';
  multiTextColImp: AdHocReportingUI.ColumnImplementation = {
    sortType: 1,
    visibleInReport: true,
    filterColumn: {
      columnName: `category.${this.categoryId1}.${this.multiTextAreaKey}`,
      filters: []
    },
    columnNameOverride: '',
    definition: {
      column: this.multiTextAreaKey,
      parentBucket: `category.${this.categoryId1}`,
      parentBucketName: '1st Category',
      type: 'text',
      format: null,
      display: 'What kind of disaster was it?',
      i18nKey: null,
      isReferenceField: true
    }
  };
  fileUploadColImp: AdHocReportingUI.ColumnImplementation = {
    sortType: 1,
    visibleInReport: true,
    filterColumn: {
      columnName: `category.${this.categoryId2}.${this.fileUploadKey}`,
      filters: []
    },
    columnNameOverride: '',
    definition: {
      column: this.fileUploadKey,
      parentBucket: `category.${this.categoryId2}`,
      parentBucketName: '2nd Category',
      type: 'text',
      format: 'file',
      display: 'Upload your file',
      i18nKey: null,
      isReferenceField: true
    }
  };
  multiTextAnswer = 'Answer 1|Answer 2';
  appId = 23;
  appFormId = 54;
  fileId = 55;
  fileName = 'logo.jpg';
  row = {
    application: {
      id: this.appId
    } as any,
    form: {
      applicationFormId: this.appFormId
    } as any,
    referenceFields: [{
      referenceFieldId: 1,
      referenceFieldKey: this.multiTextAreaKey,
      value: this.multiTextAnswer,
      dateValue: '',
      type: ReferenceFieldsUI.ReferenceFieldTypes.TextArea
    }, {
      referenceFieldId: 2,
      referenceFieldKey: this.fileUploadKey,
      value: 'https://yourcausegrantsqa.com/management/download-file?applicationId=166993&applicationFormId=163915&fileId=762&fileName=logo.jpg',
      dateValue: null,
      numericValue: null,
      type: ReferenceFieldsUI.ReferenceFieldTypes.FileUpload,
      values: [],
      isEncrypted: false,
      isReferenceFieldMasked: false,
      currencyValue: null,
      supportsMultiple: false,
      file: {
        fileId: this.fileId,
        fileName: this.fileName,
        value: 'https://yourcausegrantsqa.com/management/download-file?applicationId=166993&applicationFormId=163915&fileId=7624&fileName=logo.jpg'
      },
      files: []
    }]
  } as AdHocReportingUI.ReportResponseRow;
  referenceFields: ReferenceFieldAPI.ReferenceFieldDisplayModel[] = [{
    customDataTableGuid: '',
    name: 'Multi textarea',
    description: '',
    type: ReferenceFieldsUI.ReferenceFieldTypes.TextArea,
    key: this.multiTextAreaKey,
    supportsMultiple: true,
    categoryId: this.categoryId1,
    formAudience: FormAudience.APPLICANT,
    referenceFieldId: 1,
    formCount: 1,
    usedOnReports: false,
    createdBy: '',
    createDate: '',
    updatedBy: '',
    updateDate: '',
    aggregateType: null,
    parentReferenceFieldId: null,
    isEncrypted: false,
    isMasked: false,
    tableAllowsImport: false,
    isSingleResponse: false,
    isTableField: false,
    aggregateTableReferenceFieldId: null,
    referenceFieldTableId: null,
    standardComponentIsPublished: true,
    isStandardProductField: false,
    subsetCollectionType: null
  }, {
    customDataTableGuid: '',
    name: 'File Upload',
    description: '',
    type: ReferenceFieldsUI.ReferenceFieldTypes.FileUpload,
    key: this.fileUploadKey,
    supportsMultiple: false,
    categoryId: this.categoryId2,
    formAudience: FormAudience.APPLICANT,
    referenceFieldId: 1,
    formCount: 1,
    usedOnReports: false,
    createdBy: '',
    createDate: '',
    updatedBy: '',
    updateDate: '',
    aggregateType: null,
    parentReferenceFieldId: null,
    isEncrypted: false,
    isMasked: false,
    tableAllowsImport: false,
    isSingleResponse: false,
    isTableField: false,
    aggregateTableReferenceFieldId: null,
    referenceFieldTableId: null,
    standardComponentIsPublished: true,
    isStandardProductField: false,
    subsetCollectionType: null
  }];

  constructor (
    private timezoneService: TimeZoneService,
    private adHocDefinitions: AdHocReportingDefinitions
  ) { }

  @BeforeEach()
  mock (service: AdHocReportingMappingService) {
    (service as any).TimeZoneService = this.timezoneService;
    this.timezoneService.setTimeZones();
    service['referenceFieldService'].setAllReferenceFields(
      this.referenceFields
    );
  }

  @TestCase('should be able to format date display value')
  async getFormattedDateDisplayValue (service: AdHocReportingMappingService) {
    const value = '2013-10-01T00:00:00Z';
    const row = {
      application: {
        hireDate: value
      }
    } as any;
    const formatted = service.getFormattedDisplayValue(
      value,
      this.hireDateDef,
      row,
      true
    );
    formatted;
    expect(formatted).to.be.equal('Oct 1, 2013');
  }

  @TestCase('should be able to format filter options display value')
  async getFormattedOptionsDisplayValue (service: AdHocReportingMappingService) {
    const value = ApplicationStatuses.Approved;
    const row = {
      application: {
        applicationStatus: value
      }
    } as any;
    const formatted = service.getFormattedDisplayValue(
      value,
      this.appStatusDef,
      row,
      true
    );
    expect(formatted).to.be.equal('Approved');
  }

  @TestCase('should be able to map api to column filters')
  mapApiToColumnFilters (service: AdHocReportingMappingService) {
    const response = service.mapApiToColumnFilters(this.userSavedReportColumns[0]);
    expect(response.columnName).to.be.equal('application.id');
    expect(response.filters.length).to.be.equal(0);
  }

  @TestCase('should be able to get value for multi text area')
  getValueForColumnFromRow (service: AdHocReportingMappingService) {
    const value = service.getValueForColumnFromRow(
      this.multiTextColImp.definition,
      this.row,
      false
    );
    expect(value).to.be.equal(
      this.multiTextAnswer.split('|').join(', ')
    );
  }

  @TestCase('should be able to get value for file form field')
  getValueForFormFieldFile (service: AdHocReportingMappingService) {
    const value = service.getValueForColumnFromRow(
      this.fileUploadColImp.definition,
      this.row,
      false
    );
    const expectedUrl = `https://yourcausegrantsqa.com/management/download-file?applicationId=${this.appId}&applicationFormId=${this.appFormId}&fileId=${this.fileId}&fileName=${this.fileName}`;
    expect(value).to.be.equal(expectedUrl);
  }

  @TestCase('should be able to adapt form column name for api')
  adaptFormColumnNameForApi (service: AdHocReportingMappingService) {
    const columnName = `category.${this.categoryId1}.${this.multiTextAreaKey}`;
    const adapted = service.adaptFormColumnNameForApi(columnName);
    expect(adapted).to.be.equal(`referenceFields.${this.multiTextAreaKey}`);
  }

  @TestCase('should be able to adapt form column name for view')
  adaptFormColumnNameForView (service: AdHocReportingMappingService) {
    const columnName = `referenceFields.${this.multiTextAreaKey}`;
    const adapted = service.adaptFormColumnNameForView(columnName);
    expect(adapted).to.be.equal(`category.${this.categoryId1}.${this.multiTextAreaKey}`);
  }

  @TestCase('should be able to map columns to api')
  mapColumnsToApi (service: AdHocReportingMappingService) {
    const columnImps = [
      this.multiTextColImp,
      this.fileUploadColImp
    ];
    const mapped = service.mapColumnsToApi(columnImps);
    expect(mapped[0].columnName).to.be.equal(`referenceFields.${this.multiTextAreaKey}`);
    expect(mapped[1].columnName).to.be.equal(`referenceFields.${this.fileUploadKey}`);
  }

  @TestCase('should be able to get category buckets')
  getCategoryBuckets (service: AdHocReportingMappingService) {
    const formId = 1;
    const categoryBuckets = service.getCategoryBuckets(
      [formId],
      {
        [formId]: [{
          key: this.multiTextAreaKey,
          type: `referenceFields-${this.multiTextAreaKey}`,
          label: 'Multi text'
        }, {
          key: this.fileUploadKey,
          type: `referenceFields-${this.fileUploadKey}`,
          label: 'File'
        }]
      },
      AdHocReportingUI.Usage.AD_HOC,
      this.adHocDefinitions.table
    );
    expect(categoryBuckets.length).to.be.equal(2);
    expect(categoryBuckets[0].property).to.be.equal(`category.${this.categoryId1}`);
    expect(categoryBuckets[1].property).to.be.equal(`category.${this.categoryId2}`);
  }

  @TestCase('should be able to tell if is ref field column')
  isRefFieldColumn (service: AdHocReportingMappingService) {
    let isRefFieldColumn = service.isRefFieldColumn(
      `category.${this.categoryId1}.${this.multiTextAreaKey}`
    );
    expect(isRefFieldColumn).to.be.true;
    isRefFieldColumn = service.isRefFieldColumn(
      'application.applicationStatus'
    );
    expect(isRefFieldColumn).to.be.false;
  }
}