import {
  Body,
  Controller,
  Post,
  UseGuards,
  Request,
  Get,
  Param,
  Query,
  ServiceUnavailableException,
  Inject,
  UnauthorizedException,
  BadRequestException,
  UseInterceptors,
} from "@nestjs/common";
import { DocuSignService } from "./docusign.service";
import { RolesAuthGuard } from "src/auth/guards/roles-auth.guard";
import { SendContractDto } from "./dtos/send-contract.dto";
import { AuthRequest, EndUserRoles } from "src/common/interfaces";
import { FilterContractStatusDto } from "./dtos/filter-status.dto";
import { UserService } from "src/user/user.service";
import { CustomCacheInterceptor } from "src/interceptor/cache.interceptor";
import { AuthGuard } from "@nestjs/passport";

@Controller("api/v1/docusign")
export class DocuSignController {
  @Inject(UserService)
  private readonly userService: UserService;
  constructor(private readonly docuSignService: DocuSignService) {}

  @UseGuards(new RolesAuthGuard(["dealer", "investor"]))
  @Post("/")
  async sendContract(
    @Request() request: AuthRequest,
    @Body() sendContractDto: SendContractDto,
  ) {
    try {
      await this.userService.checkIfUserIsAllowedToFund(
        request.user,
        sendContractDto.fundId,
      );
      return await this.docuSignService.createAnEnvelope({
        ...sendContractDto,
        dealerEmail: request.user.email,
      });
    } catch (error) {
      console.error(error);
      if (error.status === 401) {
        throw new UnauthorizedException(error);
      }
      if (error.status === 400) {
        throw new BadRequestException(error);
      }
      throw new ServiceUnavailableException(error);
    }
  }

  @UseInterceptors(CustomCacheInterceptor)
  @UseGuards(new RolesAuthGuard(["dealer"]))
  @Get("/")
  async getDealerSubmittedDocuments(
    @Request() request: AuthRequest,
    @Query() filterContractStatusDto: FilterContractStatusDto,
  ) {
    try {
      return await this.docuSignService.getDealerSubmittedDocuments({
        customFieldName: "dealerEmail",
        customFieldValue: request.user.email,
        status: filterContractStatusDto.status,
        docuSignStatus: filterContractStatusDto.docuSignStatus,
      });
    } catch (error) {
      console.error(error);
      throw new ServiceUnavailableException(error);
    }
  }

  @UseInterceptors(CustomCacheInterceptor)
  @UseGuards(AuthGuard("jwt"))
  @Get("/custom-fields/:orderId")
  async fetchCustomField(
    @Request() request: AuthRequest,
    @Param("orderId") orderId: string,
  ) {
    try {
      if (request.user.role === "admin") {
        return this.docuSignService.fetchCustomFields(orderId);
      }
      const customFields = await this.docuSignService.fetchCustomFields(
        orderId,
      );
      const dealerEmailField = customFields.textCustomFields.find(
        (textField) => {
          return textField.name === "dealerEmail";
        },
      );
      if (
        dealerEmailField.value !== request.user.email &&
        request.user.role === EndUserRoles.dealer
      ) {
        throw new UnauthorizedException(
          "The dealer is not assigned to this order",
        );
      }
      await this.userService.checkIfUserIsAllowedToFund(
        request.user,
        customFields.textCustomFields.find((customField) => {
          if (customField.name === "fundId") {
            return customField;
          }
        }).value,
      );
      return customFields;
    } catch (error) {
      console.error(error);
      if (error.status === 401) {
        throw new UnauthorizedException(error);
      }
      throw new ServiceUnavailableException(error);
    }
  }

  @UseInterceptors(CustomCacheInterceptor)
  @UseGuards(AuthGuard("jwt"))
  @Get("/envelop/:orderId")
  async fetchEnvelop(
    @Request() request: AuthRequest,
    @Param("orderId") orderId: string,
  ) {
    try {
      return await this.docuSignService.fetchEnvelop(orderId, request.user);
    } catch (error) {
      console.error(error);
      if (error.status === 401) {
        throw new UnauthorizedException(error);
      }
      throw new ServiceUnavailableException(error);
    }
  }

  @UseInterceptors(CustomCacheInterceptor)
  @UseGuards(AuthGuard("jwt"))
  @Get("/document/:orderId")
  async fetchDocument(
    @Request() request: AuthRequest,
    @Param("orderId") orderId: string,
  ) {
    try {
      return await this.docuSignService.fetchDocument(orderId, request.user);
    } catch (error) {
      console.error(error);
      if (error.status === 400) {
        throw new BadRequestException(error);
      }
      if (error.status === 401) {
        throw new UnauthorizedException(error);
      }
      throw new ServiceUnavailableException(error);
    }
  }

  @UseInterceptors(CustomCacheInterceptor)
  @UseGuards(new RolesAuthGuard(["fundAdmin", "admin"]))
  @Get("fund/")
  async getDocuments(
    @Request() req: AuthRequest,
    @Query() filterContractStatusDto: FilterContractStatusDto,
  ) {
    try {
      return await this.docuSignService.getContracts(
        req.user,
        filterContractStatusDto,
      );
    } catch (error) {
      console.error(error);
      throw new ServiceUnavailableException(error);
    }
  }
}