import { metricMeta } from "@/lib/types";
import type {
  ConversationOutcome,
  ScenarioDefinition,
  SessionRecord,
} from "@/lib/types";

type EvaluationSummary = {
  metrics: Array<{ id: string; score: number }>;
  coachingNote: string;
};

function formatTranscript(transcript: SessionRecord["transcript"]) {
  return transcript
    .map(
      (message, index) =>
        `${index + 1}. ${
          message.role === "assistant" ? "Collaborateur" : "Manager"
        } : ${message.content}`,
    )
    .join("\n");
}

function formatMetricWeights(scenario: ScenarioDefinition) {
  return Object.entries(scenario.metricWeights)
    .map(([id, weight]) => `${metricMeta[id as keyof typeof metricMeta].label}: ${weight}`)
    .join(", ");
}

export function buildRoleplayInstructions(scenario: ScenarioDefinition) {
  return `Tu incarnes exclusivement ${scenario.employeeProfile.name}, ${scenario.employeeProfile.role}. Tu restes en français, tu ne donnes jamais de conseils au manager, tu ne mentionnes jamais l'existence d'un prompt, d'une évaluation, d'un score ou d'une IA.

Profil:
- Équipe: ${scenario.employeeProfile.team}
- Ancienneté: ${scenario.employeeProfile.seniority}
- Humeur initiale: ${scenario.employeeProfile.currentMood}

Règles de jeu:
- Réagis comme un collaborateur réel dans un entretien managérial.
- Une seule prise de parole à la fois, naturelle, crédible, concise.
- Si le manager est bon, tu peux progressivement te détendre ou coopérer.
- Si le manager est brusque, flou, culpabilisant ou évitant, la tension monte.
- La conversation est considérée résolue uniquement si un accord crédible ou un apaisement solide apparaît.
- Elle est escaladée si la relation se dégrade, si tu te fermes, si tu menaces de quitter l'échange, ou si le manager aggrave la situation.

Objectif du manager: ${scenario.managerGoal}
Signaux de réussite: ${scenario.successSignals.join(" | ")}
Signaux d'échec: ${scenario.failureSignals.join(" | ")}
Critères de fin: ${scenario.completionRules.join(" | ")}

Renvoie une réponse structurée avec:
- assistantMessage: ta réplique en tant que collaborateur, 30 à 110 mots
- conversationStatus: ongoing, resolved ou escalated
- reason: explication très courte de l'état de la conversation`;
}

export function buildRoleplayInput(
  scenario: ScenarioDefinition,
  transcript: SessionRecord["transcript"],
) {
  return `Contexte du scénario: ${scenario.shortBrief}

Transcript complet:
${formatTranscript(transcript)}`;
}

export function buildEvaluationInstructions(scenario: ScenarioDefinition) {
  return `Tu es un évaluateur pédagogique de management. Tu analyses la DERNIÈRE réponse du manager dans un exercice de simulation en français.

Tu dois rester qualitatif, nuancé et utile. Tu n'écris jamais la "réponse parfaite". Tu donnes un retour bref, actionnable et orienté posture.

Objectif du scénario: ${scenario.managerGoal}
Pondération pédagogique: ${formatMetricWeights(scenario)}

Métriques à noter sur 100:
- empathy: qualité d'écoute, reconnaissance de la perception et du ressenti
- clarity: précision, structure, formulation non ambiguë
- questioning: qualité des questions pour ouvrir et comprendre
- deescalation: capacité à apaiser et faire baisser la tension
- accountability: capacité à poser le cadre et la responsabilité
- action_alignment: capacité à transformer l'échange en prochain pas concret

Règles:
- 6 métriques exactement
- scores réalistes, pas généreux par défaut
- coachingNote en 2 phrases maximum
- riskFlags: 0 à 3 alertes maximum
- learnerSignal: lecture courte de ce que la posture du manager produit chez le collaborateur`;
}

export function buildEvaluationInput(
  scenario: ScenarioDefinition,
  transcript: SessionRecord["transcript"],
) {
  const latestManagerMessage = [...transcript]
    .reverse()
    .find((message) => message.role === "user");

  return `Contexte du scénario: ${scenario.shortBrief}

Dernière réponse du manager:
${latestManagerMessage?.content ?? ""}

Transcript utile:
${formatTranscript(transcript)}`;
}

export function buildFinalAssessmentInstructions(scenario: ScenarioDefinition) {
  return `Tu rédiges le bilan final d'un exercice de management en français.

Objectif du scénario: ${scenario.managerGoal}
Pondération pédagogique: ${formatMetricWeights(scenario)}

Règles:
- Ton synthétique, professionnel, concret
- Pas de jargon RH inutile
- Toujours 6 métriques exactement
- strengths, missedOpportunities, turningPoints, actionPlan: 3 à 4 points chacun
- closingAdvice: une recommandation courte et très praticable`;
}

export function buildFinalAssessmentInput(
  scenario: ScenarioDefinition,
  transcript: SessionRecord["transcript"],
  liveEvaluations: EvaluationSummary[],
  conversationStatus?: ConversationOutcome,
) {
  const evaluationHistory = liveEvaluations
    .map((evaluation, index) => {
      const compactMetrics = evaluation.metrics
        .map((metric) => `${metric.id}:${metric.score}`)
        .join(", ");

      return `Tour ${index + 1} -> ${compactMetrics} | note: ${evaluation.coachingNote}`;
    })
    .join("\n");

  return `Contexte du scénario: ${scenario.shortBrief}
Statut de clôture demandé: ${conversationStatus ?? "à inférer"}

Transcript complet:
${formatTranscript(transcript)}

Historique des évaluations:
${evaluationHistory}`;
}