import {
  Request,
  Body,
  Controller,
  Post,
  UseGuards,
  Inject,
  ServiceUnavailableException,
  BadRequestException,
} from "@nestjs/common";

import { RolesAuthGuard } from "src/auth/guards/roles-auth.guard";
import { AuthRequest, EndUserRoles } from "src/common/interfaces";
import { OrderConfirmDto } from "./dto/confirm-order.dto";
import { OrderLockDto } from "./dto/lock-order.dto";

import { OrderDto } from "./dto/create-order.dto";

import { OrderBookService } from "./orderbook.service";
import { ForceOrderRedemptionDto } from "./dto/force-order.dto";
import { OrderCancelDto } from "./dto/cancel-order.dto";
import { OrderSettleDto } from "./dto/settle-order.dto";
import { OrderReBalanceDto } from "./dto/rebalance-order.dto";
import { FillRedemptionBookDto } from "./dto/fill-redemptionbook.dto";
import { AuthGuard } from "@nestjs/passport";

@Controller("api/v1/orderbook/redemption")
export class RedemptionOrderbookController {
  @Inject(OrderBookService)
  private readonly orderbook: OrderBookService;

  @UseGuards(new RolesAuthGuard(["dealer", "investor"]))
  @Post("/order")
  async createOrder(
    @Request() request: AuthRequest,
    @Body() orderDto: OrderDto,
  ) {
    try {
      if (
        request.user.role === "admin" ||
        request.user.role === EndUserRoles.dealer
      ) {
        return await this.orderbook.dealerCreateOrder({
          request,
          orderDto,
          type: "Redemption",
        });
      }
      if (request.user.role === EndUserRoles.investor && orderDto.investorId) {
        throw new BadRequestException("investor should not send investor Id");
      }
      return await this.orderbook.investorCreateOrder({
        request,
        orderDto,
        type: "Redemption",
      });
    } catch (error) {
      console.error(error);
      throw new ServiceUnavailableException(error);
    }
  }

  @UseGuards(new RolesAuthGuard(["admin", "dealer", "investor"]))
  @Post("/order/confirm")
  async confirmOrder(
    @Request() request: AuthRequest,
    @Body() orderDto: OrderConfirmDto,
  ) {
    try {
      if (
        request.user.role === "admin" ||
        request.user.role === EndUserRoles.dealer
      ) {
        return await this.orderbook.dealerConfirmOrder({
          request,
          orderDto,
          type: "Redemption",
        });
      }
      if (orderDto.investorId && orderDto.investorId.length > 0) {
        throw new BadRequestException("investor should not send investor Id");
      }
      return await this.orderbook.investorConfirmOrder({
        request,
        orderDto,
        type: "Redemption",
      });
    } catch (error) {
      throw new ServiceUnavailableException(error);
    }
  }

  @UseGuards(new RolesAuthGuard(["admin"]))
  @Post("/order/fill")
  async fillOrderBook(@Body() fillRedemptionBookDto: FillRedemptionBookDto) {
    try {
      return await this.orderbook.fillRedemptionBook(fillRedemptionBookDto);
    } catch (error) {
      console.error(error);
      if (error.status === 400) {
        throw new BadRequestException(error);
      }
      throw new ServiceUnavailableException(error);
    }
  }

  @UseGuards(AuthGuard("jwt"))
  @Post("/order/cancel")
  async cancelOrder(
    @Request() request: AuthRequest,
    @Body() orderDto: OrderCancelDto,
  ) {
    try {
      return await this.orderbook.cancelOrder({
        request,
        orderDto,
      });
    } catch (error) {
      throw new ServiceUnavailableException(error);
    }
  }

  @UseGuards(AuthGuard("jwt"))
  @Post("/order/lock")
  async lockOrder(
    @Request() request: AuthRequest,
    @Body() orderDto: OrderLockDto,
  ) {
    try {
      if (
        request.user.role === "admin" &&
        !orderDto.investorId &&
        !orderDto.dealerId
      ) {
        throw new BadRequestException(
          "Admin should send investor ID or dealer ID",
        );
      }

      if (request.user.role === "admin") {
        if (orderDto.dealerId) {
          return await this.orderbook.dealerLockRedemptionOrder({
            orderDto,
            request,
          });
        }

        if (orderDto.investorId) {
          return await this.orderbook.investorLockRedemptionOrder({
            orderDto,
            request,
          });
        }
      }

      if (request.user.role === EndUserRoles.dealer) {
        return await this.orderbook.dealerLockRedemptionOrder({
          orderDto,
          request,
        });
      }

      return await this.orderbook.investorLockRedemptionOrder({
        orderDto,
        request,
      });
    } catch (error) {
      console.error(error);
      if (error.status === 400) {
        throw new BadRequestException(error);
      }
      throw new ServiceUnavailableException(error);
    }
  }

  @UseGuards(new RolesAuthGuard(["admin", "fundAdmin"]))
  @Post("/order/settle")
  async settleOrder(
    @Request() request: AuthRequest,
    @Body() orderDto: OrderSettleDto,
  ) {
    try {
      const response = await this.orderbook.settleOrder({
        request,
        orderDto,
        type: "Redemption",
      });
      return response;
    } catch (error) {
      console.error(error);
      if (error.status === 400) {
        throw new BadRequestException(error);
      }
      throw new ServiceUnavailableException(error);
    }
  }

  @UseGuards(new RolesAuthGuard(["admin"]))
  @Post("/order/force")
  async forceRedemption(
    @Request() request: AuthRequest,
    @Body() orderDto: ForceOrderRedemptionDto,
  ) {
    try {
      const response = await this.orderbook.forceRedemption({
        userJwt: request.user,
        orderDto,
        type: "Redemption",
      });
      return response;
    } catch (error) {
      throw new ServiceUnavailableException(error);
    }
  }

  @UseGuards(new RolesAuthGuard(["admin"]))
  @Post("/order/rebalance")
  async reBalance(
    @Request() request: AuthRequest,
    @Body() orderDto: OrderReBalanceDto,
  ) {
    try {
      const response = await this.orderbook.reBalanceSettlement({
        userJwt: request.user,
        ...orderDto,
      });
      return response;
    } catch (error) {
      console.error(error);
      throw new ServiceUnavailableException(error);
    }
  }
}