File size: 3,415 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
import { NextRequest, NextResponse } from "next/server";
import prisma from "@/lib/prisma";
import { ElevenLabsClient } from "@/utils/elevenlabs";

export async function POST(
  request: NextRequest,
  { params }: { params: { inviteCode: string } }
) {
  try {
    // Attendre la résolution des paramètres
    const { inviteCode } = await Promise.resolve(params);
    const formData = await request.formData();
    const audioFile = formData.get("audio") as Blob;
    const userId = formData.get("userId") as string;

    if (!audioFile || !userId) {
      return NextResponse.json(
        { error: "Audio et ID utilisateur requis" },
        { status: 400 }
      );
    }

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

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

    const currentRound = group.gameState.rounds[0];
    const currentPlayer = group.members.find(
      (m) => m.userId === parseInt(userId)
    );

    if (!currentPlayer) {
      return NextResponse.json({ error: "Joueur non trouvé" }, { status: 404 });
    }

    // Vérifier si c'est le tour du joueur
    const playerIndex = group.members.indexOf(currentPlayer);
    const shouldBePlayerIndex = currentRound.roundNumber % group.members.length;

    if (playerIndex !== shouldBePlayerIndex) {
      return NextResponse.json(
        { error: "Ce n'est pas votre tour" },
        { status: 400 }
      );
    }

    // Si le joueur est celui dont la voix est volée, utiliser ElevenLabs
    if (currentPlayer.userId === group.gameState.stolenVoicePlayerId) {
      const stolenVoicePlayer = group.members.find(
        (m) =>
          m.userId !== group.gameState.stolenVoicePlayerId && m.user.voiceId
      );

      if (stolenVoicePlayer?.user.voiceId) {
        const elevenlabs = new ElevenLabsClient(
          process.env.ELEVENLABS_API_KEY!
        );
        // TODO: Implémenter la transcription de l'audio pour obtenir le texte
        const text = "Voici ma réponse à la question...";
        await elevenlabs.generateSpeech(stolenVoicePlayer.user.voiceId, text);
      }
    }

    // Mettre à jour l'état du jeu
    if (playerIndex === group.members.length - 1) {
      // Si c'était le dernier joueur, passer à la phase de débat
      await prisma.gameState.update({
        where: { id: group.gameState.id },
        data: {
          status: "DEBATE",
        },
      });
    } else {
      // Sinon, mettre à jour le round pour le prochain joueur
      await prisma.gameRound.update({
        where: { id: currentRound.id },
        data: {
          speakerId:
            group.members[(playerIndex + 1) % group.members.length].userId,
        },
      });
    }

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