import { Component, OnChanges, OnInit } from '@angular/core';
import { AdminUsersService } from '@core/services/admin-users.service';
import { EmailLogsService } from '@core/services/email-logs.service';
import { APIAdminClient } from '@core/typings/api/admin-client.typing';
import { FormAudience } from '@features/configure-forms/form.typing';
import { EmailService } from '@features/system-emails/email.service';
import { ViewEmailModalComponent } from '@features/system-emails/view-email-modal/view-email-modal.component';
import { UserService } from '@features/users/user.service';
import { ArrayHelpersService, DebounceFactory, PaginationOptions, SelectOption, TableDataFactory, TopLevelFilter, TopLevelFilterOption } from '@yourcause/common';
import { I18nService } from '@yourcause/common/i18n';
import { ModalFactory } from '@yourcause/common/modals';
import { EmailLog, EmailLogDetail, EmailNotificationType, SimpleEmail } from '../../system-emails/email.typing';
import { AdminClientService } from '../clients/admin-client.service';

@Component({
  selector: 'gc-email-logs',
  templateUrl: './email-logs.component.html',
  styleUrls: ['./email-logs.component.scss']
})
export class EmailLogsComponent implements OnInit, OnChanges {
  logListFilters: TopLevelFilter[] = [];
  logListFactory: TableDataFactory<EmailLog>;
  clientOptions: TopLevelFilterOption[] = [];
  emailOptions: SelectOption[] = [];
  userId = this.userService.currentUser.id;
  allowedClients: APIAdminClient.Client[];

  constructor (
    private adminClientService: AdminClientService,
    private arrayHelper: ArrayHelpersService,
    private userService: UserService,
    private adminUserService: AdminUsersService,
    private i18n: I18nService,
    private emailLogService: EmailLogsService,
    private modalFactory: ModalFactory,
    private emailService: EmailService
  ) { }

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

  async ngOnInit () {
    await this.emailService.setEmails();

    for (const email in EmailNotificationType) {
      if (typeof EmailNotificationType[email] === 'number') {
        this.emailOptions.push({
          label: 'GC-' + EmailNotificationType[email],
          value: EmailNotificationType[email]
        });
      }
    }

    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.clientOptions = this.arrayHelper.sort(this.clientOptions, 'label');

    this.logListFilters = [
      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',
        'toFriendlyName',
        '',
        this.i18n.translate(
          'ADMIN:textSearchRecipient',
          {},
          'Search Recipient'
        ),
        undefined,
        undefined,
        [{
          column: 'toFriendlyName',
          filterType: 'cn'
        }, {
          column: 'toAddress',
          filterType: 'cn'
        }]
      );

      this.logListFilters.push(filter);

    this.logListFactory = DebounceFactory.createSimple(
      async (options: PaginationOptions<EmailLog>) => {
        const result = await this.emailLogService.adminEmailLogsPaginated(options);

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

  audienceName (audienceType: FormAudience) {
    switch (audienceType) {
      case FormAudience.APPLICANT:
        return this.i18n.translate(
          'common:lblApplicant',
          {},
          'Applicant'
        );
        break;
      case FormAudience.MANAGER:
        return this.i18n.translate(
          'ADMIN:textGrantManager',
          {},
          'Grant Manager'
        );
        break;
      default:
        return '';
        break;
    }
  }

  getSimpleEmail (
    email: EmailLog,
    emailDetail: EmailLogDetail
  ): SimpleEmail {
    const foundClient = this.emailService.emails.filter(found => {
      return found.emailNotificationType === email.emailNotificationType;
    });

    return {
      id: email.id,
      subject: email.subject,
      emailNumber: '',
      emailNotificationType: email.emailNotificationType,
      audienceType: foundClient[0].audienceType,
      title: foundClient[0].title,
      body: emailDetail.body,
      description: foundClient[0].description,
      ccEmails: email.ccEmails,
      bccEmails: email.bccEmails,
      attachments: email.emailAttachments
    };
  }

  async viewEmail (email: EmailLog) {
    const emailDetail = await this.emailLogService.getAdminEmail(email.id);
    const deps = {
      email: this.getSimpleEmail(email, emailDetail),
      isCopy: true,
      editEmailsArea: false,
      showEmailHeader: false,
      removeEmailContainerClass: true
    };
    await this.modalFactory.open(
      ViewEmailModalComponent,
      deps,
      { backdrop: true, class: 'modal-xl' }
    );
  }

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

}