import { Injectable, NotFoundException } from "@nestjs/common";
import { PrismaService } from "src/prisma/prisma.service";
import { CreateLeaveRequestsDto } from "../dtos/create-leave-requests.dto";
import { LeaveRequests } from "@prisma/client";
import { UpdateLeaveRequestsDto } from "../dtos/update-leave-requests.dto";

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

    async create(dto: CreateLeaveRequestsDto): Promise<LeaveRequests> {
        const {
            employee_id,
            leave_type,
            start_date_time,
            end_date_time,
            comment,
            approval_status,
        } = dto;

        return this.prisma.leaveRequests.create({
            data: {
                employee_id,
                leave_type,
                start_date_time,
                end_date_time,
                comment,
                approval_status: approval_status ?? undefined,
            },
            include: {
                employee: {
                    include: {
                        user: true
                    },
                },
            },
        });
    }

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

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


    async update(
        id: number,
        dto: UpdateLeaveRequestsDto,
    ): Promise<LeaveRequests> {
        await this.findOne(id);
        const {
            employee_id,
            leave_type,
            start_date_time,
            end_date_time,
            comment,
            approval_status,
        } = dto;
        return this.prisma.leaveRequests.update({
            where: { id },
            data: {
                ...(employee_id !== undefined && { employee_id }),
                ...(leave_type !== undefined && { leave_type } ),
                ...(start_date_time !== undefined && { start_date_time }),
                ...(end_date_time !== undefined && { end_date_time }),
                ...(comment !== undefined && { comment }),
                ...(approval_status == undefined && { approval_status }),
            },
            include: {
                employee: {
                    include: {
                        user:true
                    },
                },
            },
        });
    }

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

    //archivation function
    async archiveExpired(): Promise<void> {
        const now = new Date();

        await this.prisma.$transaction(async transaction => {
            //fetches expired leave requests
            const expired = await transaction.leaveRequests.findMany({
                where: { end_date_time: { lt: now } },
            });
            if(expired.length === 0) {
                return;
            }
            //copy unto archive table
            await transaction.leaveRequestsArchive.createMany({
                data: expired.map(request => ({
                    leave_request_id: request.id,
                    employee_id: request.employee_id,
                    leave_type: request.leave_type,
                    start_date_time: request.start_date_time,
                    end_date_time: request.end_date_time,
                    comment: request.comment,
                    approval_status: request.approval_status,
                })),
            });
            //delete from leave_requests table
            await transaction.leaveRequests.deleteMany({
                where: { id: { in: expired.map(request => request.id ) } },
            });
        });

    }
}