import { PrismaClient } from "@prisma/client";

const prisma = new PrismaClient();

const SUGGESTED_QUESTIONS: Record<string, string[]> = {
  tools: [
    "Quels outils IA utilisez-vous au quotidien ?",
    "Comment les avez-vous choisis et intégrés à votre workflow personnel ?",
    "Utilisez-vous des rules, skills ou agents (Cursor, etc.) pour configurer vos outils ?",
    "Comment avez-vous personnalisé votre setup pour l'adapter à vos usages ?",
  ],
  prompts: [
    "Comment structurez-vous vos prompts pour des tâches complexes ?",
    "Utilisez-vous des templates ou des patterns réutilisables ?",
    "Comment gérez-vous les cas limites et les outputs inattendus ?",
  ],
  context: [
    "Quels fichiers ou parties du codebase incluez-vous typiquement dans le contexte (selon l'outil : @, #, fichiers ouverts...) ?",
    "Comment choisissez-vous ce qui mérite d'être inclus vs laissé hors du contexte ?",
    "Comment choisissez-vous le modèle (selon la tâche, la taille du contexte, le coût) ?",
    "Utilisez-vous des règles pré-chargées (rules, .cursorrules, config projet) pour fournir du contexte ?",
    "Avez-vous des stratégies pour limiter la taille du contexte tout en restant pertinent ?",
  ],
  iteration: [
    "Comment itérez-vous quand la première réponse ne convient pas ?",
    "Décomposez-vous les tâches complexes en sous-étapes ou sous-agents ?",
    "Utilisez-vous l'IA comme sparring partner pour réfléchir ?",
    "Avez-vous des workflows agentiques (agents, sous-agents) ?",
  ],
  evaluation: [
    "Comment vérifiez-vous les sorties de l'IA avant de les utiliser ?",
    "Avez-vous des critères explicites de qualité ?",
    "Repérez-vous les générations excessives ou les infos dupliquées dans les sorties IA ?",
    "Comment gérez-vous les hallucinations ou erreurs subtiles ?",
  ],
  integration: [
    "Comment l'IA est-elle discutée et partagée dans l'équipe ?",
    "Y a-t-il des pratiques formalisées ou documentées ?",
    "Comment les nouveaux arrivants sont-ils onboardés sur ces usages ?",
  ],
  usecases: [
    "Quels cas d'usage couvrez-vous (snippets, tests, refacto, debug...) ?",
    "Quel est votre cas d'usage principal ?",
    "Avez-vous exploré des usages plus avancés (discovery, review, agents, skills) ?",
  ],
  conception: [
    "Utilisez-vous l'IA en mode plan / conception avant de coder (SDD, design, architecture) ?",
    "Comment structurez-vous la phase de conception (documents, schémas, décisions) ?",
    "L'IA vous aide-t-elle à explorer des options de design ou à challenger vos choix ?",
    "Comment validez-vous la cohérence architecturale des propositions IA ?",
  ],
  exploration: [
    "Testez-vous régulièrement de nouveaux workflows ou techniques trouvés (web, communautés, docs) ?",
    "Comment identifiez-vous ce qui améliore le contexte ou la pertinence des sorties IA ?",
    "Avez-vous des exemples de techniques découvertes en ligne qui ont changé votre façon de travailler ?",
    "Comment validez-vous qu'une nouvelle pratique vaut le coup avant de l'adopter ?",
  ],
  impact: [
    "Quel impact mesurable l'IA a-t-elle sur votre delivery ?",
    "Comment le quantifiez-vous (temps, qualité, vélocité) ?",
    "L'IA est-elle un levier stratégique pour l'équipe ?",
  ],
  alignment: [
    "Comment vous assurez-vous que le code généré respecte vos standards ?",
    "Comment intégrez-vous les NFR (perf, sécurité, observabilité...) dans le contexte pour l'IA ?",
    "Avez-vous des garde-fous pour l'alignement archi ?",
    "Comment gérez-vous le rework quand l'IA sort du cadre ?",
  ],
  quality_usage: [
    "Utilisez-vous l'IA pour les tests ? Comment ?",
    "Et pour la revue de code ou le refactoring ?",
    "L'IA est-elle un levier pour améliorer la qualité globale ?",
  ],
  learning: [
    "Comment l'IA vous aide-t-elle à monter en compétence ?",
    "Utilisez-vous l'IA pour comprendre des patterns ou concepts ?",
    "Évitez-vous la dépendance passive (copier-coller sans comprendre) ?",
  ],
  cost_control: [
    "Suivez-vous les coûts d'usage IA (tokens, API, abonnements) ?",
    "Avez-vous des budgets ou limites par équipe/projet ?",
    "Comment optimisez-vous (choix de modèles, taille du contexte, batch) ?",
    "Comment arbitrez-vous coût vs qualité dans vos usages ?",
  ],
};

const RUBRICS: Record<string, string> = {
  tools:
    "1:Usage ponctuel — utilisation occasionnelle, sans réelle stratégie ni critères de choix;2:Outil identifié — un outil principal utilisé, choix fait de manière informelle;3:Usage raisonné — comparaison de plusieurs outils, critères explicites (coût, latence, qualité), intégration dans son workflow;4:Maîtrise personnelle — outils bien configurés (rules, skills), usage fluide et efficace;5:Expertise — maîtrise des fonctionnalités avancées (agents, customisation), optimisation continue de son setup",
  prompts:
    "1:Vague — prompts improvisés, peu de structure, résultats aléatoires;2:Simple — prompts basiques avec instructions claires mais sans systématisation;3:Structuré — format cohérent (rôle, contexte, tâche, format attendu), testés manuellement;4:Templates — sait trouver des prompts réutilisables (ex. how to Peaksys) et s'en sert;5:Prompt engineering maîtrisé — techniques avancées (chain-of-thought, few-shot), optimisation continue, validation des outputs",
  context:
    "1:Peu — contexte minimal (peu ou pas de fichiers inclus), l'IA manque de code/archi pour bien répondre;2:Partiel — quelques fichiers inclus ou ouverts, parfois pertinent, parfois manquant;3:Suffisant — fichiers pertinents inclus systématiquement, choix du modèle adapté à la tâche;4:Structuré — règles pré-chargées, stratégie de sélection, choix du modèle selon taille du contexte/coût;5:Context engineering maîtrisé — règles ciblées, inclusion pertinente, gestion de la taille du contexte, choix du modèle optimisé",
  iteration:
    "1:One-shot — une seule tentative, pas de retry si le résultat est insuffisant;2:Quelques itérations — 2-3 essais manuels si la première réponse échoue;3:Itératif — approche systématique: retry, reformulation, décomposition en sous-tâches;4:Décomposition — tâches complexes découpées en étapes, prompts en chaîne;5:IA sparring partner — dialogue continu avec l'IA pour explorer, affiner, challenger les réponses",
  evaluation:
    "1:Acceptation — acceptation des sorties sans vérification significative;2:Relecture superficielle — lecture rapide, pas de critères explicites;3:Vérif fonctionnelle — tests manuels ou automatisés, vérification du comportement;4:Regard archi — évaluation de la maintenabilité, alignement, cohérence;5:Culture critique — critères de qualité partagés, revue systématique, détection des hallucinations",
  integration:
    "1:Isolé — usage personnel, pas de partage ou discussion en équipe;2:Discussions — échanges informels sur les usages, pas de formalisation;3:Partages — démos, retours d'expérience, bonnes pratiques partagées;4:Formalisé — pratiques documentées, onboarding, standards d'usage;5:Doctrine équipe — vision partagée, roadmap IA, adoption comme pilier de la stratégie",
  usecases:
    "1:Snippets — usage limité à la génération de petits snippets ou complétion;2:Code basique — génération de fonctions, classes, scripts simples;3:Tests/refacto — génération de tests, refactoring, documentation;4:Debug/opt — aide au debug, optimisation, analyse de code;5:Discovery→review — exploration de solutions, design, revue de code, boucle complète",
  conception:
    "1:Code direct — pas de phase conception, passage direct au code;2:Conception informelle — réflexion mentale ou notes rapides, pas de formalisation;3:Conception assistée — IA pour esquisser des designs, SDD ou schémas;4:Mode plan structuré — IA utilisée pour explorer options, challenger, documenter les décisions;5:Conception maîtrisée — boucle conception→validation→implémentation, cohérence archi vérifiée",
  exploration:
    "1:Statique — usage figé, pas de recherche ni d'expérimentation;2:Occasionnel — quelques essais ponctuels, pas de démarche structurée;3:Curieux — suit des sources (web, X, communautés), teste de temps en temps;4:Actif — teste régulièrement workflows et astuces, identifie ce qui améliore contexte/pertinence;5:Explorateur — veille continue, validation systématique, adoption des pratiques qui font la différence",
  impact:
    "1:Aucun — pas d'impact visible sur la delivery;2:Marginal — gain de temps perçu mais non quantifié;3:Accélération — vélocité accrue, moins de tâches répétitives;4:Gain mesurable — métriques (temps, qualité, vélocité) documentées;5:Levier clair — IA comme levier stratégique, pilotage de l'adoption, ROI démontré",
  alignment:
    "1:Hors standards — code généré souvent non conforme, rework systématique;2:Rework lourd — modifications importantes nécessaires pour aligner;3:Cohérent — code généralement aligné, quelques ajustements;4:Aligné — prompts et garde-fous pour respecter standards et archi;5:Quasi conforme — sorties quasi conformes, validation automatisée possible",
  quality_usage:
    "1:Rarement — utilisation peu fréquente pour la qualité;2:Tests simples — génération de tests unitaires basiques;3:Tests utiles — tests pertinents, couverture, refacto assistée;4:Refacto guidée — IA pour identifier du code à améliorer, suggérer des refactorings;5:Levier qualité — IA intégrée dans la boucle qualité (review, dette technique, standards)",
  learning:
    "1:Dépendance — copier-coller sans comprendre, risque de régression;2:Apprentissage limité — utilisation pour débloquer mais compréhension superficielle;3:Compréhension — IA pour comprendre les concepts, valider sa compréhension;4:IA pour patterns — utilisation pour apprendre des patterns, architectures, bonnes pratiques;5:Accélérateur de progression — IA comme outil de montée en compétence structurée",
  cost_control:
    "1:Inconscient — pas de visibilité sur les coûts, usage sans limite;2:Aware — conscience des coûts, pas de suivi ni de budget;3:Suivi basique — métriques de consommation (tokens, API), pas d'alertes;4:Piloté — budgets par équipe/projet, alertes, arbitrage modèles/qualité;5:Optimisé — optimisation continue (contexte, batch, modèles), ROI coût documenté",
};

const TEMPLATES_DATA = [
  {
    id: "full-15",
    name: "Full - 14 dimensions",
    dimensions: [
      {
        id: "tools",
        title: "Maîtrise individuelle de l'outillage",
        rubric: RUBRICS.tools,
      },
      { id: "prompts", title: "Clarté des prompts", rubric: RUBRICS.prompts },
      {
        id: "conception",
        title: "Conception & mode plan (SDD, design)",
        rubric: RUBRICS.conception,
      },
      {
        id: "context",
        title: "Gestion du contexte",
        rubric: RUBRICS.context,
      },
      {
        id: "iteration",
        title: "Capacité d'itération",
        rubric: RUBRICS.iteration,
      },
      {
        id: "evaluation",
        title: "Évaluation critique",
        rubric: RUBRICS.evaluation,
      },
      {
        id: "usecases",
        title: "Cas d'usage couverts",
        rubric: RUBRICS.usecases,
      },
      {
        id: "exploration",
        title: "Exploration & veille (workflows, astuces, pertinence)",
        rubric: RUBRICS.exploration,
      },
      {
        id: "alignment",
        title: "Alignement archi & standards",
        rubric: RUBRICS.alignment,
      },
      {
        id: "quality_usage",
        title: "Usage pour la qualité (tests, review)",
        rubric: RUBRICS.quality_usage,
      },
      {
        id: "learning",
        title: "Montée en compétence via IA",
        rubric: RUBRICS.learning,
      },
      {
        id: "cost_control",
        title: "Maîtrise des coûts",
        rubric: RUBRICS.cost_control,
      },
      {
        id: "integration",
        title: "[Optionnel] Intégration dans les pratiques d'équipe",
        rubric: RUBRICS.integration,
      },
      {
        id: "impact",
        title: "[Optionnel] Impact sur la delivery",
        rubric: RUBRICS.impact,
      },
    ],
  },
];

async function main() {
  // Sync templates & dimensions only — ne touche pas aux évaluations, users, audit logs
  for (const t of TEMPLATES_DATA) {
    const template = await prisma.template.upsert({
      where: { id: t.id },
      create: { id: t.id, name: t.name },
      update: { name: t.name },
    });
    for (let i = 0; i < t.dimensions.length; i++) {
      const d = t.dimensions[i];
      const questions = SUGGESTED_QUESTIONS[d.id];
      await prisma.templateDimension.upsert({
        where: {
          templateId_slug: { templateId: template.id, slug: d.id },
        },
        create: {
          templateId: template.id,
          slug: d.id,
          orderIndex: i,
          title: d.title,
          rubric: d.rubric,
          suggestedQuestions: questions ? JSON.stringify(questions) : null,
        },
        update: {
          orderIndex: i,
          title: d.title,
          rubric: d.rubric,
          suggestedQuestions: questions ? JSON.stringify(questions) : null,
        },
      });
    }
    // Supprime les dimensions retirées du template
    const currentSlugs = t.dimensions.map((d) => d.id);
    await prisma.templateDimension.deleteMany({
      where: {
        templateId: template.id,
        slug: { notIn: currentSlugs },
      },
    });
  }

  // Bootstrap demo data uniquement si la DB est vide
  const evalCount = await prisma.evaluation.count();
  if (evalCount === 0) {
    const template = await prisma.template.findUnique({
      where: { id: "full-15" },
    });
    if (!template) throw new Error("Template not found");

    await prisma.user.upsert({
      where: { email: "admin@cars-front.local" },
      create: {
        email: "admin@cars-front.local",
        name: "Admin User",
        role: "admin",
      },
      update: {},
    });

    const dims = await prisma.templateDimension.findMany({
      where: { templateId: template.id },
      orderBy: { orderIndex: "asc" },
    });

    const candidates = [
      {
        name: "Alice Chen",
        role: "Senior ML Engineer",
        team: "Cars Front",
        evaluator: "Jean Dupont",
      },
      {
        name: "Bob Martin",
        role: "Data Scientist",
        team: "Cars Front",
        evaluator: "Marie Curie",
      },
      {
        name: "Carol White",
        role: "AI Product Manager",
        team: "Cars Data",
        evaluator: "Jean Dupont",
      },
    ];

    for (let i = 0; i < candidates.length; i++) {
      const c = candidates[i];
      const evaluation = await prisma.evaluation.create({
        data: {
          candidateName: c.name,
          candidateRole: c.role,
          candidateTeam: c.team,
          evaluatorName: c.evaluator,
          evaluationDate: new Date(2025, 1, 15 + i),
          templateId: template.id,
          status: i === 0 ? "submitted" : "draft",
          findings:
            i === 0
              ? "Bonne maîtrise des outils et des prompts. Axes d'amélioration : capitalisation et mesure."
              : null,
          recommendations:
            i === 0
              ? "Former sur la capitalisation des prompts et mettre en place des indicateurs."
              : null,
        },
      });
      for (const d of dims) {
        const score = 2 + Math.floor(Math.random() * 3);
        await prisma.dimensionScore.create({
          data: {
            evaluationId: evaluation.id,
            dimensionId: d.id,
            score,
            justification: `Justification pour ${d.title}`,
            examplesObserved: `Observé : ${d.title} niveau ${score}`,
            confidence: ["low", "med", "high"][Math.floor(Math.random() * 3)],
          },
        });
      }
    }
    console.log("Seed complete: templates synced, demo evaluations created");
  } else {
    console.log("Seed complete: templates synced, evaluations preserved");
  }
}

main()
  .catch((e) => {
    console.error(e);
    process.exit(1);
  })
  .finally(() => prisma.$disconnect());