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

const prisma = new PrismaClient();

export async function DELETE(
  request: NextRequest,
  { params }: { params: Promise<{ id: string }> }
) {
  try {
    const { id } = await params;
    
    console.log('Deleting employee with ID/Number:', id);
    
    // Try to find employee by UUID first, then by employeeNumber
    let employee = await prisma.employee.findUnique({
      where: { id: id },
    });
    
    if (!employee) {
      employee = await prisma.employee.findUnique({
        where: { employeeNumber: id },
      });
    }
    
    if (!employee) {
      console.log('Employee not found with ID:', id);
      return NextResponse.json(
        { error: 'Employee not found' },
        { status: 404 }
      );
    }
    
    console.log('Found employee:', employee.email, 'Employee Number:', employee.employeeNumber);
    
    // Delete related records in order with error handling
    const deleteResults = {
      leaveRequests: 0,
      trainingRecords: 0,
      appraisals: 0,
      trainingRequests: 0,
      workPlans: 0,
      kpis: 0,
      quarterlyTargets: 0,
      pip: 0,
      users: 0,
    };
    
    // Delete leave requests
    const leaveResult = await prisma.leaveRequest.deleteMany({
      where: { employeeId: employee.email },
    });
    deleteResults.leaveRequests = leaveResult.count;
    console.log(`Deleted ${leaveResult.count} leave requests`);
    
    // Delete training records
    const trainingRecordResult = await prisma.trainingRecord.deleteMany({
      where: { employeeId: employee.email },
    });
    deleteResults.trainingRecords = trainingRecordResult.count;
    console.log(`Deleted ${trainingRecordResult.count} training records`);
    
    // Delete appraisals
    const appraisalResult = await prisma.appraisal.deleteMany({
      where: { employeeId: employee.email },
    });
    deleteResults.appraisals = appraisalResult.count;
    console.log(`Deleted ${appraisalResult.count} appraisals`);
    
    // Delete training requests
    const trainingRequestResult = await prisma.trainingRequest.deleteMany({
      where: { employeeId: employee.email },
    });
    deleteResults.trainingRequests = trainingRequestResult.count;
    console.log(`Deleted ${trainingRequestResult.count} training requests`);
    
    // Delete work plans
    const workPlanResult = await prisma.workPlan.deleteMany({
      where: { employeeId: employee.email },
    });
    deleteResults.workPlans = workPlanResult.count;
    console.log(`Deleted ${workPlanResult.count} work plans`);
    
    // Delete KPIs
    const kpiResult = await prisma.kPI.deleteMany({
      where: { employeeId: employee.email },
    });
    deleteResults.kpis = kpiResult.count;
    console.log(`Deleted ${kpiResult.count} KPIs`);
    
    // Delete quarterly targets
    const quarterlyResult = await prisma.quarterlyTarget.deleteMany({
      where: { employeeId: employee.email },
    });
    deleteResults.quarterlyTargets = quarterlyResult.count;
    console.log(`Deleted ${quarterlyResult.count} quarterly targets`);
    
    // Delete performance improvement plans
    const pipResult = await prisma.performanceImprovementPlan.deleteMany({
      where: { employeeId: employee.email },
    });
    deleteResults.pip = pipResult.count;
    console.log(`Deleted ${pipResult.count} PIPs`);
    
    // Delete individual performance indicators
    await prisma.individualPerformanceIndicator.deleteMany({
      where: { employeeId: employee.email },
    });
    
    // Delete notifications
    await prisma.notification.deleteMany({
      where: { userId: employee.email },
    });
    
    // Delete performance comments
    await prisma.performanceComment.deleteMany({
      where: { employeeId: employee.email },
    });
    
    // Delete the user account
    const userResult = await prisma.user.deleteMany({
      where: { email: employee.email },
    });
    deleteResults.users = userResult.count;
    console.log(`Deleted ${userResult.count} user account(s)`);
    
    // Finally delete the employee
    const deletedEmployee = await prisma.employee.delete({
      where: { id: employee.id },
    });
    
    console.log('Employee deleted successfully:', deletedEmployee.id);
    
    return NextResponse.json({
      success: true,
      message: 'Employee and associated data deleted successfully',
      deletedRecords: deleteResults,
    });
    
  } catch (error) {
    console.error('Error deleting employee:', error);
    return NextResponse.json(
      { error: error instanceof Error ? error.message : 'Failed to delete employee' },
      { status: 500 }
    );
  }
}

// PUT endpoint for updating employee
export async function PUT(
  request: NextRequest,
  { params }: { params: Promise<{ id: string }> }
) {
  try {
    const { id } = await params;
    const body = await request.json();
    
    console.log('Updating employee with ID:', id);
    
    const { fullName, email, phone, dept, position, employmentType, isActive, salary, dob, nationalId, kraPin } = body;
    
    // Find the employee
    let employee = await prisma.employee.findUnique({
      where: { id: id },
    });
    
    if (!employee) {
      employee = await prisma.employee.findUnique({
        where: { employeeNumber: id },
      });
    }
    
    if (!employee) {
      return NextResponse.json(
        { error: 'Employee not found' },
        { status: 404 }
      );
    }
    
    // Update employee
    const updatedEmployee = await prisma.employee.update({
      where: { id: employee.id },
      data: {
        fullName: fullName || employee.fullName,
        email: email || employee.email,
        phone: phone !== undefined ? phone : employee.phone,
        dept: dept || employee.dept,
        position: position || employee.position,
        employmentType: employmentType || employee.employmentType,
        isActive: isActive !== undefined ? isActive : employee.isActive,
        salary: salary ? parseFloat(salary) : employee.salary,
        dob: dob ? new Date(dob) : employee.dob,
        nationalId: nationalId !== undefined ? nationalId : employee.nationalId,
        kraPin: kraPin !== undefined ? kraPin : employee.kraPin,
        updatedAt: new Date(),
      },
    });
    
    // Also update the user record
    await prisma.user.updateMany({
      where: { email: employee.email },
      data: {
        email: email || employee.email,
        name: fullName || employee.fullName,
        dept: dept || employee.dept,
        position: position || employee.position,
        isActive: isActive !== undefined ? isActive : employee.isActive,
      },
    });
    
    console.log('Employee updated successfully:', updatedEmployee.id);
    
    return NextResponse.json({ 
      success: true, 
      message: 'Employee updated successfully',
      employee: updatedEmployee 
    });
  } catch (error) {
    console.error('Error updating employee:', error);
    return NextResponse.json(
      { error: error instanceof Error ? error.message : 'Failed to update employee' },
      { status: 500 }
    );
  }
}

// GET endpoint for single employee
export async function GET(
  request: NextRequest,
  { params }: { params: Promise<{ id: string }> }
) {
  try {
    const { id } = await params;
    
    console.log('Fetching employee with ID:', id);
    
    let employee = await prisma.employee.findUnique({
      where: { id: id },
    });
    
    if (!employee) {
      employee = await prisma.employee.findUnique({
        where: { employeeNumber: id },
      });
    }
    
    if (!employee) {
      return NextResponse.json(
        { error: 'Employee not found' },
        { status: 404 }
      );
    }
    
    return NextResponse.json(employee);
  } catch (error) {
    console.error('Error fetching employee:', error);
    return NextResponse.json(
      { error: 'Failed to fetch employee' },
      { status: 500 }
    );
  }
}