import { Component, OnDestroy, OnInit } from '@angular/core';
import { Router } from '@angular/router';
import { SpinnerService } from '@core/services/spinner.service';
import { SimpleWorkflowUser, Workflow, WorkflowLevelPermissions, WorkflowLevelUser, WorkflowManager } from '@core/typings/workflow.typing';
import { UserService } from '@features/users/user.service';
import { SimpleStringMap, TopLevelFilter } from '@yourcause/common';
import { I18nService } from '@yourcause/common/i18n';
import { ConfirmationModalComponent, ModalFactory } from '@yourcause/common/modals';
import { Subscription } from 'rxjs';
import { WorkflowDetailsModalComponent } from '../workflow-details-modal/workflow-details-modal.component';
import { WorkflowService } from '../workflow.service';

@Component({
  selector: 'gc-workflow-page',
  templateUrl: 'workflow-page.component.html',
  styleUrls: ['./workflow-page.component.scss']
})

export class WorkflowPageComponent implements OnInit, OnDestroy {
  userMap: SimpleStringMap<SimpleWorkflowUser[]> = {};
  sub = new Subscription();
  workflows: Workflow[] = [];
  topLevelFilters = [
    new TopLevelFilter(
      'text',
      'name',
      '',
      this.i18n.translate(
        'common:textSearchByName',
        {},
        'Search by name'
      )
    )
  ];
  deactivatedUsers: number[] = [];

  constructor (
    private workflowService: WorkflowService,
    private i18n: I18nService,
    private modalFactory: ModalFactory,
    private spinnerService: SpinnerService,
    private router: Router,
    private userService: UserService
  ) { }

  ngOnInit () {
    this.deactivatedUsers = this.userService.allUsers.filter((user) => {
      return user.isDeactivated;
    }).map((user) => user.id);
    this.sub.add(
      this.workflowService.changesTo$('workflows').subscribe(() => {
        const map: SimpleStringMap<SimpleWorkflowUser[]> = {};
        const workflows = this.workflowService.workflows;
        workflows.forEach((workflow: Workflow) => {
          const managers = this.getFilteredUsers(workflow.workflowLevelManagers);
          map[workflow.id] = managers.map((manager) => {
            return {
              id: manager.clientUserId,
              name: manager.firstName + ' ' + manager.lastName,
              permissions: [WorkflowLevelPermissions.MANAGER]
            };
          });
          workflow.levels.forEach((level) => {
            const workflowLevelUsers = this.getFilteredUsers(
              level.workflowLevelUsers
            ) as WorkflowLevelUser[];
            this.addUsersToMap(
              workflow,
              map,
              workflowLevelUsers
            );
            level.subLevels.forEach((sub) => {
              const subLevelUsers = this.getFilteredUsers(
              sub.workflowLevelUsers
            ) as WorkflowLevelUser[];
              this.addUsersToMap(
                workflow,
                map,
                subLevelUsers
              );
            });
          });
        });
        this.userMap = map;
        this.workflows = workflows;
      })
    );
  }

  getFilteredUsers (users: (WorkflowManager|WorkflowLevelUser)[]) {
    return users.filter((user) => {
      return !this.deactivatedUsers.includes(user.clientUserId);
    });
  }

  addUsersToMap (
    workflow: Workflow,
    map: SimpleStringMap<SimpleWorkflowUser[]>,
    users: WorkflowLevelUser[]
  ) {
    const workflowUsers = users.filter((user) => {
      let alreadyExists = false;
      (map[workflow.id] || []).forEach((existingUser) => {
        if (existingUser.id === user.clientUserId) {
          alreadyExists = true;
          if (!existingUser.permissions.includes(user.workflowLevelAccessType)) {
            existingUser.permissions.push(user.workflowLevelAccessType);
          }
        }
      });

      return !alreadyExists;
    }).map((user) => {
      return {
        id: user.clientUserId,
        name: user.firstName + ' ' + user.lastName,
        permissions: [user.workflowLevelAccessType]
      };
    });
    map[workflow.id] = (map[workflow.id] || []).concat(workflowUsers);
  }

  async deleteModal (workflow: Workflow) {
    const proceed = await this.modalFactory.open(
      ConfirmationModalComponent,
      {
        confirmText: this.i18n.translate(
          'WORKFLOW:textAreSureYouWantToDeleteThisWorkflow',
          {},
          'Are you sure you want to delete this workflow?'
        ),
        modalHeader: `${this.i18n.translate(
          'WORKFLOW:textDeleteWorkflow',
          {},
          'Delete Workflow'
        )}: ${workflow.name}`,
        confirmButtonText: this.i18n.translate(
          'common:btnDelete',
          {},
          'Delete'
        )
      }
    );
    if (proceed) {
      this.spinnerService.startSpinner();
      await this.workflowService.handleDeleteWorkflow(workflow.id);
      this.spinnerService.stopSpinner();
    }
  }

  async addWorkflow () {
    const response = await this.modalFactory.open(
      WorkflowDetailsModalComponent,
      {
        isNew: true,
        name: '',
        description: ''
      }
    );
    if (response) {
      this.workflowService.setMapForNewWorkflow(
        response.workflowName,
        response.workflowDescription
      );
      this.router.navigate([
        `/management/program-setup/workflows/detail/new/structure`
      ]);
    }
  }

  ngOnDestroy () {
    this.sub.unsubscribe();
  }
}