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

import type { AuthRequest } from "src/common/interfaces";
import { EndUserRoles } from "src/common/interfaces";

import { RolesAuthGuard } from "src/auth/guards/roles-auth.guard";

import { OrderConfirmDto } from "./dto/confirm-order.dto";
import { OrderLockDto } from "./dto/lock-order.dto";
import { OrderDto } from "./dto/create-order.dto";
import { OrderSettleDto } from "./dto/settle-order.dto";

import { OrderBookService } from "./orderbook.service";
import { OrderCancelDto } from "./dto/cancel-order.dto";
import { AuthGuard } from "@nestjs/passport";

@Controller("api/v1/orderbook/subscription")
export class SubscriptionOrderbookController {
  @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 === EndUserRoles.dealer) {
        return await this.orderbook.dealerCreateOrder({
          request,
          orderDto,
          type: "Subscription",
        });
      }
      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: "Subscription",
      });
    } 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: "Subscription",
        });
      }
      if (orderDto.investorId && orderDto.investorId.length > 0) {
        throw new BadRequestException("investor should not send investor Id");
      }

      return await this.orderbook.investorConfirmOrder({
        request,
        orderDto,
        type: "Subscription",
      });
    } catch (error) {
      console.log({ 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 === EndUserRoles.dealer && !orderDto.investorId) {
        throw new BadRequestException("Investor ID is missing");
      }

      if (request.user.role === EndUserRoles.investor && orderDto.dealerId) {
        throw new BadRequestException(
          "Shouldn't send dealer ID if you are an investor",
        );
      }
      if (
        request.user.role === "admin" ||
        request.user.role === EndUserRoles.fundAdmin
      ) {
        return await this.orderbook.adminLockOrder({ orderDto, request });
      }

      if (request.user.role === EndUserRoles.dealer) {
        if (orderDto.dealerId && orderDto.dealerId.length > 0) {
          throw new BadRequestException("dealer should not send dealer Id");
        }
        return await this.orderbook.dealerLockSubscriptionOrder({
          orderDto,
          request,
        });
      }

      if (
        request.user.role === EndUserRoles.investor &&
        orderDto.investorId &&
        orderDto.investorId.length > 0
      ) {
        throw new BadRequestException("investor should not send investor Id");
      }
      if (request.user.role === EndUserRoles.investor) {
        return await this.orderbook.investorLockSubscriptionOrder({
          orderDto,
          request,
        });
      }
      throw new BadRequestException("Bad IDs");
    } catch (error) {
      console.error(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: "Subscription",
      });
      return response;
    } catch (error) {
      console.error(error);
      if (error.status === 400) {
        throw new BadRequestException(error);
      }
      throw new ServiceUnavailableException(error);
    }
  }
}