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

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

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

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

import { CustomCacheInterceptor } from "src/interceptor/cache.interceptor";
import { SettlementService } from "./settlement.service";
import { CreateSettlementDto } from "./dto/create-settlement.dto";
import { apolloClient, getFundIdByOrderbookQuery } from "src/common/provider";
import { ApolloQueryResult } from "@apollo/client";
import { FilterPaginationDto } from "src/shared/dto/filter-pagination.dto";

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

  @Inject(SettlementService)
  private readonly settlementService: SettlementService;

  @UseGuards(new RolesAuthGuard(["admin"]))
  @Post("/:orderbookId/settlement")
  async setSettlement(
    @Param("orderbookId") orderbookId: string,
    @Body() createSettlementDto: CreateSettlementDto,
  ) {
    try {
      return await this.settlementService.create({
        ...createSettlementDto,
        orderbookId,
      });
    } catch (error) {
      console.error(error);
      throw new ServiceUnavailableException(error);
    }
  }

  @UseGuards(new RolesAuthGuard(["admin", "fundAdmin"]))
  @Get("/settlement")
  async getAllSettlement(
    @Request() request: AuthRequest,
    @Query() filterPaginationDto: FilterPaginationDto,
  ) {
    try {
      return await this.settlementService.getAllSettlements({
        userJwt: request.user,
        ...filterPaginationDto,
      });
    } catch (error) {
      if (error.status === 400) {
        throw new BadRequestException(error);
      }
      console.error(error);
      throw new ServiceUnavailableException(error);
    }
  }

  @UseGuards(new RolesAuthGuard(["admin", "fundAdmin"]))
  @Get("/:orderbookId/settlement")
  async getSettlement(
    @Request() request: AuthRequest,
    @Param("orderbookId") orderbookId: string,
  ) {
    try {
      if (request.user.role === "admin") {
        return await this.settlementService.getSettlementByOrderBookId({
          orderbookId,
          userJwt: request.user,
        });
      }
      const orderBooks: ApolloQueryResult<IGetFundIdByOrderbookQuery> =
        await apolloClient.query({
          query: getFundIdByOrderbookQuery,
          variables: {
            orderBookId: orderbookId,
          },
        });
      if (orderBooks.errors) {
        console.error(orderBooks.errors[0]);
        throw new ServiceUnavailableException(orderBooks.error);
      }

      if (!orderBooks.data.getOrderByIdQuery.fund.id) {
        throw new BadRequestException(
          `No orderbook with address ${orderbookId}`,
        );
      }

      return await this.settlementService.getSettlementByOrderBookId({
        orderbookId,
        fundId: orderBooks.data.getOrderByIdQuery.fund.id,
        userJwt: request.user,
      });
    } catch (error) {
      if (error.status === 400) {
        throw new BadRequestException(error);
      }
      console.error(error);
      throw new ServiceUnavailableException(error);
    }
  }

  @UseInterceptors(CustomCacheInterceptor)
  @UseGuards(AuthGuard("jwt"))
  @Get("/order")
  async getAllOrders(
    @Request() request: AuthRequest,
    @Query() filterOrderDto?: FilterOrderDto,
  ) {
    try {
      const { role } = request.user;
      if (role === "admin" || role === EndUserRoles.fundAdmin) {
        return await this.orderbook.getAllOrders(request, filterOrderDto);
      }

      return await this.orderbook.getMyOrders({
        request,
        ...filterOrderDto,
      });
    } catch (error) {
      console.error(error);
      throw new ServiceUnavailableException(error);
    }
  }

  @UseInterceptors(CustomCacheInterceptor)
  @UseGuards(AuthGuard("jwt"))
  @Get("/order/:id")
  async getOrderById(@Request() request: AuthRequest, @Param("id") id) {
    try {
      return await this.orderbook.getOrderById({
        orderId: id,
        request,
      });
    } catch (error) {
      console.error(error);
      throw new ServiceUnavailableException(error);
    }
  }
}