import { NextResponse } from "next/server";
import {
  buildEvaluationInput,
  buildEvaluationInstructions,
  buildRoleplayInput,
  buildRoleplayInstructions,
} from "@/lib/prompts";
import {
  getEvaluationModel,
  getRoleplayModel,
  parseStructuredResponse,
} from "@/lib/openai";
import {
  DemoTurnRequestSchema,
  LiveEvaluationSchema,
  RoleplayResponseSchema,
} from "@/lib/schemas";
import { createRouteErrorResponse } from "@/lib/route-errors";
import { hydrateMetrics } from "@/lib/types";
import type { ChatMessage, ConversationStatus, TurnResponse } from "@/lib/types";

export const runtime = "nodejs";
const MIN_AUTO_CLOSE_TURNS = 2;

export async function POST(request: Request) {
  try {
    const payload = DemoTurnRequestSchema.parse(await request.json());

    if (payload.status !== "ongoing") {
      return NextResponse.json(
        { error: "Cette session est deja terminee." },
        { status: 409 },
      );
    }

    const userMessage: ChatMessage = {
      id: `${payload.sessionId}-user-${payload.userTurns + 1}`,
      role: "user",
      content: payload.userMessage.trim(),
      createdAt: new Date().toISOString(),
    };

    const transcript = [...payload.transcript, userMessage];

    const [roleplay, evaluation] = await Promise.all([
      parseStructuredResponse({
        schema: RoleplayResponseSchema,
        schemaName: "roleplay_response",
        model: getRoleplayModel(),
        instructions: buildRoleplayInstructions(payload.scenario),
        input: buildRoleplayInput(payload.scenario, transcript),
        temperature: 0.8,
        maxOutputTokens: 450,
      }),
      parseStructuredResponse({
        schema: LiveEvaluationSchema,
        schemaName: "live_evaluation",
        model: getEvaluationModel(),
        instructions: buildEvaluationInstructions(payload.scenario),
        input: buildEvaluationInput(payload.scenario, transcript),
        temperature: 0.3,
        maxOutputTokens: 520,
      }),
    ]);

    let status: ConversationStatus = roleplay.conversationStatus;
    if (payload.userTurns + 1 < MIN_AUTO_CLOSE_TURNS && status !== "ongoing") {
      status = "ongoing";
    }

    if (payload.userTurns + 1 >= payload.scenario.maxTurns && status === "ongoing") {
      status = "max_turns";
    }

    const assistantMessage: ChatMessage = {
      id: `${payload.sessionId}-assistant-${transcript.length}`,
      role: "assistant",
      content: roleplay.assistantMessage,
      createdAt: new Date().toISOString(),
    };

    const liveEvaluation = {
      metrics: hydrateMetrics(evaluation.metrics),
      coachingNote: evaluation.coachingNote,
      riskFlags: evaluation.riskFlags,
      learnerSignal: evaluation.learnerSignal,
    };

    const response: TurnResponse = {
      assistantMessage,
      liveEvaluation,
      conversationStatus: {
        status,
        reason:
          status === "max_turns"
            ? "Le nombre maximal de tours est atteint."
            : status === "ongoing" &&
                roleplay.conversationStatus !== "ongoing" &&
                payload.userTurns + 1 < MIN_AUTO_CLOSE_TURNS
              ? "La conversation continue : un second echange est requis avant une cloture automatique."
              : roleplay.reason,
      },
    };

    return NextResponse.json(response);
  } catch (error) {
    return createRouteErrorResponse(error, "La generation du tour a echoue.");
  }
}