import { Injectable, NotFoundException } from '@nestjs/common';
import { PrismaService } from 'src/prisma/prisma.service';
import { CreateEmployeeDto } from '../dtos/create-employee.dto';
import { UpdateEmployeeDto } from '../dtos/update-employee.dto';
import { Employees, Users } from '@prisma/client';

@Injectable()
export class EmployeesService {
  constructor(
    private readonly prisma: PrismaService,
  ) {}

  async create(dto: CreateEmployeeDto): Promise<Employees> {
    const {
      first_name,
      last_name,
      email,
      phone_number,
      residence,
      external_payroll_id,
      company_code,
      first_work_day,
      last_work_day,
    } = dto;

    return this.prisma.$transaction(async (tx) => {
      const user: Users = await tx.users.create({
        data: {
          first_name,
          last_name,
          email,
          phone_number,
          residence,
        },
      });
      return tx.employees.create({
        data: {
          user_id: user.id,
          external_payroll_id,
          company_code,
          first_work_day,
          last_work_day,
        },
      });
    });
  }

  findAll(): Promise<Employees[]> {
    return this.prisma.employees.findMany({
      include: { user: true },
    });
  }

  async findOne(id: number): Promise<Employees> {
    const emp = await this.prisma.employees.findUnique({
      where: { id },
      include: { user: true },
    });
    if (!emp) {
      throw new NotFoundException(`Employee #${id} not found`);
    }
    return emp;
  }

async update(
    id: number,
    dto: UpdateEmployeeDto,
  ): Promise<Employees> {
    const emp = await this.findOne(id);

    const {
      first_name,
      last_name,
      email,
      phone_number,
      residence,
      external_payroll_id,
      company_code,
      first_work_day,
      last_work_day,
    } = dto;

    return this.prisma.$transaction(async (tx) => {
      await tx.users.update({
        where: { id: emp.user_id },
        data: {
          ...(first_name    !== undefined && { first_name }),
          ...(last_name     !== undefined && { last_name }),
          ...(email         !== undefined && { email }),
          ...(phone_number  !== undefined && { phone_number }),
          ...(residence     !== undefined && { residence }),
        },
      });

      return tx.employees.update({
        where: { id },
        data: {
          ...(external_payroll_id !== undefined && { external_payroll_id }),
          ...(company_code        !== undefined && { company_code }),
          ...(first_work_day      !== undefined && { first_work_day }),
          ...(last_work_day       !== undefined && { last_work_day }),
        },
      });
    });
  }


  async remove(id: number): Promise<Employees> {
    await this.findOne(id);
    return this.prisma.employees.delete({ where: { id } });
  }
}