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

interface PagoWithAlumno {
  id: string;
  alumnoId: string;
  fecha: Date;
  monto: number;
  concepto: string;
  metodoPago: string;
  alumno: {
    usuario: {
      nombres: string;
      apellidos: string;
    };
  };
}

interface RegistroFinanciero {
  tipo: string;
  monto: number;
}

export async function GET(request: NextRequest) {
  try {
    const session = await getServerSession(authOptions);
    if (!session) {
      return NextResponse.json({ error: 'No autorizado' }, { status: 401 });
    }

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

    // Obtener pagos del año
    const startDate = new Date(parseInt(ano), 0, 1);
    const endDate = new Date(parseInt(ano), 11, 31);

    const pagos: PagoWithAlumno[] = await prisma.pagoDetalle.findMany({
      where: {
        fecha: {
          gte: startDate,
          lte: endDate
        }
      },
      include: {
        alumno: {
          include: {
            usuario: {
              select: {
                nombres: true,
                apellidos: true
              }
            }
          }
        }
      }
    });

    // Obtener registros financieros del año
    const registrosFinancieros: RegistroFinanciero[] = await prisma.registroFinanciero.findMany({
      where: {
        ano: parseInt(ano)
      }
    });

    // Calcular totales
    const totalPagosAlumnos = pagos.reduce((sum: number, p: PagoWithAlumno) => sum + p.monto, 0);
    const ingresosOtros = registrosFinancieros
      .filter((r: RegistroFinanciero) => r.tipo === 'INGRESO')
      .reduce((sum: number, r: RegistroFinanciero) => sum + r.monto, 0);
    const totalIngresos = totalPagosAlumnos + ingresosOtros;
    const totalEgresos = registrosFinancieros
      .filter((r: RegistroFinanciero) => r.tipo === 'EGRESO')
      .reduce((sum: number, r: RegistroFinanciero) => sum + r.monto, 0);
    const balance = totalIngresos - totalEgresos;

    // Pagos por mes
    const pagosPorMes = Array(12).fill(0);
    pagos.forEach((p: PagoWithAlumno) => {
      const mes = new Date(p.fecha).getMonth();
      pagosPorMes[mes] += p.monto;
    });

    // Pagos por concepto
    const pagosPorConcepto: { [key: string]: number } = {};
    pagos.forEach((p: PagoWithAlumno) => {
      pagosPorConcepto[p.concepto] = (pagosPorConcepto[p.concepto] || 0) + p.monto;
    });

    // Alumnos con más pagos
    const pagosPorAlumno: { [key: string]: { nombre: string, total: number, pagos: number } } = {};
    pagos.forEach((p: PagoWithAlumno) => {
      const nombre = `${p.alumno.usuario.nombres} ${p.alumno.usuario.apellidos}`;
      if (!pagosPorAlumno[p.alumnoId]) {
        pagosPorAlumno[p.alumnoId] = { nombre, total: 0, pagos: 0 };
      }
      pagosPorAlumno[p.alumnoId].total += p.monto;
      pagosPorAlumno[p.alumnoId].pagos += 1;
    });

    // Cantidad de alumnos únicos que han pagado
    const alumnosConPagos = Object.keys(pagosPorAlumno).length;

    // Total de alumnos activos
    const totalAlumnos = await prisma.alumno.count({
      where: {
        usuario: {
          activo: true
        }
      }
    });

    return NextResponse.json({
      ano: parseInt(ano),
      resumen: {
        totalIngresos,
        totalPagosAlumnos,
        ingresosOtros,
        totalEgresos,
        balance,
        cantidadPagos: pagos.length,
        alumnosConPagos,
        totalAlumnos,
        porcentajeAlumnosPagando: totalAlumnos > 0 ? Math.round((alumnosConPagos / totalAlumnos) * 100) : 0
      },
      pagosPorMes,
      pagosPorConcepto: Object.entries(pagosPorConcepto).map(([concepto, total]) => ({
        concepto,
        total
      })).sort((a, b) => b.total - a.total),
      topAlumnos: Object.values(pagosPorAlumno)
        .sort((a, b) => b.total - a.total)
        .slice(0, 10)
    });
  } catch (error) {
    console.error('Error fetching resumen financiero:', error);
    return NextResponse.json({ error: 'Error al obtener resumen' }, { status: 500 });
  }
}
