import { NextRequest, NextResponse } from 'next/server';
import { prisma } from '@/lib/prisma';

function toDate(value: string | null | undefined) {
  if (!value) return null;
  return new Date(value);
}

export async function GET(
  request: NextRequest,
  { params }: { params: Promise<{ id: string }> | { id: string } }
) {
  try {
    const { id } = await params;
    
    const leaveRequest = await prisma.leaveRequest.findUnique({
      where: { id }
    });
    
    if (!leaveRequest) {
      return NextResponse.json(
        { error: 'Leave request not found' },
        { status: 404 }
      );
    }
    
    return NextResponse.json(leaveRequest);
  } catch (error) {
    console.error('Error fetching leave request:', error);
    return NextResponse.json(
      { error: 'Failed to fetch leave request' },
      { status: 500 }
    );
  }
}

export async function PUT(
  request: NextRequest,
  { params }: { params: Promise<{ id: string }> | { id: string } }
) {
  try {
    const { id } = await params;
    const data = await request.json();

    // Check if leave request exists
    const existing = await prisma.leaveRequest.findUnique({
      where: { id }
    });
    
    if (!existing) {
      return NextResponse.json(
        { error: 'Leave request not found' },
        { status: 404 }
      );
    }

    const leaveRequest = await prisma.leaveRequest.update({
      where: { id },
      data: {
        employeeId: data.employeeId,
        employeeName: data.employeeName,
        dept: data.dept,
        position: data.position,
        employeeType: data.employeeType || 'Employee',
        gender: data.gender,
        type: data.type,
        startDate: new Date(data.startDate),
        endDate: new Date(data.endDate),
        days: data.days,
        reason: data.reason,
        status: data.status,
        submittedOn: data.submittedOn ? new Date(data.submittedOn) : undefined,
        dutyDelegate: data.dutyDelegate,
        hasDocument: data.hasDocument || false,
        hodApprovedBy: data.hodApprovedBy,
        hodApprovedOn: toDate(data.hodApprovedOn),
        hosApprovedBy: data.hosApprovedBy,
        hosApprovedOn: toDate(data.hosApprovedOn),
        hosComment: data.hosComment,
        approvedBy: data.approvedBy,
        approvedOn: toDate(data.approvedOn),
        rejectionReason: data.rejectionReason,
        rejectedBy: data.rejectedBy,
        rejectedStage: data.rejectedStage,
        reviewRequested: data.reviewRequested || false,
        reviewComment: data.reviewComment,
        reviewNewStart: data.reviewNewStart,
        reviewNewEnd: data.reviewNewEnd,
        reviewBy: data.reviewBy,
        reviewDate: toDate(data.reviewDate),
        updatedAt: new Date(),
      },
    });

    return NextResponse.json(leaveRequest);
  } catch (error) {
    console.error('Error updating leave request:', error);
    return NextResponse.json(
      { error: 'Failed to update leave request', details: error instanceof Error ? error.message : 'Unknown error' },
      { status: 500 }
    );
  }
}

export async function DELETE(
  request: NextRequest,
  { params }: { params: Promise<{ id: string }> | { id: string } }
) {
  try {
    const { id } = await params;
    
    const existing = await prisma.leaveRequest.findUnique({
      where: { id }
    });
    
    if (!existing) {
      return NextResponse.json(
        { error: 'Leave request not found' },
        { status: 404 }
      );
    }
    
    await prisma.leaveRequest.delete({
      where: { id }
    });
    
    return NextResponse.json({ success: true, message: 'Leave request deleted successfully' });
  } catch (error) {
    console.error('Error deleting leave request:', error);
    return NextResponse.json(
      { error: 'Failed to delete leave request' },
      { status: 500 }
    );
  }
}