notme/src/app/api/game/[inviteCode]/answer/route.ts

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 });
  }
}