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 evaluaciones
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 tipoEvaluacion = searchParams.get('tipo'); // 'fisica' o 'deportiva'
    const ano = searchParams.get('ano') || new Date().getFullYear().toString();
    
    const fechaInicio = new Date(parseInt(ano), 0, 1);
    const fechaFin = new Date(parseInt(ano), 11, 31);
    
    // Obtener alumnos con evaluaciones
    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: {
          select: {
            nombres: true,
            apellidos: true
          }
        },
        evaluacionesFisicas: tipoEvaluacion !== 'deportiva' ? {
          where: {
            fecha: {
              gte: fechaInicio,
              lte: fechaFin
            }
          },
          orderBy: { fecha: 'desc' }
        } : undefined,
        evaluacionesDeportivas: tipoEvaluacion !== 'fisica' ? {
          where: {
            fecha: {
              gte: fechaInicio,
              lte: fechaFin
            }
          },
          orderBy: { fecha: 'desc' }
        } : undefined
      },
      orderBy: {
        usuario: {
          apellidos: 'asc'
        }
      }
    });
    
    // Cast to any for type safety
    const alumnos = alumnosData as any[];
    
    // Procesar evaluaciones físicas
    const resumenFisico = tipoEvaluacion !== 'deportiva' ? alumnos.map((alumno: any) => {
      const evals = alumno.evaluacionesFisicas || [];
      const ultima = evals[0];
      const primera = evals[evals.length - 1];
      
      return {
        alumnoId: alumno.id,
        nombre: `${alumno.usuario?.apellidos || ''}, ${alumno.usuario?.nombres || ''}`,
        categoria: alumno.categoria,
        cantidadEvaluaciones: evals.length,
        ultimaEvaluacion: ultima ? {
          fecha: ultima.fecha,
          puntajeAgilidad: ultima.puntajeAgilidad,
          tiempoVelocidad: ultima.tiempoVelocidad,
          saltoVertical: ultima.saltoVertical,
          saltoHorizontal: ultima.saltoHorizontal
        } : null,
        progreso: primera && ultima && evals.length > 1 ? {
          agilidad: (ultima.puntajeAgilidad || 0) - (primera.puntajeAgilidad || 0),
          velocidad: primera.tiempoVelocidad && ultima.tiempoVelocidad 
            ? primera.tiempoVelocidad - ultima.tiempoVelocidad 
            : null,
          saltoVertical: (ultima.saltoVertical || 0) - (primera.saltoVertical || 0),
          saltoHorizontal: (ultima.saltoHorizontal || 0) - (primera.saltoHorizontal || 0)
        } : null
      };
    }) : [];
    
    // Procesar evaluaciones deportivas
    const resumenDeportivo = tipoEvaluacion !== 'fisica' ? alumnos.map((alumno: any) => {
      const evals = alumno.evaluacionesDeportivas || [];
      const ultima = evals[0];
      const primera = evals[evals.length - 1];
      
      return {
        alumnoId: alumno.id,
        nombre: `${alumno.usuario?.apellidos || ''}, ${alumno.usuario?.nombres || ''}`,
        categoria: alumno.categoria,
        cantidadEvaluaciones: evals.length,
        ultimaEvaluacion: ultima ? {
          fecha: ultima.fecha,
          tecnica: ultima.tecnica,
          fuerza: ultima.fuerza,
          ataque: ultima.ataque,
          defensa: ultima.defensa,
          resistencia: ultima.resistencia,
          velocidad: ultima.velocidad,
          puntajeTotal: ultima.puntajeTotal,
          posicionesPreferentes: ultima.posicionesPreferentes
        } : null,
        progreso: primera && ultima && evals.length > 1 ? {
          tecnica: (ultima.tecnica || 0) - (primera.tecnica || 0),
          fuerza: (ultima.fuerza || 0) - (primera.fuerza || 0),
          ataque: (ultima.ataque || 0) - (primera.ataque || 0),
          defensa: (ultima.defensa || 0) - (primera.defensa || 0),
          resistencia: (ultima.resistencia || 0) - (primera.resistencia || 0),
          velocidad: (ultima.velocidad || 0) - (primera.velocidad || 0),
          puntajeTotal: (ultima.puntajeTotal || 0) - (primera.puntajeTotal || 0)
        } : null
      };
    }) : [];
    
    // Calcular promedios generales
    const promediosDeportivos = resumenDeportivo
      .filter(r => r.ultimaEvaluacion)
      .reduce((acc, r) => {
        if (r.ultimaEvaluacion) {
          acc.tecnica += r.ultimaEvaluacion.tecnica || 0;
          acc.fuerza += r.ultimaEvaluacion.fuerza || 0;
          acc.ataque += r.ultimaEvaluacion.ataque || 0;
          acc.defensa += r.ultimaEvaluacion.defensa || 0;
          acc.resistencia += r.ultimaEvaluacion.resistencia || 0;
          acc.velocidad += r.ultimaEvaluacion.velocidad || 0;
          acc.count++;
        }
        return acc;
      }, { tecnica: 0, fuerza: 0, ataque: 0, defensa: 0, resistencia: 0, velocidad: 0, count: 0 });
    
    const promedioFinal = promediosDeportivos.count > 0 ? {
      tecnica: (promediosDeportivos.tecnica / promediosDeportivos.count).toFixed(1),
      fuerza: (promediosDeportivos.fuerza / promediosDeportivos.count).toFixed(1),
      ataque: (promediosDeportivos.ataque / promediosDeportivos.count).toFixed(1),
      defensa: (promediosDeportivos.defensa / promediosDeportivos.count).toFixed(1),
      resistencia: (promediosDeportivos.resistencia / promediosDeportivos.count).toFixed(1),
      velocidad: (promediosDeportivos.velocidad / promediosDeportivos.count).toFixed(1)
    } : null;
    
    return NextResponse.json({
      success: true,
      reporte: {
        periodo: {
          ano: parseInt(ano),
          categoria: categoria || 'Todas',
          tipoEvaluacion: tipoEvaluacion || 'ambas'
        },
        resumen: {
          totalAlumnos: alumnos.length,
          alumnosConEvalFisica: resumenFisico.filter(r => r.ultimaEvaluacion).length,
          alumnosConEvalDeportiva: resumenDeportivo.filter(r => r.ultimaEvaluacion).length,
          promediosDeportivos: promedioFinal
        },
        evaluacionesFisicas: tipoEvaluacion !== 'deportiva' ? resumenFisico : undefined,
        evaluacionesDeportivas: tipoEvaluacion !== 'fisica' ? resumenDeportivo : undefined
      }
    });
    
  } catch (error) {
    console.error('Error generando reporte de evaluaciones:', error);
    return NextResponse.json(
      { success: false, error: 'Error generando reporte' },
      { status: 500 }
    );
  }
}
