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

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

    const { searchParams } = new URL(request.url)
    const dateFrom = searchParams.get('dateFrom')
    const dateTo = searchParams.get('dateTo')

    const where: { createdAt?: { gte?: Date; lte?: Date }; deletedAt?: null } = { deletedAt: null }
    if (dateFrom || dateTo) {
      where.createdAt = {}
      if (dateFrom) where.createdAt.gte = new Date(dateFrom)
      if (dateTo) where.createdAt.lte = new Date(dateTo)
    }

    // Aggregate stats
    const [totalCount, avgRating, positiveCount, negativeCount, pendingCount, acknowledgedCount, resolvedCount] =
      await Promise.all([
        db.review.count({ where: { ...where, deletedAt: null } }),
        db.review.aggregate({ _avg: { rating: true }, where: { ...where, deletedAt: null } }),
        db.review.count({ where: { ...where, sentiment: 'POSITIVE', deletedAt: null } }),
        db.review.count({ where: { ...where, sentiment: 'NEGATIVE', deletedAt: null } }),
        db.review.count({ where: { ...where, status: 'PENDING', deletedAt: null } }),
        db.review.count({ where: { ...where, status: 'ACKNOWLEDGED', deletedAt: null } }),
        db.review.count({ where: { ...where, status: 'RESOLVED', deletedAt: null } }),
      ])

    // Rating distribution
    const ratingDistribution: Record<number, number> = {}
    for (let i = 1; i <= 5; i++) {
      ratingDistribution[i] = await db.review.count({
        where: { ...where, rating: i, deletedAt: null },
      })
    }

    // Average response time (hours) for resolved reviews in period
    const resolvedWhere = {
      ...where,
      status: 'RESOLVED' as const,
      deletedAt: null,
      resolvedAt: { not: null },
    }
    const resolvedReviews = await db.review.findMany({
      where: resolvedWhere,
      select: { createdAt: true, resolvedAt: true },
    })

    let avgResponseTimeHours = 0
    if (resolvedReviews.length > 0) {
      const totalHours = resolvedReviews.reduce((acc, review) => {
        if (review.resolvedAt) {
          const diffMs = review.resolvedAt.getTime() - review.createdAt.getTime()
          return acc + (diffMs / (1000 * 60 * 60))
        }
        return acc
      }, 0)
      avgResponseTimeHours = Math.round((totalHours / resolvedReviews.length) * 10) / 10
    }

    // NPS
    const nps = totalCount > 0
      ? Math.round(((positiveCount - negativeCount) / totalCount) * 100)
      : 0

    // Reviews by service type
    const reviewsByServiceType = await db.review.groupBy({
      by: ['serviceType'],
      where: { ...where, deletedAt: null },
      _count: true,
      _avg: { rating: true },
    })

    return NextResponse.json({
      period: {
        from: dateFrom || null,
        to: dateTo || null,
      },
      totalReviews: totalCount,
      averageRating: Math.round((avgRating._avg.rating || 0) * 10) / 10,
      nps,
      sentimentBreakdown: {
        positive: positiveCount,
        negative: negativeCount,
      },
      statusBreakdown: {
        pending: pendingCount,
        acknowledged: acknowledgedCount,
        resolved: resolvedCount,
      },
      ratingDistribution,
      avgResponseTimeHours,
      reviewsByServiceType: reviewsByServiceType.map((item) => ({
        serviceType: item.serviceType,
        count: item._count,
        avgRating: Math.round((item._avg.rating || 0) * 10) / 10,
      })),
    })
  } catch (error) {
    console.error('Error en reporte resumen:', error)
    return NextResponse.json(
      { error: 'Error interno del servidor' },
      { status: 500 }
    )
  }
}