import { Body,Controller,Delete,Get,NotFoundException,Param,ParseIntPipe,Patch,Post,UseGuards } from '@nestjs/common';
import { Employees, Roles as RoleEnum } from '@prisma/client';
import { EmployeesService } from '../services/employees.service';
import { CreateEmployeeDto } from '../dtos/create-employee.dto';
import { UpdateEmployeeDto } from '../dtos/update-employee.dto';
import { RolesAllowed } from '../../../common/decorators/roles.decorators';
import { ApiBearerAuth, ApiOperation, ApiParam, ApiResponse, ApiTags } from '@nestjs/swagger';

@ApiTags('Employees')
@ApiBearerAuth('access-token')
// @UseGuards()
@Controller('employees')
export class EmployeesController {
  constructor(private readonly employeesService: EmployeesService) {}

  @Post()
  @RolesAllowed(RoleEnum.ADMIN, RoleEnum.HR, RoleEnum.SUPERVISOR)
  @ApiOperation({summary: 'Create employee' })
  @ApiResponse({ status: 201, description: 'Employee created', type: CreateEmployeeDto })
  @ApiResponse({ status: 400, description: 'Incomplete task or invalid data' })
  create(@Body() dto: CreateEmployeeDto): Promise<Employees> {
    return this.employeesService.create(dto);
  }

  @Get()
  @RolesAllowed(RoleEnum.ADMIN, RoleEnum.HR, RoleEnum.SUPERVISOR, RoleEnum.ACCOUNTING)
  @ApiOperation({summary: 'Find all employees' })
  @ApiResponse({ status: 200, description: 'List of employees found', type: CreateEmployeeDto, isArray: true })
  @ApiResponse({ status: 400, description: 'List of employees not found' })
  findAll(): Promise<Employees[]> {
    return this.employeesService.findAll();
  }

  @Get(':id')
  @RolesAllowed(RoleEnum.ADMIN, RoleEnum.HR, RoleEnum.SUPERVISOR,RoleEnum.ACCOUNTING )
  @ApiOperation({summary: 'Find employee' })
  @ApiResponse({ status: 200, description: 'Employee found', type: CreateEmployeeDto })
  @ApiResponse({ status: 400, description: 'Employee not found' })
  findOne(@Param('id', ParseIntPipe) id: number): Promise<Employees> {
    return this.employeesService.findOne(id);
  }

  @Delete(':id')
  @RolesAllowed(RoleEnum.ADMIN, RoleEnum.HR, RoleEnum.SUPERVISOR )
  @ApiOperation({summary: 'Delete employee' })
  @ApiParam({ name: 'id', type: Number, description: 'Identifier of the employee to delete' })
  @ApiResponse({ status: 204, description: 'Employee deleted' })
  @ApiResponse({ status: 404, description: 'Employee not found' })
  remove(@Param('id', ParseIntPipe) id: number): Promise<Employees> {
    return this.employeesService.remove(id);
  }

  @Patch(':id')
  @RolesAllowed(RoleEnum.ADMIN, RoleEnum.HR, RoleEnum.SUPERVISOR) 
  @ApiBearerAuth('access-token')
  @ApiOperation({ summary: 'Update, archive or restore an employee' })
  @ApiParam({ name: 'id', type: Number, description: 'Identifier of the employee' })
  @ApiResponse({ status: 200, description: 'Employee updated or restored', type: CreateEmployeeDto })
  @ApiResponse({ status: 202, description: 'Employee archived successfully', type: CreateEmployeeDto })
  @ApiResponse({ status: 404, description: 'Employee not found in active or archive' })
  @Patch(':id')
  async updateOrArchiveOrRestore(@Param('id') id: string, @Body() dto: UpdateEmployeeDto,) {
    // if last_work_day is set => archive the employee
    // else if employee is archived and first_work_day or last_work_day = null => restore
    //otherwise => standard update
    const result = await this.employeesService.patchEmployee(+id, dto);
    if(!result) {
      throw new NotFoundException(`Employee #${ id } not found in active or archive.`)
    }
    return result;
  }
}