import {
  Controller,
  Get,
  Post,
  Body,
  Patch,
  Param,
  Delete,
  ParseIntPipe,
  Query,
  UseGuards,
} from "@nestjs/common"
import { VehicleModelService } from "./vehicle-model.service"
import { CreateVehicleModelDto } from "../dto/create-vehicle-model.dto"
import { UpdateVehicleModelDto } from "../dto/update-vehicle-model.dto"
import {
  ApiTags,
  ApiOperation,
  ApiResponse,
  ApiQuery,
  ApiBearerAuth,
  ApiBody,
} from "@nestjs/swagger"
import { VehicleModel } from "../entities/vehicle-model.entity"
import { AuthGuardMiddleware } from "src/middleware/auth-guard.middleware"

@ApiTags("Vehicle Models")
@UseGuards(AuthGuardMiddleware)
@ApiBearerAuth("access-token")
@Controller("vehicle-models")
export class VehicleModelController {
  constructor(private readonly vehicleModelService: VehicleModelService) {}

  @Post()
  @ApiOperation({
    summary: "Create a new vehicle model",
    description:
      "Creates a new vehicle model with manufacturer and type associations",
  })
  @ApiBody({
    type: CreateVehicleModelDto,
    description: "Vehicle model data including manufacturer and type IDs",
  })
  @ApiResponse({
    status: 201,
    description: "Vehicle model created successfully",
    type: VehicleModel,
  })
  @ApiResponse({
    status: 400,
    description: "Invalid input data or validation error",
  })
  @ApiResponse({
    status: 401,
    description: "Unauthorized - Authentication required",
  })
  create(@Body() createVehicleModelDto: CreateVehicleModelDto) {
    return this.vehicleModelService.create(createVehicleModelDto)
  }

  @Get()
  @ApiOperation({
    summary: "Get all vehicle models with pagination, search and filters",
    description:
      "Retrieves a list of vehicle models with optional filtering by manufacturer, type, and search term",
  })
  @ApiQuery({
    name: "limit",
    required: false,
    type: Number,
    description: "Number of items to take (pagination)",
  })
  @ApiQuery({
    name: "skip",
    required: false,
    type: Number,
    description: "Number of items to skip (pagination)",
  })
  @ApiQuery({
    name: "search",
    required: false,
    type: String,
    description: "Search term for vehicle model name",
  })
  @ApiQuery({
    name: "sortBy",
    required: false,
    type: String,
    description: "Sort column: id, name, created_at, updated_at",
  })
  @ApiQuery({
    name: "sortOrder",
    required: false,
    type: String,
    enum: ["ASC", "DESC"],
    description: "Sort order: ASC or DESC",
  })
  @ApiQuery({
    name: "manufacturer_ids",
    required: false,
    type: [Number],
    description: "Filter by manufacturer IDs (array)",
    isArray: true,
  })
  @ApiQuery({
    name: "type_ids",
    required: false,
    type: [Number],
    description: "Filter by vehicle type IDs (array)",
    isArray: true,
  })
  @ApiResponse({
    status: 200,
    description: "List of vehicle models retrieved successfully",
    type: [VehicleModel],
  })
  @ApiResponse({
    status: 401,
    description: "Unauthorized - Authentication required",
  })
  findAll(
    @Query("limit", new ParseIntPipe({ optional: true })) limit?: string,
    @Query("skip", new ParseIntPipe({ optional: true })) skip?: string,
    @Query("search") search?: string,
    @Query("sortBy") sortBy?: string,
    @Query("sortOrder") sortOrder?: string,
    @Query("manufacturer_ids") manufacturerIds?: any,
    @Query("type_ids") typeIds?: any,
  ) {
    return this.vehicleModelService.findAll(
      limit,
      skip,
      search,
      sortBy,
      sortOrder,
      manufacturerIds,
      typeIds,
    )
  }

  @Get(":id")
  @ApiOperation({
    summary: "Get a vehicle model by id",
    description:
      "Retrieves detailed information about a specific vehicle model including manufacturer and type details",
  })
  @ApiResponse({
    status: 200,
    description: "Vehicle model retrieved successfully",
    type: VehicleModel,
  })
  @ApiResponse({
    status: 404,
    description: "Vehicle model not found",
  })
  @ApiResponse({
    status: 401,
    description: "Unauthorized - Authentication required",
  })
  findOne(@Param("id", ParseIntPipe) id: number) {
    return this.vehicleModelService.findOne(id)
  }

  @Patch(":id")
  @ApiOperation({
    summary: "Update a vehicle model",
    description: "Updates an existing vehicle model's information",
  })
  @ApiBody({
    type: UpdateVehicleModelDto,
    description: "Updated vehicle model data",
  })
  @ApiResponse({
    status: 200,
    description: "Vehicle model updated successfully",
    type: VehicleModel,
  })
  @ApiResponse({
    status: 404,
    description: "Vehicle model not found",
  })
  @ApiResponse({
    status: 401,
    description: "Unauthorized - Authentication required",
  })
  update(
    @Param("id", ParseIntPipe) id: number,
    @Body() updateVehicleModelDto: UpdateVehicleModelDto,
  ) {
    return this.vehicleModelService.update(id, updateVehicleModelDto)
  }

  @Delete(":id")
  @ApiOperation({
    summary: "Delete a vehicle model",
    description: "Soft deletes a vehicle model from the system",
  })
  @ApiResponse({
    status: 200,
    description: "Vehicle model deleted successfully",
  })
  @ApiResponse({
    status: 404,
    description: "Vehicle model not found",
  })
  @ApiResponse({
    status: 401,
    description: "Unauthorized - Authentication required",
  })
  remove(@Param("id", ParseIntPipe) id: number) {
    return this.vehicleModelService.remove(id)
  }
}