import { Component, OnChanges, OnInit } from '@angular/core';
import { AdminUsersService } from '@core/services/admin-users.service';
import { SpinnerService } from '@core/services/spinner.service';
import { APIAdminClient } from '@core/typings/api/admin-client.typing';
import { GrantManagerUser } from '@core/typings/grant-manager.typing';
import { AdminUserPermissions } from '@core/typings/user.typing';
import { ImpersonationService } from '@features/impersonation/impersonation.service';
import { ApplicantEmailLinkModalComponent } from '@features/platform-admin/applicants/applicant-email-link-modal/applicant-email-link-modal.component';
import { AdminClientService } from '@features/platform-admin/clients/admin-client.service';
import { GrantManagerModalComponent } from '@features/platform-admin/grant-managers/grant-manager-modal/grant-manager-modal.component';
import { UserService } from '@features/users/user.service';
import { DebounceFactory, PaginationOptions, TableCSVFactory, TableDataFactory, TopLevelFilter, TopLevelFilterOption } from '@yourcause/common';
import { I18nService } from '@yourcause/common/i18n';
import { ModalFactory } from '@yourcause/common/modals';
import { NotifierService } from '@yourcause/common/notifier';
import { GrantManagerService } from '../grant-manager.service';

@Component({
  selector: 'gc-grant-managers-table',
  templateUrl: './grant-managers-table.component.html',
  styleUrls: ['./grant-managers-table.component.scss']
})
export class GrantManagersTableComponent implements OnInit, OnChanges {
  tableListFilters: TopLevelFilter[] = [];
  tableListFactory: TableDataFactory<GrantManagerUser>;
  clientOptions: TopLevelFilterOption[] = [];
  adminPermissions = this.userService.adminPermissions;
  userId = this.userService.currentUser.id;
  allowedClients: APIAdminClient.Client[];
  canEditGrantManager = this.adminPermissions.includes(
    AdminUserPermissions.EditGrantManagers
  );
  canImpersonate = this.adminPermissions.includes(
    AdminUserPermissions.CanImpersonate
  );
  tableCsvFactory: TableCSVFactory<string>;

  constructor (
    private adminClientService: AdminClientService,
    private grantManagerService: GrantManagerService,
    private adminUserService: AdminUsersService,
    private userService: UserService,
    private modalFactory: ModalFactory,
    private notifier: NotifierService,
    private i18n: I18nService,
    private spinnerService: SpinnerService,
    private impersonationService: ImpersonationService
  ) { }

  get clients () {
    return this.adminClientService.clients || [];
  }

  async ngOnInit () {

    const adminDetail = await this.adminUserService.getAdminDetail(this.userId);

    if (!adminDetail.canAccessAllClientZones) {
      this.allowedClients = this.clients.filter((client) => {
        return adminDetail.clientZoneIds.includes(client.clientId);
      });
    } else {
      this.allowedClients = this.clients;
    }

    this.clientOptions = this.allowedClients.map(client => {
      return {
        label: client.name,
        value: client.clientId
      };
    });

    this.tableListFilters = [
      new TopLevelFilter(
        'checkboxDropdown',
        'clientId',
        [],
        this.i18n.translate(
          'ADMIN:textAllClientsSelected',
          {},
          'All clients selected'
        ),
        {
          selectOptions: this.clientOptions,
          filterObjectName: this.i18n.translate(
            'common:labelClient',
            {},
            'Client'
          ).toLowerCase(),
          filterObjectNamePlural: this.i18n.translate(
            'common:textClients',
            {},
            'Clients'
          ).toLowerCase()
        }
      )
    ];

    const filter = new TopLevelFilter(
      'text',
      'fullName',
      '',
      this.i18n.translate(
        'ADMIN:textSearchGrantManager',
        {},
        'Search for grant manager'
      ),
      undefined,
      undefined,
      [{
        column: 'fullName',
        filterType: 'cn'
      }, {
        column: 'email',
        filterType: 'cn'
      }]
    );

    this.tableListFilters.push(filter);

    this.tableListFactory = DebounceFactory.createSimple(
      async (options: PaginationOptions<GrantManagerUser>) => {
        this.grantManagerService.setGrantManagerPaginationOptions(options);
        const result = await this.grantManagerService.adminGrantManagerPaginated(
          options
        );

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

  async editGrantManager (user: GrantManagerUser) {
    const response = await this.modalFactory.open(
      GrantManagerModalComponent,
      { user }
    );
    if (response) {
    this.spinnerService.startSpinner();
      await this.grantManagerService.handleUpdateGrantManager({
        ...response,
        id: user.id,
        userId: user.userId,
        clientId: user.clientId
      });
      this.tableListFactory.reset.emit();
      this.spinnerService.stopSpinner();
    }
  }


  async confirmEmail (user: GrantManagerUser) {
    this.spinnerService.startSpinner();
    await this.grantManagerService.handleConfirmEmailAddress(user.id);
    this.tableListFactory.reset.emit();
    this.spinnerService.stopSpinner();
  }

  async generatePasswordResetLink (user: GrantManagerUser) {
    const deps = {
      user,
      modalType: 'grant_manager'
    };

    const response = await this.modalFactory.open(
      ApplicantEmailLinkModalComponent,
      deps
    );
    if (response) {
      document.addEventListener('copy', (e: ClipboardEvent) => {
        e.clipboardData.setData('text/plain', (response));
        e.preventDefault();
        document.removeEventListener('copy', null);
      });
      document.execCommand('copy');

      this.notifier.success(this.i18n.translate(
        'ADMIN:LinkCopied',
        {},
        'Link copied'
      ));
    }
  }

  async impersonateUser (user: GrantManagerUser) {
    this.spinnerService.startSpinner();
    const foundClient = this.clients.find((client) => {
      return +user.clientId === +client.clientId;
    });
    const url = await this.impersonationService.handleImpersonateUser(
      user.userId,
      foundClient?.subDomain
    );
    this.spinnerService.stopSpinner();
    if (url) {
      window.open(url, '_blank');
    }
  }

  ngOnChanges () {
    if (this.tableListFactory) {
      this.tableListFactory.reset.emit();
    }
  }
}