import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
import {
  Body,
  Controller,
  Delete,
  Get,
  HttpCode,
  HttpStatus,
  Inject,
  Param,
  Patch,
  Post,
  Put,
  Query,
  Res,
  UseFilters,
} from '@nestjs/common';
import {
  ApiCreatedResponse,
  ApiHeaders,
  ApiOkResponse,
  ApiTags,
} from '@nestjs/swagger';
import { PERMISSIONS_GROUPS } from 'src/authentication/permissions.enum';
import {
  Authenticated,
  RequireAllPermissions,
  RequireSomePermission,
} from 'src/decorators/authentication.decorator';
import { Language } from 'src/decorators/language.decorator';
import { ApiInternalOnlyController } from 'src/decorators/swagger.decorator';
import { RequestUser, User } from 'src/decorators/user.decorator';
import { GrpcToHttpExceptionFilter } from 'src/error/grpc-to-http-exception.filter';
import { PackTheMetadata } from 'src/utils/PackTheMetadata';
import ErrorBuilder from 'src/utils/ErrorBuilder';
import ErrorCodes from 'src/utils/errorCodes';
import { LanguageEnum } from 'src/utils/languages.enum';
import {
  AssignRoleToUserReq,
  BatchCreateUserReq,
  BatchCreateUserRes,
  CreateUserReq,
  CreateUserRes,
  DeleteUserRes,
  GetAllDepartmentsRes,
  GetAllHierarchiesRes,
  GetAllJobTitlesRes,
  GetAllUsersByCustomerIdRes,
  IUserByCustomer,
  SetUserRolesReq,
  SetUserRolesRes,
  UnassignRoleToUserReq,
  UpdateUserReq,
  UpdateUserRes,
} from './dtos/entities';
import { UsersService } from './users.service';
import { Response } from 'express';

@ApiInternalOnlyController()
@ApiTags('Users')
@Controller('users')
@ApiHeaders([{ name: 'dadosfera-lang', enum: LanguageEnum, required: false }])
@Authenticated()
@UseFilters(GrpcToHttpExceptionFilter)
export class UsersController {
  logger: DadosferaLogger;

  constructor(
    @Inject(DadosferaLogger)
    dadosferaLogger: DadosferaLogger,
    private userService: UsersService,
  ) {
    this.logger = dadosferaLogger.logger;
  }

  @Get()
  async getAllUsersByCustomerId(
    @User() user: RequestUser,
    @Language() language: LanguageEnum,
  ): Promise<GetAllUsersByCustomerIdRes> {
    this.logger.info('getAllUsersByCustomerId', { user });
    this.userService.setLanguage(language);
    return await this.userService.findAllUsersByCustomerId(user.customer_id);
  }

  @Get('/download')
  @RequireSomePermission(PERMISSIONS_GROUPS.USERS.permissions.ADMIN)
  async downloadUsersInCsv(
    @User() user: RequestUser,
    @Language() language: LanguageEnum,
    @Res() res: Response
  ) {
    this.logger.info('downloadUsersInCsv');
    this.userService.setLanguage(language);
    const {
      file,
      filename
    } = await this.userService.downloadUsersInCsv(user.customer_id);

    res.setHeader('Content-Disposition', `attachment; filename="${filename}"`);
    res.setHeader('Content-Type', 'text/csv');

    res.end(file);
  }

  @Get('hierarchies')
  @RequireAllPermissions(PERMISSIONS_GROUPS.USERS.permissions.ADMIN)
  @ApiOkResponse({ type: GetAllHierarchiesRes })
  async getAllHierarchies(
    @User() user: RequestUser,
    @Language() language: LanguageEnum,
  ): Promise<GetAllHierarchiesRes> {
    this.logger.info('getAllHierarchies', { user });
    this.userService.setLanguage(language);
    return await this.userService.getAllHierarchies();
  }

  @Get('departments')
  @RequireAllPermissions(PERMISSIONS_GROUPS.USERS.permissions.ADMIN)
  @ApiOkResponse({ type: GetAllDepartmentsRes })
  async getAllDepartments(
    @User() user: RequestUser,
    @Language() language: LanguageEnum,
  ): Promise<GetAllDepartmentsRes> {
    this.logger.info('getAllHierarchies', { user });
    this.userService.setLanguage(language);
    return await this.userService.getAllDepartments(user.customer_id);
  }

  @Get('jobTitles')
  @RequireAllPermissions(PERMISSIONS_GROUPS.USERS.permissions.ADMIN)
  @ApiOkResponse({ type: GetAllDepartmentsRes })
  async getAllJobTitles(
    @User() user: RequestUser,
    @Language() language: LanguageEnum,
  ): Promise<GetAllJobTitlesRes> {
    this.logger.info('getAllHierarchies', { user });
    this.userService.setLanguage(language);
    return await this.userService.getAllJobTitles(user.customer_id);
  }

  @Get(':id')
  @ApiOkResponse({
    type: IUserByCustomer,
  })
  async findOneById(
    @User() user: RequestUser,
    @Param('id') id: string,
    @Language() language: LanguageEnum,
  ) {
    this.logger.info('findOneById', { user });
    this.userService.setLanguage(language);
    if (
      id !== user.user_id &&
      !user.permissions.includes(
        PERMISSIONS_GROUPS.USERS.permissions.ADMIN.seqid,
      )
    ) {
      throw new ErrorBuilder(ErrorCodes.AUTH.FORBIDDEN);
    }
    return await this.userService.findOneById(id);
  }

  @Post()
  @RequireAllPermissions(PERMISSIONS_GROUPS.USERS.permissions.ADMIN)
  @ApiCreatedResponse({ type: CreateUserRes })
  async createUser(
    @User() user: RequestUser,
    @Body() body: CreateUserReq,
    @Language() language: LanguageEnum,
  ) {
    const metadata = PackTheMetadata({
      access_token: user.access_token,
      language,
    });
    this.logger.info('createUser', { user });
    this.userService.setLanguage(language);

    return await this.userService.createUser(body, metadata);
  }

  @Post('batch')
  @RequireAllPermissions(PERMISSIONS_GROUPS.USERS.permissions.ADMIN)
  @ApiCreatedResponse({ type: BatchCreateUserRes })
  async batchCreateUser(
    @User() user: RequestUser,
    @Body() body: BatchCreateUserReq,
    @Language() language: LanguageEnum,
  ) {
    this.logger.info('batchCreateUser', { user });
    this.userService.setLanguage(language);

    const metadata = PackTheMetadata({
      access_token: user.access_token,
      language,
    });

    return await this.userService.batchCreateUser(body, metadata);
  }

  @Post(':id/resend-invite')
  @RequireAllPermissions(PERMISSIONS_GROUPS.USERS.permissions.ADMIN)
  @HttpCode(HttpStatus.OK)
  async resendInvite(
    @User() user: RequestUser,
    @Param('id') id: string,
    @Language() language: LanguageEnum,
  ) {
    this.logger.info('resendInvite', { user });
    this.userService.setLanguage(language);

    const metadata = PackTheMetadata({
      language,
    });
    return this.userService.resendInvite({ id }, metadata);
  }

  @Delete('role')
  @RequireAllPermissions(PERMISSIONS_GROUPS.USERS.permissions.ADMIN)
  async unassignRoleToUser(
    @User() user: RequestUser,
    @Query() request: UnassignRoleToUserReq,
    @Language() language: LanguageEnum,
  ) {
    this.logger.info('unassignRoleToUser', { user });
    this.userService.setLanguage(language);
    return await this.userService.unassignRoleFromUser(request);
  }

  @Delete(':id')
  @RequireAllPermissions(PERMISSIONS_GROUPS.USERS.permissions.ADMIN)
  @ApiOkResponse({ type: DeleteUserRes })
  async deleteUser(
    @User() user: RequestUser,
    @Param('id') id: string,
    @Language() language: LanguageEnum,
  ) {
    this.logger.info('deleteUser', { user });
    this.userService.setLanguage(language);
    return await this.userService.deleteUser({ id });
  }

  @Patch('roles')
  @RequireAllPermissions(PERMISSIONS_GROUPS.USERS.permissions.ADMIN)
  @ApiOkResponse({ type: SetUserRolesRes })
  async setUserRoles(
    @User() user: RequestUser,
    @Body() body: SetUserRolesReq,
    @Language() language: LanguageEnum,
  ) {
    this.logger.info('createUser', { user });
    this.userService.setLanguage(language);
    return await this.userService.setRoles(body, user.customer_id);
  }

  @Put('role')
  @RequireAllPermissions(PERMISSIONS_GROUPS.USERS.permissions.ADMIN)
  async assignRoleToUser(
    @User() user: RequestUser,
    @Body() body: AssignRoleToUserReq,
    @Language() language: LanguageEnum,
  ) {
    this.logger.info('assignRoleToUser', { user });
    this.userService.setLanguage(language);
    return await this.userService.assignRoleToUser(body);
  }

  @Patch(':id')
  @RequireAllPermissions(PERMISSIONS_GROUPS.USERS.permissions.ADMIN)
  @ApiOkResponse({ type: UpdateUserRes })
  async updateUser(
    @User() user: RequestUser,
    @Body() body: UpdateUserReq,
    @Param('id') id: string,
    @Language() language: LanguageEnum,
  ) {
    this.logger.info('updateUser', { user });
    this.userService.setLanguage(language);
    return await this.userService.updateUser(body, id, user.customer_id);
  }

  @Post('synchronize/:id')
  @RequireAllPermissions(PERMISSIONS_GROUPS.DADOSFERA.permissions.SYNC_USER)
  @ApiOkResponse({ type: UpdateUserRes })
  async synchronizeUser(@User() user: RequestUser, @Param('id') id: string) {
    this.logger.info('synchronizeUser', { user });
    return await this.userService.synchronizeUser(id);
  }
}