import { Body, Controller, Delete, Get, HttpCode, HttpStatus, Param, Patch, Post, Query, Res } from "@nestjs/common";
import { ApiOperation } from "@nestjs/swagger";
import { FastifyReply } from "fastify";

import { ChangeEmailDto } from "./DTO/change-email.dto";
import { CheckValidityDTO } from "./DTO/check-validity.dto";
import { CreateAdminDto } from "./DTO/create-admin.dto";
import { CreateCustomerDto } from "./DTO/create-customer.dto";
import { CreateLegalUserDto } from "./DTO/create-legal-user.dto";
import { CreateRealUserDto } from "./DTO/create-real-user.dto";
import { CreateRoleDto } from "./DTO/create-role.dto";
import { SearchAdminQueryDto } from "./DTO/search-admins-query.dto";
import { SearchCustomersDto } from "./DTO/search-customers.dto";
import { SearchRolesQueryDto } from "./DTO/search-roles.dto";
import { UpdateAdminDto } from "./DTO/update-admin.dto";
import { UpdateCustomerDto } from "./DTO/update-customer.dto";
import { UpdateRoleDto } from "./DTO/update-role.dto";
import { UpdateProfileDto } from "./DTO/update-profile.dto";
import { CreateUserGroupDto } from "./DTO/user-group.dto";
import { EmailVerifyQueryDto } from "./DTO/verify-email-query.dto";
import { PermissionEnum } from "./enums/permission.enum";
import { AdminsService } from "./providers/admins.service";
import { CustomersService } from "./providers/customers.service";
import { UsersService } from "./providers/users.service";
import { AdminRoute } from "../../common/decorators/admin.decorator";
import { AuthGuards } from "../../common/decorators/auth-guard.decorator";
import { PermissionsDec } from "../../common/decorators/permission.decorator";
import { SkipAuth } from "../../common/decorators/skip-auth.decorator";
import { IUserIpAndHeaders, UserDec, UserIpAndHeaders } from "../../common/decorators/user.decorator";
import { ParamDto } from "../../common/DTO/param.dto";
import { RequestOtpDto } from "../auth/DTO/request-otp.dto";
import { VerifyOtpDto } from "../auth/DTO/verify-otp.dto";
 
@AuthGuards()
@Controller("users")
export class UsersController {
  constructor(
    private readonly usersService: UsersService,
    private readonly adminsService: AdminsService,
    private readonly customersService: CustomersService,
  ) { }

  //----------------------- user -----------------------

  @ApiOperation({ summary: "Get user profile" })
  @Get("me")
  getMe(@UserDec("id") userId: string) {
    return this.usersService.getMe(userId);
  }

  @ApiOperation({ summary: "Get legal user data" })
  @Get("legal")
  getLegalUserData(@UserDec("id") userId: string) {
    return this.usersService.getLegalUserData(userId);
  }

  @ApiOperation({ summary: "Get real user data" })
  @Get("real")
  getRealUserData(@UserDec("id") userId: string) {
    return this.usersService.getRealUserData(userId);
  }

  @ApiOperation({ summary: "Create real user data ==> user route" })
  @Post("real")
  createRealUser(@Body() createDto: CreateRealUserDto, @UserDec("id") userId: string) {
    return this.customersService.createRealUserData(createDto, userId);
  }

  @ApiOperation({ summary: "Create legal user data ==> user route" })
  @Post("legal")
  createLegalUser(@Body() createDto: CreateLegalUserDto, @UserDec("id") userId: string) {
    return this.customersService.createLegalUserData(createDto, userId);
  }
  //----------------------- profile -----------------------

  @ApiOperation({ summary: "Update user profile" })
  @Patch("update-profile")
  updateProfile(@Body() updateProfileDto: UpdateProfileDto, @UserDec("id") userId: string) {
    return this.usersService.updateProfile(userId, updateProfileDto);
  }

  @ApiOperation({ summary: "change user email" })
  @Patch("change-email")
  changeEmail(@Body() changeEmailDto: ChangeEmailDto, @UserDec("id") userId: string) {
    return this.usersService.changeEmail(userId, changeEmailDto);
  }

  @ApiOperation({ summary: "Verify email" })
  @SkipAuth()
  @Get("verify-email")
  verifyEmail(@Query() queryDto: EmailVerifyQueryDto, @Res({ passthrough: true }) rep: FastifyReply) {
    return this.usersService.verifyEmail(queryDto, rep);
  }

  @ApiOperation({ summary: "change user phone" })
  @Patch("change-phone")
  changePhone(@Body() changeDto: RequestOtpDto, @UserDec("id") userId: string) {
    return this.usersService.changePhone(userId, changeDto);
  }

  @ApiOperation({ summary: "Verify phone" })
  @HttpCode(HttpStatus.OK)
  @Patch("verify-phone")
  verifyPhone(@Body() verifyOtpDto: VerifyOtpDto, @UserDec("id") userId: string) {
    return this.usersService.verifyPhone(verifyOtpDto, userId);
  }
  //
  @ApiOperation({ summary: "Check validity of user field" })
  @HttpCode(HttpStatus.OK)
  @Post("check-validity")
  checkValidity(@Body() checkValidityDto: CheckValidityDTO, @UserDec("id") userId: string) {
    return this.usersService.checkValidity(checkValidityDto, userId);
  }

  @ApiOperation({ summary: "Create user group ==> admin route" })
  @PermissionsDec(PermissionEnum.ADMINS_CREATE, PermissionEnum.CUSTOMERS_CREATE)
  @Post("user-group")
  createUserGroup(@Body() createDto: CreateUserGroupDto) {
    return this.usersService.createUserGroup(createDto);
  }

  @ApiOperation({ summary: "get all user group ==> admin route" })
  @PermissionsDec(PermissionEnum.CUSTOMERS_READ)
  @Get("user-group")
  UserGroups() {
    return this.usersService.getUserGroups();
  }

  @ApiOperation({ summary: "get all users ==> admin route" })
  @PermissionsDec(PermissionEnum.CUSTOMERS_READ)
  @Get()
  getUsers() {
    return this.usersService.findAllUsers();
  }
  //----------------------- customer -----------------------

  @ApiOperation({ summary: "Create customer" })
  @HttpCode(HttpStatus.CREATED)
  @PermissionsDec(PermissionEnum.CUSTOMERS_CREATE)
  @Post("customers")
  createCustomer(@Body() createDto: CreateCustomerDto, @UserIpAndHeaders() userIpAndHeaders: IUserIpAndHeaders) {
    return this.customersService.createCustomer(createDto, userIpAndHeaders);
  }

  @ApiOperation({ summary: "Update customer" })
  @PermissionsDec(PermissionEnum.CUSTOMERS_UPDATE)
  @Patch("customers/:id")
  updateCustomer(
    @Param() paramDto: ParamDto,
    @Body() updateDto: UpdateCustomerDto,
    @UserIpAndHeaders() userIpAndHeaders: IUserIpAndHeaders,
  ) {
    return this.customersService.updateCustomer(paramDto.id, updateDto, userIpAndHeaders);
  }

  @ApiOperation({ summary: "get customers ==> admin route" })
  @PermissionsDec(PermissionEnum.CUSTOMERS_READ)
  @Get("customers")
  getCustomers(@Query() queryDto: SearchCustomersDto) {
    return this.customersService.getCustomers(queryDto);
  }

  @ApiOperation({ summary: "get customers by id ==> admin route" })
  @PermissionsDec(PermissionEnum.CUSTOMERS_READ)
  @Get("customers/:id")
  getCustomerById(@Param() paramDto: ParamDto) {
    return this.customersService.getCustomerById(paramDto.id);
  }

  //----------------------- admin -----------------------

  @ApiOperation({ summary: "get all admins ==> admin route" })
  @AdminRoute()
  // @PermissionsDec(PermissionEnum.ADMINS_READ, PermissionEnum.CUSTOMERS_READ)
  @Get("admins")
  getAdmins(@Query() queryDto: SearchAdminQueryDto) {
    return this.adminsService.getAdmins(queryDto);
  }

  @ApiOperation({ summary: "get admin by id ==> admin route" })
  @PermissionsDec(PermissionEnum.ADMINS_READ, PermissionEnum.CUSTOMERS_READ)
  @Get("admins/:id")
  getAdminById(@Param() paramDto: ParamDto) {
    return this.adminsService.getAdminById(paramDto.id);
  }

  @ApiOperation({ summary: "update admin ==> admin route" })
  @PermissionsDec(PermissionEnum.ADMINS_UPDATE, PermissionEnum.CUSTOMERS_UPDATE)
  @Patch("admins/:id")
  updateAdmin(@Param() paramDto: ParamDto, @Body() updateDto: UpdateAdminDto, @UserIpAndHeaders() userIpAndHeaders: IUserIpAndHeaders) {
    return this.adminsService.updateAdmin(paramDto.id, updateDto, userIpAndHeaders);
  }

  @ApiOperation({ summary: "delete admin ==> admin route" })
  @PermissionsDec(PermissionEnum.ADMINS_DELETE, PermissionEnum.CUSTOMERS_DELETE)
  @Delete("admins/:id")
  deleteAdmin(@Param() paramDto: ParamDto, @UserIpAndHeaders() userIpAndHeaders: IUserIpAndHeaders) {
    return this.adminsService.deleteAdmin(paramDto.id, userIpAndHeaders);
  }

  @ApiOperation({ summary: "create admin ==> admin route" })
  @PermissionsDec(PermissionEnum.ADMINS_CREATE, PermissionEnum.CUSTOMERS_CREATE)
  @Post("admins")
  createAdmin(@Body() createDto: CreateAdminDto, @UserIpAndHeaders() userIpAndHeaders: IUserIpAndHeaders) {
    return this.adminsService.createAdmin(createDto, userIpAndHeaders);
  }

  @ApiOperation({ summary: "get admin permissions" })
  @Get("admin-permissions")
  getAdminPermissions(@UserDec("id") userId: string) {
    return this.adminsService.getAdminPermissions(userId);
  }

  @ApiOperation({ summary: "get all permissions ==> admin route" })
  @PermissionsDec(PermissionEnum.ADMINS_READ, PermissionEnum.CUSTOMERS_READ)
  @Get("permissions")
  getPermissions() {
    return this.adminsService.getPermissions();
  }

  @ApiOperation({ summary: "get all roles ==> admin route" })
  @PermissionsDec(PermissionEnum.ADMINS_READ, PermissionEnum.CUSTOMERS_READ)
  @Get("roles")
  getRoles(@Query() queryDto: SearchRolesQueryDto) {
    return this.adminsService.getRoles(queryDto);
  }

  @ApiOperation({ summary: "get role by id ==> admin route" })
  @PermissionsDec(PermissionEnum.ADMINS_READ, PermissionEnum.CUSTOMERS_READ)
  @Get("roles/:id")
  getRoleById(@Param() paramDto: ParamDto) {
    return this.adminsService.getRoleById(paramDto.id);
  }

  @ApiOperation({ summary: "create role ==> admin route" })
  @PermissionsDec(PermissionEnum.ADMINS_CREATE, PermissionEnum.CUSTOMERS_CREATE)
  @Post("roles")
  createRole(@Body() createDto: CreateRoleDto) {
    return this.adminsService.createRole(createDto);
  }

  @ApiOperation({ summary: "update role ==> admin route" })
  @PermissionsDec(PermissionEnum.ADMINS_UPDATE, PermissionEnum.CUSTOMERS_UPDATE)
  @Patch("roles/:id")
  updateRole(@Param() paramDto: ParamDto, @Body() updateDto: UpdateRoleDto) {
    return this.adminsService.updateRole(paramDto.id, updateDto);
  }

  @ApiOperation({ summary: "delete role ==> admin route" })
  @PermissionsDec(PermissionEnum.ADMINS_DELETE, PermissionEnum.CUSTOMERS_DELETE)
  @Delete("roles/:id")
  deleteRole(@Param() paramDto: ParamDto) {
    return this.adminsService.deleteRole(paramDto.id);
  }
}