// app/api/admin/employees/route.ts
import { prisma } from '@/lib/prisma'
import { NextRequest, NextResponse } from 'next/server'

export async function GET(request: NextRequest) {
  try {
    const { searchParams } = new URL(request.url);
    const dept = searchParams.get('dept');
    const employeeId = searchParams.get('employeeId');
    const isActive = searchParams.get('isActive');
    const search = searchParams.get('search');
    
    let where: any = {};
    
    // Filter by department (for HOD view)
    if (dept) {
      where.dept = dept;
    }
    
    // Filter by employee ID/number
    if (employeeId) {
      where.OR = [
        { employeeNumber: employeeId },
        { id: employeeId },
      ];
    }
    
    // Filter by active status
    if (isActive !== null) {
      where.isActive = isActive === 'true';
    } else {
      where.isActive = true;
    }
    
    // Search by name or email
    if (search) {
      where.OR = [
        { fullName: { contains: search, mode: 'insensitive' } },
        { email: { contains: search, mode: 'insensitive' } },
        { employeeNumber: { contains: search, mode: 'insensitive' } },
      ];
    }
    
    const employees = await prisma.employee.findMany({
      where,
      orderBy: { fullName: 'asc' },
    });
    
    return NextResponse.json(employees);
  } catch (error) {
    console.error('Error fetching employees:', error);
    return NextResponse.json({ error: 'Failed to fetch employees' }, { status: 500 });
  }
}

export async function POST(request: Request) {
  try {
    const body = await request.json();
    
    // Validate required fields
    if (!body.fullName || !body.email || !body.dept || !body.position || !body.joinDate) {
      return NextResponse.json(
        { error: 'Missing required fields: fullName, email, dept, position, joinDate' },
        { status: 400 }
      );
    }
    
    // Generate employee number if not provided
    const employeeNumber = body.employeeNumber || `UF${String(Math.floor(Math.random() * 1000)).padStart(3, '0')}`;
    
    // Split full name into first and last name
    const nameParts = body.fullName.split(' ');
    const firstName = nameParts[0];
    const lastName = nameParts.slice(1).join(' ') || firstName;
    
    const employee = await prisma.employee.create({
      data: {
        employeeNumber: employeeNumber,
        firstName: firstName,
        lastName: lastName,
        fullName: body.fullName,
        email: body.email,
        phone: body.phone || null,
        dob: body.dob ? new Date(body.dob) : null,
        gender: body.gender || 'Other',
        employmentType: body.employmentType || 'Permanent',
        dept: body.dept,
        position: body.position,
        joinDate: new Date(body.joinDate),
        salary: body.salary ? parseFloat(body.salary) : null,
        nationalId: body.nationalId || null,
        kraPin: body.kraPin || null,
        isIntern: body.isIntern || false,
        isActive: true,
      },
    });
    
    console.log('Employee created:', employee.email, 'Department:', employee.dept);
    
    return NextResponse.json(employee, { status: 201 });
  } catch (error) {
    console.error('Error creating employee:', error);
    return NextResponse.json({ error: 'Failed to create employee' }, { status: 500 });
  }
}

// PUT endpoint for updating multiple employees (batch update)
export async function PUT(request: Request) {
  try {
    const body = await request.json();
    const { employeeIds, updates } = body;
    
    if (!employeeIds || !Array.isArray(employeeIds) || employeeIds.length === 0) {
      return NextResponse.json(
        { error: 'Employee IDs are required' },
        { status: 400 }
      );
    }
    
    const result = await prisma.employee.updateMany({
      where: {
        id: { in: employeeIds },
      },
      data: updates,
    });
    
    return NextResponse.json({ success: true, count: result.count });
  } catch (error) {
    console.error('Error batch updating employees:', error);
    return NextResponse.json({ error: 'Failed to update employees' }, { status: 500 });
  }
}