import { Controller, Get, Post, Put, Delete, Body, Param, Query, HttpCode, HttpStatus, NotFoundException } from '@nestjs/common';
import { ApiTags, ApiOperation, ApiResponse, ApiBody } from '@nestjs/swagger';
import { PrismaService } from '../services/prisma.service';
import { PrismaClientKnownRequestError } from '@prisma/client/runtime/library';
import {
  CreateOrderItemDto,
  UpdateOrderItemDto,
  FindManyOrderItemDto,
  FlatQueryOrderItemDto,
  OrderItemResponseDto,
  OrderItemIdDto,
} from '../dto/orderitem';

@ApiTags('OrderItem')
@Controller('orderitem')
export class OrderItemController {
  constructor(private readonly prisma: PrismaService) {}

  @Post()
  @ApiOperation({ summary: 'Create a new OrderItem record', operationId: 'createOrderItem' })
  @ApiBody({ type: CreateOrderItemDto })
  @ApiResponse({ status: 201, description: 'Created OrderItem record', type: OrderItemResponseDto })
  async createOrderItem(@Body() data: CreateOrderItemDto): Promise<OrderItemResponseDto> {
    return this.prisma.orderItem.create({ data });
  }

  @Put(':id')
  @ApiOperation({ summary: 'Update a OrderItem record', operationId: 'updateOrderItem' })
  @ApiBody({ type: UpdateOrderItemDto })
  @ApiResponse({ status: 200, description: 'Updated OrderItem record', type: OrderItemResponseDto })
  @ApiResponse({ status: 404, description: 'OrderItem record not found' })
  async updateOrderItem(@Param() params: OrderItemIdDto, @Body() data: UpdateOrderItemDto): Promise<OrderItemResponseDto> {
    try {
      return await this.prisma.orderItem.update({ where: params, data });
    } catch (error) {
      if (error instanceof PrismaClientKnownRequestError && error.code === 'P2025') {
        throw new NotFoundException('OrderItem record not found');
      }
      throw error;
    }
  }

  @Get(':id')
  @ApiOperation({ summary: 'Get a OrderItem record by ID', operationId: 'getOrderItem' })
  @ApiResponse({ status: 200, description: 'OrderItem record', type: OrderItemResponseDto })
  @ApiResponse({ status: 404, description: 'OrderItem record not found' })
  async getOrderItem(@Param() params: OrderItemIdDto): Promise<OrderItemResponseDto> {
    try {
      return await this.prisma.orderItem.findUniqueOrThrow({ where: params });
    } catch (error) {
      if (error instanceof PrismaClientKnownRequestError && error.code === 'P2025') {
        throw new NotFoundException('OrderItem record not found');
      }
      throw error;
    }
  }

  @Get()
  @ApiOperation({ summary: 'Get a list of OrderItem records', operationId: 'getOrderItemList' })
  @ApiResponse({ status: 200, description: 'List of OrderItem records', type: [OrderItemResponseDto] })
  async getOrderItemList(@Query() query: FlatQueryOrderItemDto): Promise<OrderItemResponseDto[]> {
    return this.prisma.orderItem.findMany(query.toPrismaQuery());
  }

  @Post('search')
  @ApiOperation({ summary: 'Search OrderItem records', operationId: 'searchOrderItem' })
  @ApiBody({ type: FindManyOrderItemDto })
  @ApiResponse({ status: 200, description: 'List of OrderItem records', type: [OrderItemResponseDto] })
  async searchOrderItem(@Body() query: FindManyOrderItemDto): Promise<OrderItemResponseDto[]> {
    const { where, orderBy, take, skip } = query;
    return this.prisma.orderItem.findMany({
      where,
      orderBy,
      take,
      skip,
    });
  }

  @Delete(':id')
  @ApiOperation({ summary: 'Delete a OrderItem record', operationId: 'deleteOrderItem' })
  @HttpCode(HttpStatus.NO_CONTENT)
  @ApiResponse({ status: 204, description: 'OrderItem record deleted' })
  @ApiResponse({ status: 404, description: 'OrderItem record not found' })
  async deleteOrderItem(@Param() params: OrderItemIdDto): Promise<void> {
    try {
      await this.prisma.orderItem.delete({ where: params });
    } catch (error) {
      if (error instanceof PrismaClientKnownRequestError && error.code === 'P2025') {
        throw new NotFoundException('OrderItem record not found');
      }
      throw error;
    }
  }

}