import { Injectable } from '@nestjs/common';
import { AppLogger } from '../../../logger';
import { PermissionGuardService } from '../services';
import { PermissionModeConditional } from '../interfaces';
import { UserPermission } from '../interfaces';
import { GetProjectPermissionResponseDto } from '../models/dto';
import { AuthorizationUtil } from '../utils';
import { AuthorizationError } from '../../../exceptions/app-error/authorization-error';
import { ErrorCode } from '../../../exceptions/app-error/models/enums';
import { AclGuardService } from '../services';
import { AuthorizationGuardService } from '../services';
import { AclResourcePermissions } from '../interfaces';

@Injectable()
export class AuthorizationGuardProvider {

  protected TAG: string = `${this.constructor.name}`;

  constructor(private readonly permissionGuardService: PermissionGuardService,
              private readonly aclGuardService: AclGuardService,
              private readonly authorizationGuardService: AuthorizationGuardService) {
    AppLogger.log('Init', this.TAG);
  }

  public async canActivate(request, headers, modes: Array<PermissionModeConditional<any>>,
                           resourceName: string = null, resourcesIds: string = null): Promise<boolean> {
    let userPermissions: UserPermission = {};
    if (request.projectShortId) {
      const userProjectPermissionsDto: GetProjectPermissionResponseDto[] = await this.permissionGuardService
        .getAccountProjectPermission(headers.authorization, request.token.sub, request.projectShortId);
      userPermissions = await this.permissionGuardService
        .getUserProjectPermissionName(userProjectPermissionsDto, request.projectShortId, request.token.sub);
      if (resourceName) {
        const aclResourcePermission: AclResourcePermissions = await this.aclGuardService
          .getProjectResourceAcl(headers.authorization, request.token.sub, request.projectShortId, resourceName, resourcesIds);
        if (aclResourcePermission) {
          request.acls = aclResourcePermission;
          AuthorizationUtil.addAclPermissionToDictionary(userPermissions, aclResourcePermission, resourcesIds);
        }
      }
    }

    const systemPermissions: string[] = await this.permissionGuardService.getUserSystemPermission(headers.authorization, request.token);
    AuthorizationUtil.addSystemPermissionToDictionary(userPermissions, systemPermissions);

    const modeResponse: any = this.authorizationGuardService.hasPermission<any>(userPermissions, modes, request.params, resourcesIds);
    if (modeResponse) {
      request.mode = modeResponse;
      return true;
    }
    throw new AuthorizationError(ErrorCode.UNAUTHORIZED_PERMISSION);
  }
}