import {
  Body,
  Controller,
  Delete,
  Get,
  Param,
  ParseIntPipe,
  Patch,
  Post,
  Query,
  Req,
  UseGuards,
} from "@nestjs/common"
import {
  ApiBearerAuth,
  ApiBody,
  ApiOperation,
  ApiQuery,
  ApiResponse,
  ApiTags,
} from "@nestjs/swagger"
import { AuthGuardMiddleware } from "src/middleware/auth-guard.middleware"
import { DriverAvailabilityService } from "./driver-availability.service"
import { CreateBulkDriverAvailabilityDto } from "../dto/create-driver-availability.dto"
import { UpdateDriverAvailabilityDto } from "../dto/update-driver-availability.dto"
import { DriverAvailability } from "../entities/driver-availability.entity"

@ApiTags("Driver Availability")
@UseGuards(AuthGuardMiddleware)
@ApiBearerAuth("access-token")
@Controller("driver-availability")
export class DriverAvailabilityController {
  constructor(
    private readonly driverAvailabilityService: DriverAvailabilityService,
  ) {}

  @Post()
  @ApiOperation({ summary: "Create a new driver availability record" })
  @ApiResponse({
    status: 201,
    description: "Driver availability created successfully",
    type: DriverAvailability,
  })
  @ApiBody({
    schema: {
      type: "object",
      properties: {
        availability: {
          type: "array",
          items: {
            type: "object",
            properties: {
              day_of_week: { type: "string", example: "monday" },
              start_time: { type: "string", example: "09:00" },
              end_time: { type: "string", example: "18:00" },
              is_available: { type: "boolean", example: true },
            },
            required: ["day_of_week", "is_available"],
          },
        },
      },
    },
  })
  async create(@Req() req: any, @Body() body: CreateBulkDriverAvailabilityDto) {
    const driver_id = req.user?.user?.team_member_id
    console.log("userrrrr", req.user)
    console.log("driver_id", driver_id)
    const availabilityWithDriver = body.availability.map((item) => ({
      ...item,
      driver_id,
    }))

    return this.driverAvailabilityService.bulkCreate({
      availability: availabilityWithDriver,
    })
  }

  @Get()
  @ApiQuery({ name: "driver_id", required: true, type: Number })
  @ApiQuery({ name: "created_at", required: false, type: String })
  findAll(
    @Req() req: any,

    @Query("driver_id") driver_id?: any,
    @Query("created_at") created_at?: string,
  ) {
    // const loggedInDriverId = req.user?.user?.team_member_id

    return this.driverAvailabilityService.findAll({
      // driver_id: driver_id || loggedInDriverId,
      driver_id: driver_id,
      created_at,
    })
  }

  @Patch("update-duty-status")
  @ApiOperation({
    summary: "Save current duty status to history with optional overrides",
  })
  @ApiBody({
    schema: {
      type: "object",
      properties: {
        duty_status: { type: "string", example: "on-duty" },
        start_time: { type: "string", example: "2025-11-01T11:15:00.000Z" },
        end_time: { type: "string", example: "2025-11-01T18:30:00.000Z" },
      },
      required: [],
    },
  })
  @ApiResponse({
    status: 200,
    description: "Driver duty status saved to history successfully",
  })
  updateDutyStatus(@Req() req: any, @Body() body: any) {
    const driver_id = req.user?.user?.team_member_id

    return this.driverAvailabilityService.updateDutyStatus(driver_id, body)
  }

  @Get("history")
  @ApiOperation({ summary: "Get driver availability history by ID" })
  @ApiQuery({ name: "driver_id", required: true, type: Number })
  getDriverAvailabilityHistory(@Query("driver_id") driver_id: number) {
    return this.driverAvailabilityService.getDriverAvailabilityHistory(
      driver_id,
    )
  }

  @Get(":id")
  @ApiOperation({ summary: "Get driver availability by ID" })
  @ApiResponse({
    status: 200,
    description: "Return the driver availability record",
    type: DriverAvailability,
  })
  @ApiResponse({ status: 404, description: "Driver availability not found" })
  findOne(@Param("id", ParseIntPipe) id: number) {
    return this.driverAvailabilityService.findOne(id)
  }

  @Patch(":id")
  @ApiOperation({ summary: "Update a driver availability record" })
  @ApiResponse({
    status: 200,
    description: "Driver availability updated successfully",
    type: DriverAvailability,
  })
  @ApiResponse({ status: 404, description: "Driver availability not found" })
  @ApiBody({
    schema: {
      type: "object",
      properties: {
        start_time: { type: "string", example: "2025-11-01T11:15:00.000Z" },
        end_time: { type: "string", example: "2025-11-01T18:30:00.000Z" },
        is_available: { type: "boolean", example: true },
      },
      required: ["start_time", "end_time"],
    },
  })
  update(
    @Param("id", ParseIntPipe) id: number,
    @Body() updateDriverAvailabilityDto: UpdateDriverAvailabilityDto,
  ) {
    return this.driverAvailabilityService.update(
      id,
      updateDriverAvailabilityDto,
    )
  }

  @Delete(":id")
  @ApiOperation({ summary: "Delete a driver availability record" })
  @ApiResponse({
    status: 200,
    description: "Driver availability deleted successfully",
  })
  @ApiResponse({ status: 404, description: "Driver availability not found" })
  remove(@Param("id", ParseIntPipe) id: number) {
    return this.driverAvailabilityService.remove(id)
  }
}