import { NextRequest, NextResponse } from "next/server";
import prisma from "@/lib/prisma";

export async function POST(
  request: NextRequest,
  { params }: { params: { inviteCode: string } }
) {
  try {
    const { inviteCode } = await params;
    const { userId, votedPlayerId } = await request.json();

    if (!userId || !votedPlayerId) {
      return NextResponse.json(
        { error: "ID utilisateur et ID du joueur voté requis" },
        { status: 400 }
      );
    }

    // Récupérer le groupe et son état
    const group = await prisma.group.findUnique({
      where: { inviteCode },
      include: {
        members: true,
        gameState: {
          include: {
            rounds: {
              orderBy: {
                roundNumber: "desc",
              },
              take: 1,
              include: {
                guesses: true,
              },
            },
          },
        },
      },
    });

    if (!group || !group.gameState) {
      return NextResponse.json(
        { error: "Groupe ou partie non trouvé" },
        { status: 404 }
      );
    }

    const currentRound = group.gameState.rounds[0];

    // Vérifier que le joueur n'a pas déjà voté
    const hasVoted = currentRound.guesses.some(
      (g) => g.guesserId === parseInt(userId)
    );
    if (hasVoted) {
      return NextResponse.json(
        { error: "Vous avez déjà voté" },
        { status: 400 }
      );
    }

    // Enregistrer le vote
    await prisma.guess.create({
      data: {
        gameRoundId: currentRound.id,
        guesserId: parseInt(userId),
        guessedId: parseInt(votedPlayerId),
        isCorrect:
          parseInt(votedPlayerId) === group.gameState.stolenVoicePlayerId,
      },
    });

    // Vérifier si tout le monde a voté
    const totalVotes = currentRound.guesses.length + 1; // +1 pour le vote qu'on vient d'ajouter
    if (totalVotes === group.members.length) {
      // Compter les votes
      const votes = await prisma.guess.groupBy({
        by: ["guessedId"],
        where: {
          gameRoundId: currentRound.id,
        },
        _count: {
          guessedId: true,
        },
      });

      // Trouver le joueur le plus voté
      const mostVotedPlayer = votes.reduce((prev, current) =>
        current._count.guessedId > prev._count.guessedId ? current : prev
      );

      if (mostVotedPlayer.guessedId === group.gameState.stolenVoicePlayerId) {
        // Les joueurs ont gagné
        await prisma.gameState.update({
          where: { id: group.gameState.id },
          data: {
            status: "FINISHED",
            endedAt: new Date(),
            winnerId: null, // Victoire de l'équipe
          },
        });
      } else {
        // Commencer un nouveau round
        await prisma.gameRound.create({
          data: {
            gameStateId: group.gameState.id,
            roundNumber: currentRound.roundNumber + 1,
          },
        });

        await prisma.gameState.update({
          where: { id: group.gameState.id },
          data: {
            status: "ANSWERS",
          },
        });
      }
    }

    return NextResponse.json({ success: true });
  } catch (error) {
    console.error("Erreur lors de l'enregistrement du vote:", error);
    return NextResponse.json({ error: "Erreur serveur" }, { status: 500 });
  }
}