import {
  BadRequestException,
  Body,
  Controller,
  Get,
  Inject,
  InternalServerErrorException,
  Param,
  Post,
  Put,
  Query,
  Req,
  UnauthorizedException,
  UseGuards,
} from "@nestjs/common";
import { RolesAuthGuard } from "src/auth/guards/roles-auth.guard";
import {
  AuthRequest,
  EndUserRoles,
  RequestStatus,
} from "src/common/interfaces";

import { FundAdminService } from "./fundAdmin.service";
import { UserService } from "./user.service";
import { RequestAccessStatusDto } from "./dto/updateAccess-request.dto";
import { RequestAccessByStatusDto } from "./dto/requestAccess-status.dto";
import { FundDocument } from "src/security/schemas/fund.schema";
import { SetInvestorAccessDto } from "./dto/set-investor-access.dto";
import { AuthGuard } from "@nestjs/passport";

@Controller("api/v1/user/fund-admin")
export class FundAdminController {
  @Inject(UserService)
  private readonly userService: UserService;
  constructor(private readonly fundAdminService: FundAdminService) {}

  @UseGuards(AuthGuard("jwt"))
  @Get("request-access/")
  async getAllPendingRequests(
    @Req() request: AuthRequest,
    @Query() requestAccessByStatusDto: RequestAccessByStatusDto,
  ) {
    try {
      if (request.user.role === "admin") {
        return await this.fundAdminService.aggregateQuery(
          requestAccessByStatusDto,
        );
      }
      const fundAdminOrDealer = await this.userService.findUserByProperty({
        email: request.user.email,
      });
      if (!fundAdminOrDealer) {
        throw new InternalServerErrorException("User doesn't exist.");
      }
      const usersId: string[] = [];
      if (request.user.role === EndUserRoles.dealer) {
        const users = await this.userService.findUsersByFilter({
          onboardByEmail: request.user.email,
        });

        usersId.push(...users.map((user) => user._id.toString()));
      }

      if (request.user.role === EndUserRoles.investor) {
        const users = await this.userService.findUsersByFilter({
          email: request.user.email,
        });
        usersId.push(...users.map((user) => user._id.toString()));
      }
      if (!fundAdminOrDealer.subscribedFunds.length) {
        return [];
      }

      if (!usersId.length && request.user.role !== EndUserRoles.fundAdmin) {
        return [];
      }
      const requestedAccess = await this.fundAdminService.getRequestsByFundsId(
        request.user.role,
        fundAdminOrDealer.subscribedFunds.map((fund) => fund.toString()),
        usersId,
        requestAccessByStatusDto,
      );
      return requestedAccess;
    } catch (error) {
      console.error(error);
      throw new InternalServerErrorException(error);
    }
  }

  @UseGuards(new RolesAuthGuard(["admin", "fundAdmin", "dealer"]))
  @Get("/request-access/:id")
  async getRequestAccess(@Req() request: AuthRequest, @Param("id") id: string) {
    try {
      if (request.user.role === "admin") {
        return await this.fundAdminService.getRequestDetails(id);
      }
      const requestDetails = await this.fundAdminService.getRequestDetails(id);

      await this.userService.checkIfUserIsAllowedToFund(
        request.user,
        (requestDetails.fundId as FundDocument)._id.toString(),
      );
      return requestDetails;
    } catch (error) {
      console.error(error);
      if (error.status === 401) {
        throw new UnauthorizedException(error);
      }
      throw new InternalServerErrorException(error);
    }
  }

  @UseGuards(new RolesAuthGuard(["admin", "fundAdmin"]))
  @Put("/request-access/:id")
  async updateRequest(
    @Req() request: AuthRequest,
    @Param("id") id: string,
    @Body() requestAccessStatusDto: RequestAccessStatusDto,
  ) {
    try {
      const requestDetails = await this.fundAdminService.getRequestDetails(id);
      await this.userService.checkIfUserIsAllowedToFund(
        request.user,
        (requestDetails.fundId as FundDocument)._id.toString(),
      );
      if (requestDetails.status === requestAccessStatusDto.status) {
        throw new BadRequestException("Request status didn't change");
      }
      if (
        requestDetails.status === RequestStatus.rejected &&
        requestAccessStatusDto.status === RequestStatus.accepted
      ) {
        throw new BadRequestException(
          "Dealer should submit a new request before accepting investor after rejection",
        );
      }
      return await this.fundAdminService.updateRequest(id, {
        currentRequest: requestDetails,
        status: requestAccessStatusDto.status,
        optionalComment: requestAccessStatusDto.optionalComment,
      });
    } catch (error) {
      console.error(error);
      if (error.status === 400) {
        throw new BadRequestException(error);
      }
      if (error.status === 401) {
        throw new UnauthorizedException(error);
      }
      throw new InternalServerErrorException(error);
    }
  }

  @UseGuards(new RolesAuthGuard(["admin", "fundAdmin"]))
  @Post("/request-access/instrument/investor")
  async setInstrumentAccessForInvestor(
    @Req() request: AuthRequest,
    @Body() setInvestorAccessDto: SetInvestorAccessDto,
  ) {
    try {
      return await this.fundAdminService.setInvestorAccessForInstrument(
        request.user,
        setInvestorAccessDto,
      );
    } catch (error) {
      console.error(error);
      if (error.status === 401) {
        throw new UnauthorizedException(error);
      }
      throw new InternalServerErrorException(error);
    }
  }
}