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

// GET /api/campeonatos/[id] - Obtener detalle
export async function GET(
  request: NextRequest,
  { params }: { params: Promise<{ id: string }> }
) {
  try {
    const session = await getServerSession(authOptions);
    if (!session?.user) {
      return NextResponse.json({ error: 'No autorizado' }, { status: 401 });
    }

    const { id } = await params;

    const campeonato = await prisma.campeonato.findUnique({
      where: { id },
      include: {
        jugadores: {
          include: {
            usuario: {
              select: {
                nombres: true,
                apellidos: true,
                foto: true,
              },
            },
          },
        },
        cuerpoTecnico: {
          include: {
            usuario: {
              select: {
                nombres: true,
                apellidos: true,
              },
            },
          },
        },
        partidos: {
          orderBy: { fecha: 'asc' },
          include: {
            estadisticas: {
              include: {
                alumno: {
                  include: {
                    usuario: {
                      select: { nombres: true, apellidos: true },
                    },
                  },
                },
              },
            },
          },
        },
      },
    });

    if (!campeonato) {
      return NextResponse.json({ error: 'Campeonato no encontrado' }, { status: 404 });
    }

    // Calcular tabla de goleadores y estadísticas
    const estadisticasJugadores: Record<string, {
      alumnoId: string;
      nombre: string;
      partidosJugados: number;
      minutosJugados: number;
      goles: number;
      asistencias: number;
      tarjetasAmarillas: number;
      tarjetasRojas: number;
    }> = {};

    campeonato.partidos.forEach((partido) => {
      partido.estadisticas.forEach((est) => {
        if (!estadisticasJugadores[est.alumnoId]) {
          estadisticasJugadores[est.alumnoId] = {
            alumnoId: est.alumnoId,
            nombre: `${est.alumno.usuario.nombres} ${est.alumno.usuario.apellidos}`,
            partidosJugados: 0,
            minutosJugados: 0,
            goles: 0,
            asistencias: 0,
            tarjetasAmarillas: 0,
            tarjetasRojas: 0,
          };
        }
        estadisticasJugadores[est.alumnoId].partidosJugados += 1;
        estadisticasJugadores[est.alumnoId].minutosJugados += est.minutosJugados;
        estadisticasJugadores[est.alumnoId].goles += est.goles;
        estadisticasJugadores[est.alumnoId].asistencias += est.asistencias;
        estadisticasJugadores[est.alumnoId].tarjetasAmarillas += est.tarjetasAmarillas;
        estadisticasJugadores[est.alumnoId].tarjetasRojas += est.tarjetasRojas;
      });
    });

    const tablaGoleadores = Object.values(estadisticasJugadores)
      .sort((a, b) => b.goles - a.goles)
      .slice(0, 10);

    const stats = {
      partidosJugados: campeonato.partidos.filter((p) => p.golesAFavor !== null).length,
      partidosProgramados: campeonato.partidos.filter((p) => p.golesAFavor === null).length,
      victorias: campeonato.partidos.filter(
        (p) => p.golesAFavor !== null && p.golesEnContra !== null && p.golesAFavor > p.golesEnContra
      ).length,
      empates: campeonato.partidos.filter(
        (p) => p.golesAFavor !== null && p.golesEnContra !== null && p.golesAFavor === p.golesEnContra
      ).length,
      derrotas: campeonato.partidos.filter(
        (p) => p.golesAFavor !== null && p.golesEnContra !== null && p.golesAFavor < p.golesEnContra
      ).length,
      golesAFavor: campeonato.partidos.reduce((sum, p) => sum + (p.golesAFavor || 0), 0),
      golesEnContra: campeonato.partidos.reduce((sum, p) => sum + (p.golesEnContra || 0), 0),
    };

    return NextResponse.json({
      campeonato,
      stats,
      tablaGoleadores,
      estadisticasJugadores: Object.values(estadisticasJugadores),
    });
  } catch (error) {
    console.error('Error fetching campeonato:', error);
    return NextResponse.json({ error: 'Error al obtener campeonato' }, { status: 500 });
  }
}

// PUT /api/campeonatos/[id] - Actualizar campeonato
export async function PUT(
  request: NextRequest,
  { params }: { params: Promise<{ id: string }> }
) {
  try {
    const session = await getServerSession(authOptions);
    if (!session?.user) {
      return NextResponse.json({ error: 'No autorizado' }, { status: 401 });
    }

    if (session.user.rol !== 'COORDINADOR') {
      return NextResponse.json({ error: 'Solo coordinadores pueden editar campeonatos' }, { status: 403 });
    }

    const { id } = await params;
    const body = await request.json();
    const { nombre, categoria, fechaInicio, fechaFin, organizador, activo, jugadoresIds, profesoresIds } = body;

    const campeonato = await prisma.campeonato.update({
      where: { id },
      data: {
        ...(nombre && { nombre }),
        ...(categoria && { categoria }),
        ...(fechaInicio && { fechaInicio: new Date(fechaInicio) }),
        ...(fechaFin && { fechaFin: new Date(fechaFin) }),
        ...(organizador && { organizador }),
        ...(activo !== undefined && { activo }),
        ...(jugadoresIds && {
          jugadores: { set: jugadoresIds.map((jid: string) => ({ id: jid })) },
        }),
        ...(profesoresIds && {
          cuerpoTecnico: { set: profesoresIds.map((pid: string) => ({ id: pid })) },
        }),
      },
      include: {
        jugadores: true,
        cuerpoTecnico: true,
      },
    });

    return NextResponse.json({ campeonato });
  } catch (error) {
    console.error('Error updating campeonato:', error);
    return NextResponse.json({ error: 'Error al actualizar campeonato' }, { status: 500 });
  }
}

// DELETE /api/campeonatos/[id] - Eliminar campeonato
export async function DELETE(
  request: NextRequest,
  { params }: { params: Promise<{ id: string }> }
) {
  try {
    const session = await getServerSession(authOptions);
    if (!session?.user) {
      return NextResponse.json({ error: 'No autorizado' }, { status: 401 });
    }

    if (session.user.rol !== 'COORDINADOR') {
      return NextResponse.json({ error: 'Solo coordinadores pueden eliminar campeonatos' }, { status: 403 });
    }

    const { id } = await params;

    // Eliminar estadísticas y partidos primero
    const partidos = await prisma.partidoCampeonato.findMany({
      where: { campeonatoId: id },
    });

    for (const partido of partidos) {
      await prisma.estadisticaCampeonato.deleteMany({
        where: { partidoId: partido.id },
      });
    }

    await prisma.partidoCampeonato.deleteMany({
      where: { campeonatoId: id },
    });

    await prisma.campeonato.delete({ where: { id } });

    return NextResponse.json({ message: 'Campeonato eliminado' });
  } catch (error) {
    console.error('Error deleting campeonato:', error);
    return NextResponse.json({ error: 'Error al eliminar campeonato' }, { status: 500 });
  }
}
