File size: 3,350 Bytes
811126d
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
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 });
  }
}