src/app/api/text/question/route.ts

import { NextResponse } from 'next/server';
import { Mistral } from "@mistralai/mistralai";

type Language = 'fr' | 'en' | 'es';

const mistral = new Mistral({apiKey: process.env.MISTRAL_API_KEY})

export async function POST(request: Request) {
    try {
        const body = await request.json();
        const { language, story, chat } = body;
        console.log('language:', language)
        console.log('story:', story)
        console.log('chat:', chat)

        const chatHistory = chat.messages
          .map((m: { role: string; content: string }) =>
            `${m.role === 'judge' ? 'Judge' : 'Lawyer'}: ${m.content}`
          )
          .join('\n');

        const prompts = {
            fr: `En tant que juge, génère une question difficile concernant cette affaire:
                ${story.description}

                Alibis du suspect: ${story.alibi.join(', ')}
                Problèmes dans sa défense: ${story.problematic.join(', ')}
                ${chat.messages.length > 0 ? `\nHistorique de la discussion:\n${chatHistory}` : ''}

                Génère aussi une liste de 3 mots ou expressions absurdes que l'avocat devra obligatoirement utiliser dans sa réponse.
                Ces expressions doivent être décalées et mettre l'avocat dans l'embarras mais etre relativement réaliste à l'affaire.

                Réponds en JSON avec ce format:
                {
                    "question": "Ta question incisive de juge ici",
                    "words": ["expression1", "expression2", "expression3"]
                }`,
            en: `As a judge, generate a tough question about this case:
                ${story.description}

                Suspect's alibis: ${story.alibi.join(', ')}
                Issues in their defense: ${story.problematic.join(', ')}
                ${chat.messages.length > 0 ? `Previous answers:\n${chatHistory}` : ''}

                Also generate a list of 3 absurd words or expressions that the lawyer must use in their response.
                These expressions should be quirky and put the lawyer in an awkward position but be relatively realistic to the case.

                Answer in JSON with this format:
                {
                    "question": "Your incisive judge question here",
                    "words": ["expression1", "expression2", "expression3"]
                }`,
            es: `Como juez, genera una pregunta difícil sobre este caso:
                ${story.description}

                Coartadas del sospechoso: ${story.alibi.join(', ')}
                Problemas en su defensa: ${story.problematic.join(', ')}
                ${chat.messages.length > 0 ? `Respuestas previas:\n${chatHistory}` : ''}

                También genera una lista de 3 palabras o expresiones absurdas que el abogado deberá usar en su respuesta.
                Estas expresiones deben ser extrañas y poner al abogado en una situación incómoda pero realista à l'affaire.

                Responde en JSON con este formato:
                {
                    "question": "Tu pregunta incisiva de juez aquí",
                    "words": ["expresión1", "expresión2", "expresión3"]
                }`
        };

        console.log('prompts:', prompts[language as Language])

        const seed = Math.floor(Math.random() * 1000000);

        console.log('seed:', seed)

        const response = await mistral.chat.complete({
            model: "mistral-small-latest",
            messages: [{role: 'user', content: prompts[language as Language]}],
            responseFormat: {type: 'json_object'},
            randomSeed: seed,
        });

        console.log('response:', response)

        const functionCall = response.choices?.[0]?.message.content;
        const JSONResponse = functionCall ? JSON.parse(functionCall as string) : null;
        console.log('functionCall:', functionCall)
        console.log('JSONResponse:', JSONResponse)

        return NextResponse.json(JSONResponse || {
            'question': 'Erreur de génération de question',
            'words': [],
            'status': 'error',
        });

    } catch (error: unknown) {
        console.log('error:', error)
        return NextResponse.json(
            { error: 'Erreur lors de la génération de la question' },
            { status: 500 }
        );
    }
}