import { NextRequest, NextResponse } from "next/server"
import { getServerSession } from "next-auth"
import { authOptions } from "@/lib/auth"
import { prisma } from "@/lib/prisma"

interface ActivityEvent {
  id: string
  type: 'user_registered' | 'report_created' | 'appointment_created' | 'appointment_completed'
  title: string
  description: string
  timestamp: Date
  color: 'green' | 'blue' | 'purple' | 'orange'
}

export async function GET(request: NextRequest) {
  try {
    const session = await getServerSession(authOptions)

    if (!session?.user?.id) {
      return NextResponse.json(
        { error: "No autorizado" },
        { status: 401 }
      )
    }

    if (session.user.role !== "ADMIN") {
      return NextResponse.json(
        { error: "Acceso denegado. Solo administradores." },
        { status: 403 }
      )
    }

    const { searchParams } = new URL(request.url)
    const limit = parseInt(searchParams.get("limit") || "10")

    // Obtener últimos usuarios registrados
    const recentUsers = await prisma.user.findMany({
      where: {
        role: "PATIENT"
      },
      select: {
        id: true,
        name: true,
        lastname: true,
        createdAt: true
      },
      orderBy: {
        createdAt: "desc"
      },
      take: 5
    })

    // Obtener últimos reportes creados
    const recentReports = await prisma.record.findMany({
      select: {
        id: true,
        createdAt: true,
        chatType: true,
        user: {
          select: {
            name: true,
            lastname: true
          }
        }
      },
      orderBy: {
        createdAt: "desc"
      },
      take: 5
    })

    // Obtener últimas citas completadas
    const recentAppointments = await prisma.appointment.findMany({
      where: {
        estado: "COMPLETADA"
      },
      select: {
        id: true,
        createdAt: true,
        updatedAt: true,
        estado: true,
        paciente: {
          select: {
            name: true,
            lastname: true
          }
        }
      },
      orderBy: {
        updatedAt: "desc"
      },
      take: 5
    })

    // Convertir a eventos unificados
    const activities: ActivityEvent[] = []

    // Agregar usuarios registrados
    recentUsers.forEach(user => {
      activities.push({
        id: `user-${user.id}`,
        type: 'user_registered',
        title: 'Nuevo paciente registrado',
        description: `${user.name} ${user.lastname}`,
        timestamp: user.createdAt,
        color: 'green'
      })
    })

    // Agregar reportes
    recentReports.forEach(report => {
      activities.push({
        id: `report-${report.id}`,
        type: 'report_created',
        title: report.chatType === 'PSYCHOLOGICAL' ? 'Reporte psicológico generado' : 'Reporte médico generado',
        description: `${report.user.name} ${report.user.lastname}`,
        timestamp: report.createdAt,
        color: 'blue'
      })
    })

    // Agregar citas completadas
    recentAppointments.forEach(apt => {
      activities.push({
        id: `appointment-${apt.id}`,
        type: 'appointment_completed',
        title: 'Consulta completada',
        description: `${apt.paciente.name} ${apt.paciente.lastname}`,
        timestamp: apt.updatedAt,
        color: 'purple'
      })
    })

    // Ordenar todos los eventos por fecha (más reciente primero)
    activities.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime())

    // Limitar al número solicitado
    const limitedActivities = activities.slice(0, limit)

    return NextResponse.json({
      activities: limitedActivities,
      total: activities.length
    })

  } catch (error) {
    console.error("Error in recent activity API:", error)
    return NextResponse.json(
      { error: "Error al obtener actividad reciente" },
      { status: 500 }
    )
  }
}