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

// GET /api/estadisticas - Obtener estadísticas globales
export async function GET(request: NextRequest) {
  try {
    const session = await getServerSession(authOptions);
    if (!session?.user) {
      return NextResponse.json({ error: 'No autorizado' }, { status: 401 });
    }

    const { searchParams } = new URL(request.url);
    const categoria = searchParams.get('categoria');
    const ano = searchParams.get('ano') || new Date().getFullYear().toString();

    const escuelaId = session.user.escuelaId || '';

    // Estadísticas de alumnos
    const alumnosWhere: Record<string, unknown> = {
      usuario: { escuelaId },
    };
    if (categoria) alumnosWhere.categoria = categoria;

    const totalAlumnos = await prisma.alumno.count({ where: alumnosWhere });

    const alumnosPorCategoria = await prisma.alumno.groupBy({
      by: ['categoria'],
      where: { usuario: { escuelaId } },
      _count: { id: true },
    });

    // Estadísticas de profesores
    const totalProfesores = await prisma.profesor.count({
      where: { usuario: { escuelaId, activo: true } },
    });

    // Estadísticas de eventos del año
    const eventosAno = await prisma.evento.findMany({
      where: {
        escuelaId,
        fecha: {
          gte: new Date(`${ano}-01-01`),
          lt: new Date(`${parseInt(ano) + 1}-01-01`),
        },
      },
    });

    const eventosPorTipo = {
      ENTRENAMIENTO: eventosAno.filter((e) => e.tipo === 'ENTRENAMIENTO').length,
      AMISTOSO: eventosAno.filter((e) => e.tipo === 'AMISTOSO').length,
      CAMPEONATO: eventosAno.filter((e) => e.tipo === 'CAMPEONATO').length,
    };

    const eventosPorMes: Record<number, number> = {};
    for (let i = 1; i <= 12; i++) {
      eventosPorMes[i] = eventosAno.filter(
        (e) => new Date(e.fecha).getMonth() + 1 === i
      ).length;
    }

    // Estadísticas de asistencia
    const asistenciasAno = await prisma.asistencia.findMany({
      where: {
        evento: {
          escuelaId,
          fecha: {
            gte: new Date(`${ano}-01-01`),
            lt: new Date(`${parseInt(ano) + 1}-01-01`),
          },
        },
      },
    });

    const totalAsistencias = asistenciasAno.filter((a) => a.presente).length;
    const totalAusencias = asistenciasAno.filter((a) => !a.presente).length;
    const porcentajeAsistencia = asistenciasAno.length > 0
      ? Math.round((totalAsistencias / asistenciasAno.length) * 100)
      : 0;

    // Estadísticas de partidos (fichas)
    const fichasPartido = await prisma.fichaPartido.findMany({
      where: {
        fecha: {
          gte: new Date(`${ano}-01-01`),
          lt: new Date(`${parseInt(ano) + 1}-01-01`),
        },
        evento: { escuelaId },
      },
      include: {
        goles: true,
        tarjetas: true,
      },
    });

    const estadisticasPartidos = {
      total: fichasPartido.length,
      victorias: fichasPartido.filter((f) => f.resultado === 'VICTORIA').length,
      empates: fichasPartido.filter((f) => f.resultado === 'EMPATE').length,
      derrotas: fichasPartido.filter((f) => f.resultado === 'DERROTA').length,
      golesAFavor: fichasPartido.reduce((sum, f) => sum + f.golesAFavor, 0),
      golesEnContra: fichasPartido.reduce((sum, f) => sum + f.golesEnContra, 0),
      tarjetasAmarillas: fichasPartido.reduce(
        (sum, f) => sum + f.tarjetas.filter((t) => t.tipo === 'AMARILLA').length,
        0
      ),
      tarjetasRojas: fichasPartido.reduce(
        (sum, f) => sum + f.tarjetas.filter((t) => t.tipo === 'ROJA').length,
        0
      ),
    };

    // Top goleadores del año
    const golesAgrupados = await prisma.golPartido.groupBy({
      by: ['alumnoId'],
      where: {
        fichaPartido: {
          fecha: {
            gte: new Date(`${ano}-01-01`),
            lt: new Date(`${parseInt(ano) + 1}-01-01`),
          },
        },
      },
      _count: { id: true },
      orderBy: { _count: { id: 'desc' } },
      take: 10,
    });

    const topGoleadores = await Promise.all(
      golesAgrupados.map(async (g) => {
        const alumno = await prisma.alumno.findUnique({
          where: { id: g.alumnoId },
          include: {
            usuario: { select: { nombres: true, apellidos: true } },
          },
        });
        return {
          alumnoId: g.alumnoId,
          nombre: alumno
            ? `${alumno.usuario.nombres} ${alumno.usuario.apellidos}`
            : 'Desconocido',
          categoria: alumno?.categoria || '',
          goles: g._count.id,
        };
      })
    );

    // Evaluaciones del año
    const evaluacionesFisicas = await prisma.evaluacionFisica.count({
      where: {
        fecha: {
          gte: new Date(`${ano}-01-01`),
          lt: new Date(`${parseInt(ano) + 1}-01-01`),
        },
      },
    });

    const evaluacionesDeportivas = await prisma.evaluacionDeportiva.count({
      where: {
        fecha: {
          gte: new Date(`${ano}-01-01`),
          lt: new Date(`${parseInt(ano) + 1}-01-01`),
        },
      },
    });

    // Campeonatos activos
    const campeonatosActivos = await prisma.campeonato.count({
      where: { escuelaId, activo: true },
    });

    // Finanzas del año
    const pagosAno = await prisma.pagoDetalle.aggregate({
      where: {
        fecha: {
          gte: new Date(`${ano}-01-01`),
          lt: new Date(`${parseInt(ano) + 1}-01-01`),
        },
      },
      _sum: { monto: true },
      _count: { id: true },
    });

    return NextResponse.json({
      ano: parseInt(ano),
      alumnos: {
        total: totalAlumnos,
        porCategoria: alumnosPorCategoria.map((a) => ({
          categoria: a.categoria,
          cantidad: a._count.id,
        })),
      },
      profesores: { total: totalProfesores },
      eventos: {
        total: eventosAno.length,
        porTipo: eventosPorTipo,
        porMes: eventosPorMes,
      },
      asistencia: {
        totalAsistencias,
        totalAusencias,
        porcentaje: porcentajeAsistencia,
      },
      partidos: estadisticasPartidos,
      topGoleadores,
      evaluaciones: {
        fisicas: evaluacionesFisicas,
        deportivas: evaluacionesDeportivas,
      },
      campeonatos: { activos: campeonatosActivos },
      finanzas: {
        totalRecaudado: pagosAno._sum.monto || 0,
        cantidadPagos: pagosAno._count.id,
      },
    });
  } catch (error) {
    console.error('Error fetching estadisticas:', error);
    return NextResponse.json({ error: 'Error al obtener estadísticas' }, { status: 500 });
  }
}
