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

// GET - Generar reporte de asistencia
export async function GET(request: NextRequest) {
  try {
    const session = await getServerSession(authOptions);
    
    if (!session?.user) {
      return NextResponse.json(
        { success: false, error: 'No autorizado' },
        { status: 401 }
      );
    }
    
    const { searchParams } = new URL(request.url);
    const categoria = searchParams.get('categoria');
    const mes = searchParams.get('mes');
    const ano = searchParams.get('ano') || new Date().getFullYear().toString();
    
    // Construir rango de fechas
    let fechaInicio: Date;
    let fechaFin: Date;
    
    if (mes) {
      fechaInicio = new Date(parseInt(ano), parseInt(mes) - 1, 1);
      fechaFin = new Date(parseInt(ano), parseInt(mes), 0);
    } else {
      fechaInicio = new Date(parseInt(ano), 0, 1);
      fechaFin = new Date(parseInt(ano), 11, 31);
    }
    
    // Obtener alumnos con sus asistencias mediante usuario
    const whereAlumno: Record<string, unknown> = {
      usuario: {
        escuelaId: session.user.escuelaId,
        activo: true
      }
    };
    
    if (categoria) {
      whereAlumno.categoria = categoria;
    }
    
    const alumnosData = await prisma.alumno.findMany({
      where: whereAlumno,
      include: {
        usuario: {
          include: {
            asistencias: {
              where: {
                fecha: {
                  gte: fechaInicio,
                  lte: fechaFin
                }
              },
              include: {
                evento: {
                  select: {
                    tipo: true,
                    descripcion: true
                  }
                }
              }
            }
          }
        }
      },
      orderBy: {
        usuario: {
          apellidos: 'asc'
        }
      }
    });
    
    // Cast to any for type safety
    const alumnos = alumnosData as any[];
    
    // Procesar datos para el reporte
    interface AsistenciaStats {
      totalEventos: number;
      presentes: number;
      ausentes: number;
      porcentaje: number;
      porTipoEvento: Record<string, { total: number; presentes: number }>;
    }
    
    const resumenPorAlumno = alumnos.map((alumno: any) => {
      const asistencias = alumno.usuario?.asistencias || [];
      const stats: AsistenciaStats = {
        totalEventos: asistencias.length,
        presentes: asistencias.filter((a: any) => a.presente).length,
        ausentes: asistencias.filter((a: any) => !a.presente).length,
        porcentaje: 0,
        porTipoEvento: {}
      };
      
      stats.porcentaje = stats.totalEventos > 0 
        ? Math.round((stats.presentes / stats.totalEventos) * 100) 
        : 0;
      
      // Agrupar por tipo de evento
      asistencias.forEach((a: any) => {
        const tipo = a.evento?.tipo || 'OTRO';
        if (!stats.porTipoEvento[tipo]) {
          stats.porTipoEvento[tipo] = { total: 0, presentes: 0 };
        }
        stats.porTipoEvento[tipo].total++;
        if (a.presente) {
          stats.porTipoEvento[tipo].presentes++;
        }
      });
      
      return {
        alumnoId: alumno.id,
        nombres: alumno.usuario?.nombres || '',
        apellidos: alumno.usuario?.apellidos || '',
        rut: alumno.usuario?.rut || '',
        categoria: alumno.categoria,
        ...stats
      };
    });
    
    // Calcular totales generales
    const totalGeneral = resumenPorAlumno.reduce((acc, alumno) => {
      acc.totalEventos += alumno.totalEventos;
      acc.presentes += alumno.presentes;
      acc.ausentes += alumno.ausentes;
      return acc;
    }, { totalEventos: 0, presentes: 0, ausentes: 0 });
    
    const promedioAsistencia = totalGeneral.totalEventos > 0
      ? Math.round((totalGeneral.presentes / totalGeneral.totalEventos) * 100)
      : 0;
    
    return NextResponse.json({
      success: true,
      reporte: {
        periodo: {
          fechaInicio: fechaInicio.toISOString(),
          fechaFin: fechaFin.toISOString(),
          mes: mes ? parseInt(mes) : null,
          ano: parseInt(ano),
          categoria: categoria || 'Todas'
        },
        resumen: {
          totalAlumnos: alumnos.length,
          totalEventosRegistrados: totalGeneral.totalEventos,
          totalPresentes: totalGeneral.presentes,
          totalAusentes: totalGeneral.ausentes,
          promedioAsistencia
        },
        detallePorAlumno: resumenPorAlumno
      }
    });
    
  } catch (error) {
    console.error('Error generando reporte de asistencia:', error);
    return NextResponse.json(
      { success: false, error: 'Error generando reporte' },
      { status: 500 }
    );
  }
}
