Quiz Diagnostic V2

Réponse "Email & Newsletter" → scoring_weights:
{
  "tool:uuid-mailchimp": 5,
  "tool:uuid-brevo": 4,
  "category:communication": 2,
  "pricing:gratuit": 1
}

interface Quiz {
  id: string;
  title: string;
  description: string | null;
  slug: string;         // Pour routing (ex: /quiz/diagnostic-digital)
  is_active: boolean;
  created_at: string;
  updated_at: string;
  questions: QuizQuestion[];
}

interface QuizQuestion {
  id: string;
  quiz_id: string;
  question_text: string;
  question_type: 'single' | 'multiple' | 'scale';
  order_index: number;
  is_required: boolean;
  help_text: string | null;
  next_question_rules?: NextQuestionRule[] | null;  // V2 : branchement conditionnel
  answers: QuizAnswer[];
}

interface QuizAnswer {
  id: string;
  question_id: string;
  answer_text: string;
  answer_value: string;
  order_index: number;
  scoring_weights?: Record<string, number>;  // V2 : pondération par réponse
}

interface QuizRecommendation {
  id: string;
  quiz_id: string;
  condition_logic: Record<string, any>;  // JSONB — utilisé par l'ancien moteur V1
  recommended_pack_ids: string[];
  recommended_tool_ids: string[];
  recommendation_text: string | null;
  priority: number;
}

interface QuizResponse {
  id: string;
  quiz_id: string;
  answers: Record<string, any>;
  recommended_pack_ids: string[];
  recommended_tool_ids: string[];
  email: string | null;
  created_at: string;
}

export function calculateScores(
  userAnswers: QuizUserAnswers,
  answersData: AnswerScoringData[],
  tools: ToolForScoring[],
  maxTools: number   // Défaut : 6
): ScoredTool[]

export function determineProfile(
  answers: QuizUserAnswers,
  budgetQuestionId: string,
  maturityQuestionId: string,
  prioritiesQuestionId: string
): 'beginner' | 'transition' | 'connected'

interface QuizReport {
  profile: 'beginner' | 'transition' | 'connected';
  profileLabel: string;      // Ex: "Explorateur Digital"
  profileDescription: string;
  summary: string;           // Résumé personnalisé
  scoredTools: ScoredTool[]; // Top 6 outils avec scores
  actionPlan: ActionStep[];  // 3 étapes concrètes
  answers: QuizUserAnswers;
  quiz_id: string;
}

interface ScoredTool {
  tool: {
    id: string;
    name: string;
    description: string | null;
    pricing_tier: string;
    logo_url: string | null;
    website_url: string | null;
    category_name: string;
  };
  score: number;
  reasons: string[];  // Max 2 raisons uniques
}

interface ActionStep {
  step: number;        // 1, 2, 3
  toolName: string;
  toolId: string;
  action: string;      // Instruction concrète
  pricingInfo: string;
}

[
  { "if_answer_value": "aucun",  "go_to_question_id": "uuid-question-3" },
  { "if_answer_value": "avance", "go_to_question_id": "uuid-question-5" }
]

// Détermine la prochaine question selon les règles de branchement
function getNextQuestionIndex(
  currentQuestion: QuizQuestion,
  answer: string | string[] | undefined,
  allQuestions: QuizQuestion[]
): number | 'end'

// Calcule le chemin complet pour la barre de progression
function calculateQuestionPath(
  questions: QuizQuestion[],
  answers: QuizUserAnswers,
  startIndex: number
): string[]

https://kit.lucdidion.lu/quiz/diagnostic-digital?r=eyJxdWl6SWQiOiJ...

// Encoder les réponses dans l'URL
function encodeAnswersToUrl(quizId: string, answers: QuizUserAnswers): string {
  const data = { quizId, answers };
  return btoa(encodeURIComponent(JSON.stringify(data)));
}

// Décoder depuis l'URL
function decodeAnswersFromUrl(encoded: string): { quizId: string; answers: QuizUserAnswers } | null

const QUIZ_STORAGE_KEY = 'kitasso_quiz_progress';
const QUIZ_PROGRESS_MAX_AGE = 24 * 60 * 60 * 1000; // 24h

// Données sauvegardées
{ slug, answers, currentStep, timestamp }

src/features/quiz/
├── pages/
│   └── Quiz.tsx                  # Route wrapper (/quiz/:slug?)
├── components/
│   ├── QuizContainer.tsx         # Orchestrateur principal
│   ├── QuizStart.tsx             # Ecran d'introduction
│   ├── QuizQuestion.tsx          # Rendu de question (3 types)
│   ├── QuizProgress.tsx          # Barre de progression dynamique
│   ├── QuizResults.tsx           # Affichage des résultats
│   └── QuizResultsSkeleton.tsx   # Skeleton pendant le calcul
├── hooks/
│   ├── useQuiz.ts                # Hook principal (440 lignes)
│   └── useQuizAnalytics.ts      # Analytics (placeholder)
├── admin/                        # CRUD admin (6 composants)
│   ├── QuizList.tsx
│   ├── QuizForm.tsx
│   ├── QuizQuestionManager.tsx
│   ├── QuestionForm.tsx          # Editeur avec scoring weights
│   ├── QuizRecommendationManager.tsx
│   └── RecommendationForm.tsx
└── constants.ts

// Rendu conditionnel basé sur l'état du quiz
if (isLoading) return <QuizSkeleton />;
if (isSubmitting) return <QuizResultsSkeleton />;
if (report) return <QuizResults report={report} />;
if (isIntroScreen) return <QuizStart onStart={startQuiz} />;
return <QuizQuestion question={currentQuestion} onAnswer={answerQuestion} />;

const {
  quiz,              // Données du quiz chargé
  currentStep,       // Index de la question courante (-1 = intro)
  currentQuestion,   // Question courante ou null
  answers,           // Réponses de l'utilisateur
  isLoading,         // Chargement initial
  error,             // Message d'erreur
  report,            // QuizReport (null tant que non terminé)
  isSubmitting,      // Calcul des résultats en cours
  email,             // Email capturé
  setEmail,          // Setter pour l'email
  progress,          // 0-1, progression dynamique avec branchement
  isIntroScreen,     // true si step === -1
  isLastStep,        // true si dernière question du chemin
  shareableUrl,      // URL de partage (disponible après complétion)
  isFromSharedLink,  // true si résultats chargés depuis un lien partagé
  // Actions
  loadQuiz,          // Recharger le quiz
  answerQuestion,    // (questionId, answer) => void
  startQuiz,         // Passer de l'intro aux questions
  nextStep,          // Question suivante (avec branchement)
  prevStep,          // Question précédente (via historique)
  resetQuiz,         // Réinitialiser tout
} = useQuiz({ slug: 'diagnostic-digital' });

// Données envoyées à la fonction
interface ReportData {
  email: string;
  profileLabel: string;
  profileDescription: string;
  summary: string;
  tools: ReportTool[];
  actionPlan: ActionStep[];
  resultsUrl: string;
}

export const quizApi = {
  // Public
  getActiveQuiz(slug: string): Promise<Quiz>,
  submitResponse(data: QuizResponseInsert): Promise<void>,

  // V2 Scoring
  getRecommendationsByScoring(
    quiz: Quiz,
    answers: QuizUserAnswers,
    questionIdMap: { teamSize, budget, maturity, priorities }
  ): Promise<QuizReport>,

  // V1 Legacy
  getRecommendations(quizId: string, answers: QuizUserAnswers): Promise<QuizRecommendation[]>,

  // Admin CRUD
  createQuiz(data: QuizFormData): Promise<Quiz>,
  updateQuiz(id: string, data: Partial<QuizFormData>): Promise<Quiz>,
  deleteQuiz(id: string): Promise<void>,

  // Questions
  createQuestion(quizId: string, data: QuestionFormData): Promise<void>,
  updateQuestion(id: string, data: QuestionFormData): Promise<void>,
  deleteQuestion(id: string): Promise<void>,

  // Recommendations (V1)
  createRecommendation(quizId: string, data: RecommendationFormData): Promise<void>,
  updateRecommendation(id: string, data: RecommendationFormData): Promise<void>,
  deleteRecommendation(id: string): Promise<void>,

  // Analytics
  getQuizResponses(quizId: string): Promise<QuizResponse[]>,
  getResponseStats(quizId: string): Promise<QuizResponseStats>,
};

query GetQuizBySlug($slug: String!) {
  quizzes(where: { slug: { _eq: $slug }, is_active: { _eq: true } }) {
    id title description slug
    quiz_questions(order_by: { order_index: asc }) {
      id question_text question_type is_required help_text
      order_index next_question_rules
      quiz_answers(order_by: { order_index: asc }) {
        id answer_text answer_value scoring_weights
      }
    }
  }
}