import { Injectable } from '@angular/core';
import { AdminUserResources } from '@core/resources/admin-user.resources';
import { AdminUsersState } from '@core/states/admin-users.state';
import { AdaptedAdminUser, AdminUser } from '@core/typings/user.typing';
import { AdminClientService } from '@features/platform-admin/clients/admin-client.service';
import { ArrayHelpersService, FileService, PaginationOptions, SimpleStringMap } 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 * as parse from 'papaparse';
import { TimeZoneService } from './time-zone.service';


@AttachYCState(AdminUsersState)
@Injectable({ providedIn: 'root' })
export class AdminUsersService extends BaseYCService<AdminUsersState> {

   constructor (
    private logger: LogService,
    private adminUserResources: AdminUserResources,
    private adminClientService: AdminClientService,
    private notifierService: NotifierService,
    private timeZoneService: TimeZoneService,
    private fileService: FileService,
    private i18nService: I18nService,
    private arrayHelper: ArrayHelpersService
  ) {
    super();
  }

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

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

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

  get roles () {
    return this.get('adminRoles');
  }

  async fetchAdminRoles () {
    if (!this.roles) {
      const roles = await this.adminUserResources.getAllAdminRoles();

      this.set('adminRoles', this.arrayHelper.sort(roles, 'name'));
    }

    return this.roles;
  }

  async getAllAdmins () {
    const options: PaginationOptions<AdminUser> = {
      rowsPerPage: 12,
      pageNumber: 0,
      sortColumns: [{
        columnName: 'fullName',
        sortAscending: true
      }],
      filterColumns: [],
      retrieveTotalRecordCount: true,
      returnAll: true
    };
    const admins = await this.adminUserResources.adminUsersPaginated(options);
    const adaptedAdmins = this.adaptAdminUser(admins.records);
    this.set('admins', adaptedAdmins);
    const adminMap: SimpleStringMap<AdaptedAdminUser> = {};
    adaptedAdmins.forEach((admin) => {
      adminMap[admin.userId] = admin;
    });
    this.set('adminMap', adminMap);
    await this.setActiveAdminCount();
  }

  async getPaginatedAdmins (options: PaginationOptions<AdminUser>) {
    const results = await this.adminUserResources.adminUsersPaginated(options);

    return {
      success: results.success,
      recordCount: results.recordCount,
      records: this.adaptAdminUser(results.records)
    };
  }

  async toggleAdminActivation (
    userId: number,
    activationStatus: boolean
  ) {
    try {
      await this.adminUserResources.toggleAdminUserStatus(userId, activationStatus);
      if (activationStatus) {
        this.notifierService.success(this.i18nService.translate(
          'ADMIN:txtSuccesfullyDeactivatedInternalAdmin',
          {},
          'Succesfully deactivated the internal admin'
        ));
      } else {
        this.notifierService.success(this.i18nService.translate(
          'ADMIN:txtSuccesfullyActivatedInternalAdmin',
          {},
          'Succesfully activated the internal admin'
        ));
      }
    } catch (error) {
      this.logger.error(error);
      if (activationStatus) {
        this.notifierService.error(this.i18nService.translate(
          'ADMIN:txtErrorDeactivatingInternalAdmin',
          {},
          'There was a problem deactivating the internal admin'
        ));
      } else {
        this.notifierService.error(this.i18nService.translate(
          'ADMIN:txtErrorActivatingInternalAdmin',
          {},
          'There was a problem activating the internal admin'
        ));
      }
    }
  }

  adaptAdminUser (admins: AdminUser[]): AdaptedAdminUser[] {
    const adaptedAdmins = admins.map((admin) => ({
      userId: admin.userId,
      firstName: admin.firstName,
      lastName: admin.lastName,
      fullName: admin.fullName,
      isDeactivated: admin.isDeactivated,
      canAccessAllClientZones: admin.canAccessAllClientZones,
      createdDate: admin.createdDate,
      email: admin.email,
      clientZoneIds: admin.clientZoneIds,
      roleIds: admin.roles
    }));

    return adaptedAdmins;
  }

  async saveAdminUser (payload: AdaptedAdminUser, newUser: boolean) {
    try {
      if (newUser) {
        await this.adminUserResources.addAdminUser(payload);
      } else {
        await this.adminUserResources.updateAdminUser(payload);
      }
      if (newUser) {
        this.notifierService.success(this.i18nService.translate(
          'ADMIN:txtSuccessfullyAddedInternalAdmin',
          {},
          'Successfully added internal admin'
        ));
      } else {
        this.notifierService.success(this.i18nService.translate(
          'ADMIN:SuccessfullySavedInternalAdmin',
          {},
          'Successfully saved internal admin'
        ));
      }
    } catch (error) {
      this.logger.error(error);
      if (newUser) {
        this.notifierService.error(this.i18nService.translate(
          'ADMIN:errorAddingInternalAdmins',
          {},
          'There was an error adding the internal admin'
        ));
      } else {
        this.notifierService.error(this.i18nService.translate(
          'ADMIN:errorSavingInternalAdmins',
          {},
          'There was an error saving the internal admin'
        ));
      }

    }
  }

  getAdminDetail (userId: number): Promise<AdaptedAdminUser> {
    return this.adminUserResources.getAdminDetail(userId);
  }

  async setActiveAdminCount () {
    const activeAdmins = await this.adminUserResources.activeAdminUserCount();
    this.set('activeAdminCount', activeAdmins);
  }

  async downloadAdminReport (options: PaginationOptions<AdminUser>) {
    try {
      if (!options) {
        options = {
          rowsPerPage: 12,
          pageNumber: 0,
          sortColumns: [{
            columnName: 'fullName',
            sortAscending: true
          }],
          filterColumns: [],
          retrieveTotalRecordCount: true,
          returnAll: true
        };
      } else {
        options.returnAll = true;
      }

      const admins = await this.adminUserResources.adminUsersPaginated(options);

      const allClients = this.adminClientService.clients.map((client) => {
        return client.name;
      });

      const response = admins.records.map((admin: AdminUser) => {
        let assignedClients: string[] = [];
        if (admin.canAccessAllClientZones && !admin.isDeactivated) {
          assignedClients = allClients;
        } else if (!admin.isDeactivated && !admin.canAccessAllClientZones) {
          assignedClients = admin.clientZoneIds.map((clientId) => {
            return this.adminClientService.clientsMap[clientId]?.name;
          }).filter((client) => !!client);
        }

        return {
          AdminLastName: admin.lastName,
          AdminFirstName: admin.firstName,
          AdminEmail: admin.email,
          AssignedClients: assignedClients,
          AssignedRoles: this.roles.filter((role) => {
            return admin.roles.includes(role.id);
          }).map((role) => {
            return role.name;
          }),
          CreatedDate: this.timeZoneService.returnMidnightUTCDateShort(admin.createdDate, 'MM/DD/YYYY'),
          CreatedBy: this.adminMap[admin.createdBy]?.fullName,
          UpdatedDate: this.timeZoneService.returnMidnightUTCDateShort(admin.updatedDate, 'MM/DD/YYYY'),
          UpdatedBy: this.adminMap[admin.updatedBy]?.fullName
        };

      });

      const csv = parse.unparse(response);
      this.fileService.downloadCSV(csv);
    } catch (error) {
      this.logger.error(error);
      this.notifierService.error(
        this.i18nService.translate(
          'USERS:textErrorDownloadingUserReport',
          {},
          'Error downloading user report'
        )
      );
    }
  }

  searchActiveDirectory (
    searchTerm: string,
    topResults = 5
  ) {
    return this.adminUserResources.searchActiveDirectory(
      searchTerm,
      topResults
    );
  }
}