import { Injectable } from '@angular/core';
import { TranslationService } from '@core/services/translation.service';
import { ApplicationActivityForUi, ApplicationActivityFromApi } from '@features/application-activity/activity.typing';
import { ApplicationActivityService } from '@features/application-activity/application-activity.service';
import { APIResult, ArrayHelpersService, DebounceFactory, PaginationOptions, TypeaheadSelectOption } from '@yourcause/common';
import { I18nService } from '@yourcause/common/i18n';
import { LogService } from '@yourcause/common/logging';
import { NotifierService } from '@yourcause/common/notifier';
import { AttachYCState, BaseYCService } from '@yourcause/common/state';
import { MyWorkspaceResources } from './my-workspace.resources';
import { MyWorkspaceState } from './my-workspace.state';
import { StringMap } from './my-workspace.typing';


@AttachYCState(MyWorkspaceState)
@Injectable({ providedIn: 'root' })
export class MyWorkspaceService extends BaseYCService<MyWorkspaceState> {
  allActivitiesFactory = DebounceFactory
    .createSimple((options: PaginationOptions<ApplicationActivityForUi>) => {
      return this.getActivity(options);
    }, 0);

   constructor (
    private logger: LogService,
    private i18n: I18nService,
    private notifier: NotifierService,
    private arrayHelper: ArrayHelpersService,
    private myWorkspaceResources: MyWorkspaceResources,
    private translationService: TranslationService,
    private applicationActivityService: ApplicationActivityService
  ) {
    super();
  }

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

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

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

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

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

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

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

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

  async getActivity (
    options: PaginationOptions<ApplicationActivityForUi>
  ): Promise<APIResult<ApplicationActivityForUi>> {
    options.rowsPerPage = 5;
    options.retrieveTotalRecordCount = true;
    options.sortColumns = [{
      columnName: 'createdDate',
      sortAscending: false
    }];
    const results = await this.applicationActivityService.getMyActivity(
      options
    );

    return {
      success: true,
      data: {
        records: results.records,
        recordCount: results.recordCount
      }
    };
  }

  async setSummary () {
    try {
      const summary = await this.myWorkspaceResources.getSummary();
      this.set('totalApplications', summary.totalApplication ?? 0);
      this.set('totalNotReviewed', summary.totalApplicationsNotReviewed ?? 0);
      this.set('totalActiveWorkflows', summary.totalActiveWorkflowLevels ?? 0);
      this.set('totalActivePrograms', summary.totalActivePrograms ?? 0);
    } catch (e) {
      this.logger.error(e);
      this.notifier.error(this.i18n.translate(
        'GLOBAL:textErrorLoadingMyWorkspace',
        {},
        'There was an error loading my workspace'
      ));
    }
  }

  async setDeadlines () {
    if (!this.deadlines) {
      try {
        const deadlines = await this.myWorkspaceResources.getDeadlines();

        this.set('deadlines', deadlines);
      } catch (e) {
        this.logger.error(e);
        this.notifier.error(this.i18n.translate(
          'GLOBAL:textErrorLoadingDeadlines',
          {},
          'There was an error loading deadlines'
        ));
      }
    }
  }

  async getProgramsAndWorkflowsForMyWorkspace () {
    const response = await this.myWorkspaceResources.getProgramsAndWorkflowsForMyWorkspace();
    const programs = this.convertMapToFilterOptions(response.programs);
    const programTranslationMap = this.translationService.viewTranslations.Grant_Program;
    programs.forEach((program) => {
      const map = programTranslationMap[program.value];
      if (map) {
        program.label = map.Name || program.label;
      }
    });
    const workflowLevels = this.convertMapToFilterOptions(response.workflowLevels);
    this.set('filterLevels', workflowLevels);
    this.set('filterPrograms', programs);
  }

  async setActivities () {
    try {
      const options: PaginationOptions<ApplicationActivityFromApi> = {
        retrieveTotalRecordCount: true,
        filterColumns: [],
        sortColumns: [{
          columnName: 'createdDate',
          sortAscending: false
        }],
        returnAll: false,
        pageNumber: 1,
        rowsPerPage: 5
      };
      const activities = await this.applicationActivityService.getMyActivity(options);

      this.set('activities', activities.records);
    } catch (e) {
      this.logger.error(e);
      this.notifier.error(this.i18n.translate(
        'GLOBAL:textErrorLoadingActivities',
        {},
        'There was an error loading recent grant activity'
      ));
    }
  }

  convertMapToFilterOptions (map: StringMap) {
    let filterOptions: TypeaheadSelectOption[] = [];
    Object.keys(map).forEach((id) => {
      filterOptions.push({
        label: map[id],
        value: id
      });
    });
    filterOptions = this.arrayHelper.sort(filterOptions, 'label');

    return filterOptions;
  }
}