import { NextRequest, NextResponse } from 'next/server';
import crypto from 'crypto';
import { PrismaClient } from '@prisma/client';
import { sendActivationEmail } from '@/lib/emailService.cjs';

const prisma = new PrismaClient();

export async function POST(request: NextRequest) {
  try {
    const body = await request.json();
    const { email, name, role, dept, employeeId, username, ...rest } = body;
    
    // Normalize role to lowercase to prevent case sensitivity issues
    const normalizedRole = (role || 'employee').toLowerCase();
    
    // Check if user exists
    const existingUser = await prisma.user.findFirst({
      where: {
        OR: [
          { email },
          { username: username || email?.split('@')[0] },
          { employeeId: employeeId || undefined }
        ]
      }
    });
    
    if (existingUser) {
      return NextResponse.json(
        { error: 'User with this email, username, or employee ID already exists' },
        { status: 400 }
      );
    }
    
    // Generate activation token (only for new users)
    const activationToken = crypto.randomBytes(32).toString('hex');
    const tokenExpiry = new Date();
    tokenExpiry.setHours(tokenExpiry.getHours() + 24);
    
    // Create username if not provided
    const finalUsername = username || email?.split('@')[0] + '_' + Date.now();
    
    // Create user with PENDING_ACTIVATION status and lowercase role
    const user = await prisma.user.create({
      data: {
        username: finalUsername,
        email,
        name: name || '',
        role: normalizedRole,  // Store role in lowercase
        dept: dept || '',
        employeeId: employeeId || null,
        status: 'PENDING_ACTIVATION',
        activationToken,
        tokenExpiry,
        isActive: true,
        isFirstLogin: true,
        isEmailVerified: false,
        passwordHash: '',
        // Handle isIntern based on role
        isIntern: normalizedRole === 'intern',
        ...rest,
      },
    });
    
    console.log('User created:', user.email, 'Role:', user.role);
    
    // Send activation email
    const emailResult = await sendActivationEmail(user.email, user.name, activationToken);
    
    if (emailResult.success) {
      return NextResponse.json({
        success: true,
        message: 'User created successfully. Activation email sent.',
        user: {
          id: user.id,
          email: user.email,
          name: user.name,
          role: user.role,
          status: user.status,
        },
        emailSent: true,
      }, { status: 201 });
    } else {
      // User created but email failed
      return NextResponse.json({
        success: true,
        warning: 'User created but activation email failed to send',
        message: emailResult.error,
        user: {
          id: user.id,
          email: user.email,
          name: user.name,
          role: user.role,
          status: user.status,
        },
        activationLink: `${process.env.FRONTEND_URL}/activate-account?token=${activationToken}`,
      }, { status: 201 });
    }
    
  } catch (error) {
    console.error('Error creating user:', error);
    return NextResponse.json(
      { error: 'Failed to create user' },
      { status: 500 }
    );
  }
}

// GET endpoint to fetch users (for admin panel)
export async function GET(request: NextRequest) {
  try {
    const { searchParams } = new URL(request.url);
    const role = searchParams.get('role');
    const dept = searchParams.get('dept');
    
    const where: any = {};
    if (role) where.role = role.toLowerCase();
    if (dept) where.dept = dept;
    
    const users = await prisma.user.findMany({
      where,
      orderBy: { createdAt: 'desc' },
      select: {
        id: true,
        username: true,
        email: true,
        name: true,
        role: true,
        dept: true,
        position: true,
        employeeId: true,
        status: true,
        isActive: true,
        createdAt: true,
      }
    });
    
    return NextResponse.json({ users });
  } catch (error) {
    console.error('Error fetching users:', error);
    return NextResponse.json(
      { error: 'Failed to fetch users' },
      { status: 500 }
    );
  }
}

// PUT endpoint to update user
export async function PUT(request: NextRequest) {
  try {
    const body = await request.json();
    const { id, role, ...updateData } = body;
    
    if (!id) {
      return NextResponse.json({ error: 'User ID required' }, { status: 400 });
    }
    
    // Normalize role to lowercase if provided
    if (role) {
      updateData.role = role.toLowerCase();
      // Update isIntern based on role
      updateData.isIntern = updateData.role === 'intern';
    }
    
    const user = await prisma.user.update({
      where: { id },
      data: updateData,
    });
    
    return NextResponse.json({ success: true, user });
  } catch (error) {
    console.error('Error updating user:', error);
    return NextResponse.json(
      { error: 'Failed to update user' },
      { status: 500 }
    );
  }
}