import { NextRequest, NextResponse } from 'next/server'
import { db } from '@/lib/db'
import { requireAuth } from '@/lib/api-auth'
import { Prisma } from '@prisma/client'

export async function POST(request: NextRequest) {
  try {
    const authResult = await requireAuth(['ADMIN'])(request)
    if ('error' in authResult) return authResult.error

    const { user: adminUser } = authResult
    const body = await request.json()
    const { userIds } = body

    if (!Array.isArray(userIds) || userIds.length === 0) {
      return NextResponse.json(
        { error: 'Se requiere un array no vacío de IDs de usuario' },
        { status: 400 }
      )
    }

    const errors: string[] = []
    let deletedCount = 0

    await db.$transaction(async (tx: Prisma.TransactionClient) => {
      for (const userId of userIds) {
        // Prevent deleting yourself
        if (userId === adminUser.id) {
          errors.push(`No puede eliminarse a sí mismo (${adminUser.email})`)
          continue
        }

        // Find the user
        const user = await tx.user.findUnique({
          where: { id: userId },
          select: { id: true, role: true, email: true },
        })

        if (!user) {
          errors.push(`Usuario ${userId} no encontrado`)
          continue
        }

        try {
          if (user.role === 'CUSTOMER') {
            // Delete notifications for this user
            await tx.notification.deleteMany({
              where: { userId: user.id },
            })

            // Get reviews by this customer
            const customerReviews = await tx.review.findMany({
              where: { customerId: user.id },
              select: { id: true },
            })

            const reviewIds = customerReviews.map((r) => r.id)

            if (reviewIds.length > 0) {
              // Delete supervisor responses for these reviews
              await tx.supervisorResponse.deleteMany({
                where: { reviewId: { in: reviewIds } },
              })

              // Delete review photos for these reviews
              await tx.reviewPhoto.deleteMany({
                where: { reviewId: { in: reviewIds } },
              })

              // Delete the reviews
              await tx.review.deleteMany({
                where: { id: { in: reviewIds } },
              })
            }

            // Delete the user
            await tx.user.delete({
              where: { id: user.id },
            })

            deletedCount++
          } else if (user.role === 'SUPERVISOR') {
            // Delete notifications for this supervisor
            await tx.notification.deleteMany({
              where: { userId: user.id },
            })

            // Get reviews assigned to this supervisor
            const assignedReviews = await tx.review.findMany({
              where: { assignedToId: user.id },
              select: { id: true },
            })

            const assignedReviewIds = assignedReviews.map((r) => r.id)

            // Delete supervisor responses created by this supervisor
            await tx.supervisorResponse.deleteMany({
              where: { supervisorId: user.id },
            })

            if (assignedReviewIds.length > 0) {
              // Delete review photos for assigned reviews that have no other responses
              await tx.reviewPhoto.deleteMany({
                where: { reviewId: { in: assignedReviewIds } },
              })

              // Delete the assigned reviews (they lost their supervisor)
              await tx.review.deleteMany({
                where: { id: { in: assignedReviewIds } },
              })
            }

            // Set assignedById to null for customers assigned by this supervisor
            await tx.user.updateMany({
              where: { assignedById: user.id },
              data: { assignedById: null },
            })

            // Delete the supervisor user
            await tx.user.delete({
              where: { id: user.id },
            })

            deletedCount++
          } else if (user.role === 'MANAGER' || user.role === 'ADMIN') {
            // Delete notifications for this user
            await tx.notification.deleteMany({
              where: { userId: user.id },
            })

            // Delete the user
            await tx.user.delete({
              where: { id: user.id },
            })

            deletedCount++
          }
        } catch (deleteErr: any) {
          errors.push(`Error al eliminar ${user.email}: ${deleteErr.message}`)
        }
      }
    })

    return NextResponse.json({ deletedCount, errors })
  } catch (error) {
    console.error('Error en eliminación masiva:', error)
    return NextResponse.json(
      { error: 'Error interno del servidor' },
      { status: 500 }
    )
  }
}