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

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

    const body = await request.json()
    const { action, confirm } = body

    if (!confirm) {
      return NextResponse.json(
        { error: 'Se requiere confirmación' },
        { status: 400 }
      )
    }

    const result = { action, deletedCount: 0 }

    switch (action) {
      case 'soft-deleted-reviews': {
        // Permanently remove soft-deleted reviews older than 30 days
        const thirtyDaysAgo = new Date()
        thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30)
        const deleted = await db.review.deleteMany({
          where: { deletedAt: { not: null, lte: thirtyDaysAgo } },
        })
        result.deletedCount = deleted.count
        break
      }
      case 'inactive-users-reviews': {
        // Soft-delete reviews from inactive customers
        const inactiveCustomers = await db.user.findMany({
          where: { role: 'CUSTOMER', isActive: false },
          select: { id: true },
        })
        if (inactiveCustomers.length > 0) {
          const updated = await db.review.updateMany({
            where: {
              customerId: { in: inactiveCustomers.map((c) => c.id) },
              deletedAt: null,
            },
            data: { deletedAt: new Date() },
          })
          result.deletedCount = updated.count
        }
        break
      }
      case 'old-notifications': {
        // Delete notifications older than 90 days
        const ninetyDaysAgo = new Date()
        ninetyDaysAgo.setDate(ninetyDaysAgo.getDate() - 90)
        const deleted = await db.notification.deleteMany({
          where: { createdAt: { lte: ninetyDaysAgo } },
        })
        result.deletedCount = deleted.count
        break
      }
      case 'all-soft-deleted': {
        // Permanently remove ALL soft-deleted reviews
        const deleted = await db.review.deleteMany({
          where: { deletedAt: { not: null } },
        })
        result.deletedCount = deleted.count
        break
      }
      default:
        return NextResponse.json(
          { error: 'Acción no válida' },
          { status: 400 }
        )
    }

    return NextResponse.json({ result })
  } catch (error) {
    console.error('Error:', error)
    return NextResponse.json(
      { error: 'Error interno del servidor' },
      { status: 500 }
    )
  }
}

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

    const thirtyDaysAgo = new Date()
    thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30)
    const ninetyDaysAgo = new Date()
    ninetyDaysAgo.setDate(ninetyDaysAgo.getDate() - 90)

    const [softDeletedReviews, softDeletedAll, inactiveCustomersReviews, oldNotifications] =
      await Promise.all([
        db.review.count({
          where: { deletedAt: { not: null, lte: thirtyDaysAgo } },
        }),
        db.review.count({ where: { deletedAt: { not: null } } }),
        db.review.count({
          where: { customer: { isActive: false }, deletedAt: null },
        }),
        db.notification.count({
          where: { createdAt: { lte: ninetyDaysAgo } },
        }),
      ])

    return NextResponse.json({
      cleanupOptions: [
        {
          action: 'soft-deleted-reviews',
          label: 'Reseñas eliminadas hace más de 30 días',
          count: softDeletedReviews,
          severity: 'medium',
        },
        {
          action: 'all-soft-deleted',
          label: 'Todas las reseñas eliminadas (soft delete)',
          count: softDeletedAll,
          severity: 'high',
        },
        {
          action: 'inactive-users-reviews',
          label: 'Reseñas de clientes inactivos',
          count: inactiveCustomersReviews,
          severity: 'medium',
        },
        {
          action: 'old-notifications',
          label: 'Notificaciones anteriores a 90 días',
          count: oldNotifications,
          severity: 'low',
        },
      ],
    })
  } catch (error) {
    console.error('Error:', error)
    return NextResponse.json(
      { error: 'Error interno del servidor' },
      { status: 500 }
    )
  }
}