import {
  Body,
  Controller,
  Post,
  ValidationPipe,
  Request as httpRequest,
  Delete,
  ParseIntPipe,
  Param,
  Get,
  Query,
  UnauthorizedException,
} from "@nestjs/common";
import { ApiBearerAuth } from "@nestjs/swagger";
import { CommentDetailsDto } from "./dto/comment-details.dto";
import { CreateRequestDto } from "./dto/create-request.dto";
import { SearchRequestDto } from "./dto/search-request.dto";
import { UpdateRequestDto } from "./dto/update-request.dto";
import { Request } from "./entity/request.entity";
import { RequestActivityLog } from "./entity/requestActivityLog.entity";
import { RequestService } from "./request.service";
import { RequestEvents } from "./types/request-event-type.interface";

/**
 * Controller responsible for handling requests related to turo requests operations.
 */
@ApiBearerAuth("access-token")
@Controller("request")
export class RequestController {
  constructor(private readonly requestService: RequestService) {}

  /**
   * Creates request in turo
   * @param {CreateRequestDto} request
   * @param {httpRequest} req
   * @returns Promise that resolves to created request in turo
   */
  @Post("create")
  async createRequest(
    @Body(ValidationPipe) request: CreateRequestDto,
    @httpRequest() req,
  ): Promise<Request> {
    return this.requestService.createRequest(request, req.user.id);
  }

  /**
   * Updates existing request in turo
   * @param {number} requestId
   * @param {UpdateRequestDto} request
   * @param {httpRequest} req
   * @returns Promise that resolves to updated request in turo
   */
  @Post(":id")
  async updateRequest(
    @Param("id", new ParseIntPipe()) requestId: number,
    @Body(ValidationPipe) updatedRequest: UpdateRequestDto,
    @httpRequest() req,
  ): Promise<Request> {
    const request = await this.requestService.getRequestDetails(requestId);

    if (![request.assignedTo, request.requestedBy].flat().includes(req.user.id)) {
      throw new UnauthorizedException();
    }

    return this.requestService.updateRequest(requestId, updatedRequest, req.user.id);
  }

  /**
   * Deletes existing request in turo
   * @param {number} requestId
   * @returns Promise that resolves to deleted request in turo
   */
  @Delete(":id")
  async deleteRequest(
    @Param("id", new ParseIntPipe()) requestId: number,
    @httpRequest() req,
  ): Promise<Request> {
    const request = await this.requestService.getRequestDetails(requestId);

    if (![request.assignedTo, request.requestedBy].flat().includes(req.user.id)) {
      throw new UnauthorizedException();
    }

    return this.requestService.requestCancellation(requestId);
  }

  /**
   * Get details for request in turo
   * with input requestId
   * @param {number} requestId
   * @returns request details object
   */
  @Get(":id")
  async getRequestDetails(
    @Param("id", new ParseIntPipe()) requestId: number,
  ): Promise<Request> {
    return this.requestService.getRequestDetails(requestId);
  }

  /**
   * Function to log activity to request and send approve signal
   * to running workflow
   * @param {number} requestId
   * @param {CommentDetailsDto} commentDetailsDto
   * @param {httpRequest} req
   * @returns void
   */
  @Post(":requestId/approve")
  async approveRequest(
    @Param("requestId", new ParseIntPipe()) requestId: number,
    @Body(ValidationPipe) commentDetailsDto: CommentDetailsDto,
    @httpRequest() req,
  ): Promise<void> {
    const request = await this.requestService.getRequestDetails(requestId);
    if (!request.assignedTo.includes(req.user.id)) {
      throw new UnauthorizedException();
    }

    this.requestService.logActivity(
      requestId,
      req.user.id,
      RequestEvents.COMMENT,
      commentDetailsDto,
    );
    return this.requestService.approveRequest(requestId, req.user.id);
  }

  /**
   * Function to log activity to request and send decline signal
   * to running workflow
   * @param {number} requestId
   * @param {CommentDetailsDto} commentDetailsDto
   * @param {httpRequest} req
   * @returns void
   */
  @Post(":requestId/decline")
  async declineRequest(
    @Param("requestId", new ParseIntPipe()) requestId: number,
    @Body(ValidationPipe) commentDetailsDto: CommentDetailsDto,
    @httpRequest() req,
  ): Promise<void> {
    const request = await this.requestService.getRequestDetails(requestId);
    if (!request.assignedTo.includes(req.user.id)) {
      throw new UnauthorizedException();
    }

    this.requestService.logActivity(
      requestId,
      req.user.id,
      RequestEvents.COMMENT,
      commentDetailsDto,
    );
    return this.requestService.declineRequest(requestId, req.user.id);
  }

  /**
   * Function to search a request based on
   * input query object
   * @param {SearchRequestDto} searchRequestDto
   * @returns Promise that resolves to request array
   */
  @Get("")
  search(@Query() searchRequestDto: SearchRequestDto): Promise<Request[]> {
    if (searchRequestDto.assignedTo) {
      searchRequestDto.assignedTo = {
        hasSome: [searchRequestDto.assignedTo],
      } as any;
    }
    return this.requestService.requests({ where: searchRequestDto as any });
  }

  /**
   * Function to add a comment to request objects
   * with input requestId
   * @param {number} requestId
   * @param {CommentDetailsDto} commentDetailsDto
   * @param {httpRequest} req
   * @returns Promise that resolves to newly request activity log object
   */
  @Post(":requestId/comment")
  addComment(
    @Param("requestId", new ParseIntPipe()) requestId: number,
    @Body(ValidationPipe) commentDetailsDto: CommentDetailsDto,
    @httpRequest() req,
  ): Promise<RequestActivityLog> {
    return this.requestService.logActivity(
      requestId,
      req.user.id,
      RequestEvents.COMMENT,
      commentDetailsDto,
    );
  }
}