import { NextResponse } from 'next/server';
import { prisma } from '@/lib/prisma';
import bcrypt from 'bcryptjs';

export async function GET(request: Request) {
  try {
    const { searchParams } = new URL(request.url);
    const role = searchParams.get('role');
    const search = searchParams.get('search')?.toLowerCase() || '';

    const where: any = {};
    if (role && role !== 'ALL') {
      where.role = role;
    }

    const users = await prisma.user.findMany({
      where,
      select: {
        id: true,
        username: true,
        email: true,
        name: true,
        role: true,
        farmId: true,
        farmName: true,
        createdAt: true,
        updatedAt: true
      },
      orderBy: { createdAt: 'desc' }
    });

    // Client search filter if provided
    const filtered = users.filter(u => {
      if (!search) return true;
      const haystack = `${u.name || ''} ${u.username || ''} ${u.email || ''} ${u.farmName || ''} ${u.role}`.toLowerCase();
      return haystack.includes(search);
    });

    return NextResponse.json(filtered);
  } catch (error: any) {
    console.error('Error fetching users:', error);
    return NextResponse.json({ error: 'Error al obtener usuarios' }, { status: 500 });
  }
}

export async function POST(request: Request) {
  try {
    const body = await request.json();
    const { name, username, email, password, role, farmId } = body;

    if (!password || !password.trim()) {
      return NextResponse.json({ error: 'La contraseña es requerida' }, { status: 400 });
    }

    const validRole = ['ADMIN', 'COLD_ROOM', 'FARM'].includes(role) ? role : 'ADMIN';

    // Username or email required
    const cleanUsername = username ? username.trim().toLowerCase() : (email ? email.trim().toLowerCase() : '');
    const cleanEmail = email ? email.trim().toLowerCase() : cleanUsername;

    if (!cleanUsername && !cleanEmail) {
      return NextResponse.json({ error: 'Debe ingresar un usuario o correo electrónico' }, { status: 400 });
    }

    // Check duplicate username or email
    const existing = await prisma.user.findFirst({
      where: {
        OR: [
          ...(cleanUsername ? [{ username: cleanUsername }] : []),
          ...(cleanEmail ? [{ email: cleanEmail }] : [])
        ]
      }
    });

    if (existing) {
      return NextResponse.json({ error: 'Ya existe un usuario con este correo o nombre de usuario' }, { status: 400 });
    }

    let farmName: string | null = null;
    let assignedFarmId: string | null = null;

    if (validRole === 'FARM') {
      if (!farmId) {
        return NextResponse.json({ error: 'Debe seleccionar una Finca para el usuario de finca' }, { status: 400 });
      }
      const farm = await prisma.farm.findUnique({ where: { id: farmId } });
      if (!farm) {
        return NextResponse.json({ error: 'La finca seleccionada no existe' }, { status: 404 });
      }
      assignedFarmId = farm.id;
      farmName = farm.name;
    }

    const hashedPassword = await bcrypt.hash(password.trim(), 10);

    const newUser = await prisma.user.create({
      data: {
        name: name?.trim() || (validRole === 'FARM' ? farmName : cleanUsername),
        username: cleanUsername,
        email: cleanEmail,
        password: hashedPassword,
        role: validRole,
        farmId: assignedFarmId,
        farmName
      },
      select: {
        id: true,
        username: true,
        email: true,
        name: true,
        role: true,
        farmId: true,
        farmName: true,
        createdAt: true
      }
    });

    return NextResponse.json({ success: true, user: newUser }, { status: 201 });
  } catch (error: any) {
    console.error('Error creating user:', error);
    return NextResponse.json({ error: error.message || 'Error al crear usuario' }, { status: 500 });
  }
}

export async function PUT(request: Request) {
  try {
    const body = await request.json();
    const { id, name, username, email, password, role, farmId } = body;

    if (!id) {
      return NextResponse.json({ error: 'ID de usuario requerido' }, { status: 400 });
    }

    const user = await prisma.user.findUnique({ where: { id } });
    if (!user) {
      return NextResponse.json({ error: 'Usuario no encontrado' }, { status: 404 });
    }

    const cleanUsername = username ? username.trim().toLowerCase() : user.username;
    const cleanEmail = email ? email.trim().toLowerCase() : user.email;

    // Check conflict with other users
    if (cleanUsername !== user.username || cleanEmail !== user.email) {
      const conflict = await prisma.user.findFirst({
        where: {
          id: { not: id },
          OR: [
            ...(cleanUsername ? [{ username: cleanUsername }] : []),
            ...(cleanEmail ? [{ email: cleanEmail }] : [])
          ]
        }
      });
      if (conflict) {
        return NextResponse.json({ error: 'Ya existe otro usuario con este correo o nombre de usuario' }, { status: 400 });
      }
    }

    const validRole = role && ['ADMIN', 'COLD_ROOM', 'FARM'].includes(role) ? role : user.role;

    let farmName = user.farmName;
    let assignedFarmId = user.farmId;

    if (validRole === 'FARM') {
      const targetFarmId = farmId || user.farmId;
      if (!targetFarmId) {
        return NextResponse.json({ error: 'Debe seleccionar una finca' }, { status: 400 });
      }
      const farm = await prisma.farm.findUnique({ where: { id: targetFarmId } });
      if (farm) {
        assignedFarmId = farm.id;
        farmName = farm.name;
      }
    } else {
      assignedFarmId = null;
      farmName = null;
    }

    const updateData: any = {
      name: name?.trim() || user.name,
      username: cleanUsername,
      email: cleanEmail,
      role: validRole,
      farmId: assignedFarmId,
      farmName
    };

    if (password && password.trim().length > 0) {
      updateData.password = await bcrypt.hash(password.trim(), 10);
    }

    const updatedUser = await prisma.user.update({
      where: { id },
      data: updateData,
      select: {
        id: true,
        username: true,
        email: true,
        name: true,
        role: true,
        farmId: true,
        farmName: true,
        createdAt: true,
        updatedAt: true
      }
    });

    return NextResponse.json({ success: true, user: updatedUser });
  } catch (error: any) {
    console.error('Error updating user:', error);
    return NextResponse.json({ error: error.message || 'Error al actualizar usuario' }, { status: 500 });
  }
}

export async function DELETE(request: Request) {
  try {
    const { searchParams } = new URL(request.url);
    const id = searchParams.get('id');

    if (!id) {
      return NextResponse.json({ error: 'ID de usuario requerido' }, { status: 400 });
    }

    const user = await prisma.user.findUnique({ where: { id } });
    if (!user) {
      return NextResponse.json({ error: 'Usuario no encontrado' }, { status: 404 });
    }

    // If user is ADMIN, prevent deletion if it is the only admin
    if (user.role === 'ADMIN') {
      const adminCount = await prisma.user.count({ where: { role: 'ADMIN' } });
      if (adminCount <= 1) {
        return NextResponse.json({ error: 'No se puede eliminar el único administrador del sistema' }, { status: 400 });
      }
    }

    await prisma.user.delete({ where: { id } });
    return NextResponse.json({ success: true, message: 'Usuario eliminado correctamente' });
  } catch (error: any) {
    console.error('Error deleting user:', error);
    return NextResponse.json({ error: error.message || 'Error al eliminar usuario' }, { status: 500 });
  }
}