create_forms.py

#!/usr/bin/env python3
"""
Script pour créer automatiquement les Google Forms B2C et B2B
à partir du fichier '5. Questionnaire en ligne.odt'.

Prérequis :
1. Créer un projet Google Cloud : https://console.cloud.google.com
2. Activer l'API Google Forms
3. Créer des identifiants OAuth 2.0 (type "Application de bureau")
4. Télécharger le fichier credentials.json dans ce dossier
5. pip install -r requirements.txt
6. python create_forms.py
"""

import json
import copy
import os
import sys
from pathlib import Path

from google.auth.transport.requests import Request
from google.oauth2.credentials import Credentials
from google_auth_oauthlib.flow import InstalledAppFlow
from googleapiclient.discovery import build

SCOPES = [
    "https://www.googleapis.com/auth/forms.body",
]

SCRIPT_DIR = Path(__file__).parent
CREDENTIALS_FILE = SCRIPT_DIR / "credentials.json"
TOKEN_FILE = SCRIPT_DIR / "token.json"
RESALE_SURVEY_FILE = SCRIPT_DIR / "questionnaire_revente_vetements.json"


# ─── Authentification ───────────────────────────────────────────────

def get_credentials():
    creds = None
    if TOKEN_FILE.exists():
        creds = Credentials.from_authorized_user_file(str(TOKEN_FILE), SCOPES)
    if not creds or not creds.valid:
        if creds and creds.expired and creds.refresh_token:
            creds.refresh(Request())
        else:
            if not CREDENTIALS_FILE.exists():
                print(
                    "ERREUR : credentials.json introuvable.\n"
                    "Télécharge-le depuis Google Cloud Console (OAuth 2.0 > Application de bureau)\n"
                    "et place-le dans :", SCRIPT_DIR
                )
                sys.exit(1)
            flow = InstalledAppFlow.from_client_secrets_file(
                str(CREDENTIALS_FILE), SCOPES
            )
            creds = flow.run_local_server(port=0)
        TOKEN_FILE.write_text(creds.to_json())
    return creds


# ─── Helpers pour construire les items Google Forms ─────────────────

def make_section(title, description=""):
    """Crée un saut de page (section)."""
    item = {
        "title": title,
        "description": description,
        "pageBreakItem": {},
    }
    return item


def normalize_choice_option(option):
    """Normalise une option de question à choix."""
    if isinstance(option, str):
        option_value = option
        return option_value, {"value": option_value}

    if isinstance(option, dict):
        option_value = option.get("value", "")
        payload = {
            str(key): value
            for key, value in option.items()
            if value is not None
        }
        return option_value, payload

    option_value = str(option)
    return option_value, {"value": option_value}


def normalize_choice_options(raw_options):
    """Normalise les options d'une question à choix et extrait la navigation custom."""
    choices = []
    navigation = []

    for option_index, option in enumerate(raw_options):
        option_value, payload = normalize_choice_option(option)
        sanitized_payload = dict(payload)

        route = {}
        if "goToAction" in payload:
            route["goToAction"] = payload["goToAction"]
        if "goToSectionRef" in payload:
            route["goToSectionRef"] = payload["goToSectionRef"]
            sanitized_payload.pop("goToSectionRef", None)
        if "goToSectionId" in payload:
            route["goToSectionId"] = payload["goToSectionId"]

        choices.append(sanitized_payload)
        if route:
            route["optionIndex"] = option_index
            route["optionValue"] = option_value
            navigation.append(route)

    return choices, navigation


def make_choice_question(title, options, required=True, question_type="RADIO"):
    """Choix unique (RADIO) ou cases à cocher (CHECKBOX)."""
    choices = []
    has_other = False
    for opt in options:
        option_value, option_payload = normalize_choice_option(opt)

        if option_value and option_value.lower().startswith("autre"):
            has_other = True
        else:
            choices.append(option_payload)

    question = {
        "required": required,
        "choiceQuestion": {
            "type": question_type,
            "options": choices,
        },
    }
    if has_other:
        question["choiceQuestion"]["options"].append({"isOther": True})

    return {
        "title": title,
        "questionItem": {"question": question},
    }


def make_scale_question(title, low=1, high=5, low_label="", high_label="", required=True):
    """Échelle linéaire."""
    return {
        "title": title,
        "questionItem": {
            "question": {
                "required": required,
                "scaleQuestion": {
                    "low": low,
                    "high": high,
                    "lowLabel": low_label,
                    "highLabel": high_label,
                },
            }
        },
    }


def make_text_question(title, paragraph=False, required=False):
    """Réponse courte ou longue."""
    return {
        "title": title,
        "questionItem": {
            "question": {
                "required": required,
                "textQuestion": {
                    "paragraph": paragraph,
                },
            }
        },
    }


def make_ranking_as_grid(title, row_labels, col_count=5):
    """
    Classement simulé via une grille (1 à N).
    Google Forms API n'a pas de type 'classement' natif.
    """
    columns = [{"value": str(i)} for i in range(1, col_count + 1)]
    rows = [{"title": label} for label in row_labels]

    return {
        "title": title,
        "questionGroupItem": {
            "questions": [
                {"required": True, "rowQuestion": {"title": row["title"]}}
                for row in rows
            ],
            "grid": {
                "columns": {"type": "RADIO", "options": columns},
            },
        },
    }


def build_items_from_json_definition(definition):
    """Construit les items Google Forms depuis une définition JSON."""
    items = []
    section_refs = []
    choice_navigation = []

    for section_index, section in enumerate(definition.get("sections", [])):
        section_ref = section.get("id", f"section_{section_index}")
        section_title = section.get("title", "").strip()
        section_description = section.get("description", "").strip()
        if section_title or section_description:
            section_item_index = len(items)
            items.append(make_section(section_title, section_description))
            section_refs.append({
                "reference": section_ref,
                "itemIndex": section_item_index,
            })

        for question in section.get("questions", []):
            q_type = question.get("type")
            q_title = question.get("title", "").strip()
            required = question.get("required", True)
            question_index = len(items)

            if q_type == "single_choice":
                question_options, question_navigation = normalize_choice_options(
                    question.get("options", []),
                )
                items.append(make_choice_question(
                    q_title,
                    question_options,
                    required=required,
                    question_type="RADIO",
                ))
                if question_navigation:
                    choice_navigation.append({
                        "itemIndex": question_index,
                        "questionType": "RADIO",
                        "navigation": question_navigation,
                    })
                continue

            if q_type == "multiple_choice":
                question_options, question_navigation = normalize_choice_options(
                    question.get("options", []),
                )
                items.append(make_choice_question(
                    q_title,
                    question_options,
                    required=required,
                    question_type="CHECKBOX",
                ))
                if question_navigation:
                    choice_navigation.append({
                        "itemIndex": question_index,
                        "questionType": "CHECKBOX",
                        "navigation": question_navigation,
                    })
                continue

            if q_type == "scale":
                items.append(make_scale_question(
                    q_title,
                    low=question.get("low", 1),
                    high=question.get("high", 5),
                    low_label=question.get("lowLabel", ""),
                    high_label=question.get("highLabel", ""),
                    required=required,
                ))
                continue

            if q_type == "text":
                items.append(make_text_question(
                    q_title,
                    paragraph=question.get("paragraph", False),
                    required=required,
                ))
                continue

            if q_type == "grid":
                rows = question.get("rows", [])
                columns = question.get("columns", {})
                low = columns.get("low", 1)
                high = columns.get("high", 5)
                items.append(make_ranking_as_grid(
                    q_title,
                    rows,
                    col_count=high - low + 1,
                ))
                continue

            print(f"[WARN] Type de question ignoré : {q_type}")

    return items, section_refs, choice_navigation


def load_json_survey(path):
    """Charge un questionnaire depuis un fichier JSON."""
    if not path.exists():
        return None

    with path.open("r", encoding="utf-8") as file:
        return json.load(file)


# ─── Définition du formulaire B2C ──────────────────────────────────

def build_b2c_items():
    items = []

    # --- Introduction (description du formulaire, pas un item séparé) ---

    # --- Section 1 : Ton profil ---
    items.append(make_section(
        "Section 1 : Ton profil",
    ))

    items.append(make_choice_question(
        "Q1. Quel âge as-tu ?",
        ["Moins de 18 ans", "18-24 ans", "25-34 ans", "35-44 ans", "45 ans et plus"],
    ))

    items.append(make_choice_question(
        "Q2. À quelle fréquence achètes-tu des vêtements de marque (Nike, Adidas, Lacoste, The North Face, etc.) ?",
        [
            "Plusieurs fois par mois",
            "1 fois par mois",
            "Quelques fois par an",
            "Rarement (1-2 fois par an)",
            "Jamais",
        ],
    ))

    items.append(make_choice_question(
        "Q3. Combien dépenses-tu en vêtements de marque par an (environ) ?",
        ["Moins de 100 €", "100-300 €", "300-500 €", "500-1000 €", "Plus de 1000 €"],
    ))

    # --- Section 2 : Où et comment tu achètes ---
    items.append(make_section("Section 2 : Où et comment tu achètes"))

    items.append(make_choice_question(
        "Q4. Où achètes-tu tes vêtements de marque ? (Plusieurs réponses possibles)",
        [
            "Boutiques officielles / sites officiels de la marque",
            "Grandes enseignes (JD Sports, Courir, Foot Locker...)",
            "Sites e-commerce (Amazon, Zalando...)",
            "Plateformes de seconde main (Vinted, Vestiaire Collective, Leboncoin)",
            "Revendeurs / boutiques indépendantes",
            "Réseaux sociaux (Instagram, TikTok Shop)",
            "Autre",
        ],
        question_type="CHECKBOX",
    ))

    items.append(make_choice_question(
        "Q5. Quelle part de tes achats de marque se fait en seconde main / occasion ?",
        [
            "Aucun, je n'achète que du neuf",
            "Moins de 25%",
            "Entre 25% et 50%",
            "Plus de 50%",
            "Presque tout en seconde main",
        ],
    ))

    items.append(make_choice_question(
        "Q6. Qu'est-ce qui te fait le plus hésiter avant un achat de marque en ligne ?",
        [
            "Le prix",
            "La peur que ce soit un faux / une contrefaçon",
            "Ne pas pouvoir essayer",
            "Les frais de livraison / retour",
            "La fiabilité du vendeur",
            "Autre",
        ],
    ))

    # --- Section 3 : Contrefaçon et authenticité ---
    items.append(make_section("Section 3 : Contrefaçon et authenticité"))

    items.append(make_choice_question(
        "Q7. As-tu déjà acheté un vêtement/accessoire de marque qui s'est avéré être un faux ?",
        [
            "Oui, une fois",
            "Oui, plusieurs fois",
            "Non, mais j'ai déjà eu des doutes sérieux",
            "Non, jamais",
        ],
    ))

    items.append(make_choice_question(
        "Q8. (Si oui à Q7) Combien as-tu perdu au total sur des contrefaçons ?",
        ["Moins de 30 €", "30-50 €", "50-100 €", "100-200 €", "Plus de 200 €"],
        required=False,
    ))

    items.append(make_choice_question(
        "Q9. As-tu déjà renoncé à un achat par peur que ce soit un faux ?",
        ["Oui, souvent", "Oui, une ou deux fois", "Non, jamais"],
    ))

    items.append(make_choice_question(
        "Q10. Que fais-tu pour vérifier qu'un article est authentique ? (Plusieurs réponses possibles)",
        [
            "Je regarde les photos de près (coutures, étiquettes, logo)",
            "Je vérifie les avis et la réputation du vendeur",
            "Je compare avec des photos sur le site officiel",
            "Je demande l'avis de quelqu'un (ami, groupe Facebook/Reddit)",
            "J'utilise un service d'authentification payant (CheckCheck, Legit Check...)",
            "Je ne fais rien de spécial",
            "Autre",
        ],
        question_type="CHECKBOX",
    ))

    items.append(make_scale_question(
        "Q11. Sur une échelle de 1 à 5, à quel point la contrefaçon est un problème pour toi ?",
        low=1, high=5,
        low_label="Pas du tout un problème",
        high_label="Un gros problème qui me freine",
    ))

    # --- Section 4 : Vérification d'authenticité ---
    items.append(make_section("Section 4 : Vérification d'authenticité"))

    items.append(make_choice_question(
        "Q12. Si tu pouvais vérifier l'authenticité d'un vêtement en prenant une photo avec ton téléphone, tu l'utiliserais ?",
        [
            "Oui, à chaque achat en ligne",
            "Oui, pour les achats importants (> 50 €)",
            "Peut-être, si c'est gratuit",
            "Non, je n'en ai pas besoin",
        ],
    ))

    items.append(make_choice_question(
        "Q13. Combien serais-tu prêt(e) à payer pour une vérification par article ?",
        [
            "Rien, ça doit être gratuit",
            "1-2 € par vérification",
            "3-5 € par vérification",
            "Un abonnement (~5 €/mois, vérifications illimitées)",
            "Je ne suis pas intéressé(e)",
        ],
    ))

    items.append(make_ranking_as_grid(
        "Q14. Qu'est-ce qui serait le plus important pour toi ? (Classe de 1 à 5, 1 = le plus important)",
        [
            "La fiabilité / précision du résultat",
            "La rapidité (résultat en quelques secondes)",
            "Le prix",
            "La facilité d'utilisation (juste prendre une photo)",
            "Le nombre de marques couvertes",
        ],
    ))

    # --- Section 5 : Pour finir ---
    items.append(make_section("Section 5 : Pour finir"))

    items.append(make_text_question(
        "Q15. Y a-t-il quelque chose qu'on n'a pas abordé et qui te semble important ?",
        paragraph=True, required=False,
    ))

    items.append(make_text_question(
        "Q16. Si tu veux être tenu(e) au courant, laisse ton email (optionnel)",
        paragraph=False, required=False,
    ))

    return items


# ─── Définition du formulaire B2B ──────────────────────────────────

def build_b2b_items():
    items = []

    # --- Section 1 : Votre activité ---
    items.append(make_section("Section 1 : Votre activité"))

    items.append(make_choice_question(
        "Q1. Quel est votre secteur d'activité ?",
        [
            "Marque de vêtements / accessoires",
            "E-commerce / marketplace",
            "Revendeur (boutique physique ou en ligne)",
            "Plateforme de seconde main / dépôt-vente",
            "Autre",
        ],
    ))

    items.append(make_choice_question(
        "Q2. Quelle est la taille de votre entreprise ?",
        [
            "Auto-entrepreneur / freelance",
            "TPE (1-10 salariés)",
            "PME (11-250 salariés)",
            "ETI / Grande entreprise (250+)",
        ],
    ))

    items.append(make_choice_question(
        "Q3. Quel est votre chiffre d'affaires annuel approximatif ?",
        [
            "Moins de 50 000 €",
            "50 000 - 200 000 €",
            "200 000 - 1 M €",
            "1 M - 5 M €",
            "Plus de 5 M €",
            "Je préfère ne pas répondre",
        ],
    ))

    items.append(make_choice_question(
        "Q4. Quel est votre rôle dans l'entreprise ?",
        [
            "Fondateur / dirigeant",
            "Responsable e-commerce",
            "Responsable qualité / produit",
            "Responsable juridique / PI",
            "Autre",
        ],
    ))

    # --- Section 2 : La contrefaçon dans votre activité ---
    items.append(make_section("Section 2 : La contrefaçon dans votre activité"))

    items.append(make_choice_question(
        "Q5. La contrefaçon de vos produits (ou des produits que vous vendez) est-elle un problème pour votre activité ?",
        [
            "Oui, c'est un problème majeur",
            "Oui, c'est un problème ponctuel",
            "C'est un risque mais on n'a pas encore été touché",
            "Non, ce n'est pas un sujet pour nous",
        ],
    ))

    items.append(make_choice_question(
        "Q6. À quelle fréquence êtes-vous confronté à des problèmes de contrefaçon ?",
        [
            "Quotidiennement",
            "Chaque semaine",
            "Chaque mois",
            "Quelques fois par an",
            "Rarement",
        ],
    ))

    items.append(make_choice_question(
        "Q7. Quelles conséquences concrètes la contrefaçon a-t-elle sur votre activité ? (Plusieurs réponses possibles)",
        [
            "Perte de chiffre d'affaires",
            "Plaintes / retours clients (SAV)",
            "Atteinte à l'image de marque",
            "Temps perdu en signalements / procédures",
            "Frais juridiques (avocats, procédures)",
            "Difficulté à se différencier des contrefacteurs",
            "Autre",
        ],
        question_type="CHECKBOX",
    ))

    items.append(make_choice_question(
        "Q8. Estimez-vous le coût annuel de la contrefaçon pour votre activité ?",
        [
            "Moins de 5 000 €",
            "5 000 - 20 000 €",
            "20 000 - 50 000 €",
            "Plus de 50 000 €",
            "Impossible à estimer",
        ],
    ))

    # --- Section 3 : Vos solutions actuelles ---
    items.append(make_section("Section 3 : Vos solutions actuelles"))

    items.append(make_choice_question(
        "Q9. Que faites-vous actuellement pour lutter contre la contrefaçon ? (Plusieurs réponses possibles)",
        [
            "Surveillance manuelle des plateformes (Vinted, Amazon, etc.)",
            "Signalements aux plateformes",
            "Actions juridiques (avocats, mise en demeure)",
            "Outils technologiques (QR codes, puces NFC, hologrammes)",
            "Prestataire spécialisé anti-contrefaçon",
            "Rien de spécifique",
            "Autre",
        ],
        question_type="CHECKBOX",
    ))

    items.append(make_choice_question(
        "Q10. Combien dépensez-vous par an pour lutter contre la contrefaçon ?",
        [
            "0 € (aucun budget)",
            "Moins de 2 000 €",
            "2 000 - 10 000 €",
            "10 000 - 50 000 €",
            "Plus de 50 000 €",
        ],
    ))

    items.append(make_choice_question(
        "Q11. Combien de personnes dans votre équipe consacrent du temps à ce sujet ?",
        [
            "Personne, on gère au cas par cas",
            "1 personne à temps partiel",
            "1 personne dédiée",
            "Une équipe de 2+ personnes",
        ],
    ))

    items.append(make_scale_question(
        "Q12. Êtes-vous satisfait de votre solution actuelle ?",
        low=1, high=5,
        low_label="Pas du tout satisfait",
        high_label="Très satisfait",
    ))

    # --- Section 4 : Vérification d'authenticité par IA ---
    items.append(make_section("Section 4 : Vérification d'authenticité par IA"))

    items.append(make_choice_question(
        "Q13. Une API qui vérifie l'authenticité d'un produit à partir d'une photo (IA), ça vous intéresserait ?",
        [
            "Très intéressé, c'est exactement ce qu'il nous faut",
            "Intéressé, j'aimerais en savoir plus",
            "Peut-être, il faudrait voir la fiabilité",
            "Pas intéressé",
        ],
    ))

    items.append(make_choice_question(
        "Q14. Comment intégreriez-vous ce type d'outil ? (Plusieurs réponses possibles)",
        [
            "Intégration API dans notre site / plateforme",
            "Outil en ligne (upload de photo via navigateur)",
            "Application mobile pour nos équipes",
            "Vérification automatique des annonces sur les marketplaces",
            "Autre",
        ],
        question_type="CHECKBOX",
    ))

    items.append(make_choice_question(
        "Q15. Quel budget mensuel seriez-vous prêt à consacrer à ce type de solution ?",
        [
            "Moins de 50 €/mois",
            "50-200 €/mois",
            "200-500 €/mois",
            "Plus de 500 €/mois",
            "À définir selon le ROI",
        ],
    ))

    items.append(make_ranking_as_grid(
        "Q16. Qu'est-ce qui serait le plus important pour vous ? (Classe de 1 à 5, 1 = le plus important)",
        [
            "La précision / fiabilité de la détection",
            "La rapidité de traitement",
            "La facilité d'intégration (API)",
            "Le nombre de marques couvertes",
            "Le prix",
        ],
    ))

    items.append(make_choice_question(
        "Q17. Qui dans votre entreprise déciderait de l'achat de ce type d'outil ?",
        [
            "Moi directement",
            "Mon responsable / la direction",
            "Le service IT / technique",
            "Comité de direction",
            "Je ne sais pas",
        ],
    ))

    # --- Section 5 : Pour finir ---
    items.append(make_section("Section 5 : Pour finir"))

    items.append(make_text_question(
        "Q18. Y a-t-il quelque chose qu'on n'a pas abordé et qui vous semble important ?",
        paragraph=True, required=False,
    ))

    items.append(make_choice_question(
        "Q19. Seriez-vous disponible pour un entretien de 15 minutes pour approfondir ?",
        [
            "Oui (merci de laisser votre email ci-dessous)",
            "Non merci",
        ],
    ))

    items.append(make_text_question(
        "Q20. Votre email professionnel (optionnel, pour vous tenir informé)",
        paragraph=False, required=False,
    ))

    return items


# ─── Création du formulaire via l'API ──────────────────────────────

def create_form(service, title, description, items, section_refs=None, choice_navigation=None):
    """Crée un Google Form et y ajoute toutes les questions."""

    # Étape 1 : créer le formulaire (vide)
    form = service.forms().create(body={
        "info": {
            "title": title,
            "documentTitle": title,
        }
    }).execute()

    form_id = form["formId"]
    print(f"  Formulaire créé : {form['responderUri']}")

    # Étape 2 : construire les requêtes batchUpdate
    requests = []

    # Ajouter la description via updateFormInfo
    requests.append({
        "updateFormInfo": {
            "info": {
                "title": title,
                "description": description,
            },
            "updateMask": "description",
        }
    })

    # Ajouter chaque item
    for idx, item in enumerate(items):
        requests.append({
            "createItem": {
                "item": item,
                "location": {"index": idx},
            }
        })

    # Étape 3 : envoyer le batch
    create_response = service.forms().batchUpdate(
        formId=form_id,
        body={"requests": requests},
    ).execute()

    create_replies = create_response.get("replies", [])
    if len(create_replies) > 1:
        create_item_replies = [
            reply.get("createItem", {})
            for reply in create_replies[1:]
            if isinstance(reply, dict) and "createItem" in reply
        ]
    else:
        create_item_replies = []

    item_ids = [
        reply.get("itemId")
        for reply in create_item_replies
        if isinstance(reply, dict)
    ]

    if item_ids and section_refs and choice_navigation:
        section_id_by_ref = {}
        for section_ref in section_refs:
            reference = section_ref.get("reference")
            item_index = section_ref.get("itemIndex")
            if reference is None or item_index is None:
                continue
            if 0 <= item_index < len(item_ids):
                section_id_by_ref[reference] = item_ids[item_index]

        update_requests = []

        for rule in choice_navigation:
            item_index = rule.get("itemIndex")
            if item_index is None or item_index >= len(items):
                continue

            if item_index >= len(item_ids):
                print(
                    f"[WARN] Item index hors limite ({item_index}) pour une règle de navigation"
                )
                continue

            base_item = copy.deepcopy(items[item_index])
            base_item_question = base_item.get("questionItem", {}).get("question", {})
            if "choiceQuestion" not in base_item_question:
                continue

            options = copy.deepcopy(
                base_item_question.get("choiceQuestion", {}).get("options", []),
            )
            changed = False

            for navigation in rule.get("navigation", []):
                option_index = navigation.get("optionIndex")
                if option_index is None or option_index >= len(options):
                    continue

                option = copy.deepcopy(options[option_index])
                option_changed = False

                section_ref = navigation.get("goToSectionRef")
                has_section_target = False
                if section_ref:
                    target_section_id = section_id_by_ref.get(section_ref)
                    if target_section_id:
                        option["goToSectionId"] = target_section_id
                        option.pop("goToAction", None)
                        has_section_target = True
                        option_changed = True
                    else:
                        print(
                            f"[WARN] Référence de section inconnue : {section_ref}",
                        )

                if navigation.get("goToSectionId"):
                    option["goToSectionId"] = navigation.get("goToSectionId")
                    option_changed = True

                if navigation.get("goToAction") and not (section_ref and has_section_target):
                    option["goToAction"] = navigation.get("goToAction")
                    option_changed = True

                if option_changed:
                    options[option_index] = option
                    changed = True

            if not changed:
                continue

            base_item_question["choiceQuestion"]["options"] = options
            update_requests.append({
                "updateItem": {
                    "item": {
                        "itemId": item_ids[item_index],
                        "title": base_item.get("title", ""),
                        "questionItem": {
                            "question": base_item_question,
                        },
                    },
                    "location": {"index": item_index},
                    "updateMask": "questionItem.question.choiceQuestion.options",
                }
            })

        if update_requests:
            service.forms().batchUpdate(
                formId=form_id,
                body={"requests": update_requests},
            ).execute()

    print(f"  {len(items)} items ajoutés avec succès.")
    return form


# ─── Main ───────────────────────────────────────────────────────────

def main():
    print("=== Création automatique des Google Forms ===\n")

    print("Authentification...")
    creds = get_credentials()
    service = build("forms", "v1", credentials=creds)

    # --- Formulaire B2C ---
    print("\n📋 Création du formulaire B2C...")
    b2c_form = create_form(
        service,
        title="Questionnaire B2C - Acheteurs de vêtements de marque",
        description=(
            "Salut ! Ce questionnaire anonyme prend 5 minutes. "
            "Il porte sur tes habitudes d'achat de vêtements de marque "
            "et ton expérience avec les contrefaçons. "
            "Aucune réponse n'est bonne ou mauvaise. Merci !"
        ),
        items=build_b2c_items(),
    )

    # --- Formulaire B2B ---
    print("\n📋 Création du formulaire B2B...")
    b2b_form = create_form(
        service,
        title="Questionnaire B2B - Marques, e-commerce, revendeurs",
        description=(
            "Bonjour, ce questionnaire prend 5-7 minutes. "
            "Il s'adresse aux professionnels du textile et de la mode "
            "(marques, e-commerce, revendeurs). Vos réponses sont confidentielles "
            "et serviront à une étude de marché universitaire. Merci de votre temps !"
        ),
        items=build_b2b_items(),
    )

    # --- Résumé ---
    print("\n" + "=" * 50)
    print("Terminé ! Voici les liens :\n")
    print(f"  B2C (édition)  : https://docs.google.com/forms/d/{b2c_form['formId']}/edit")
    print(f"  B2C (réponses) : {b2c_form['responderUri']}")
    print(f"  B2B (édition)  : https://docs.google.com/forms/d/{b2b_form['formId']}/edit")
    print(f"  B2B (réponses) : {b2b_form['responderUri']}")

    # Sauvegarder les IDs
    output = {
        "b2c": {
            "form_id": b2c_form["formId"],
            "edit_url": f"https://docs.google.com/forms/d/{b2c_form['formId']}/edit",
            "respond_url": b2c_form["responderUri"],
        },
        "b2b": {
            "form_id": b2b_form["formId"],
            "edit_url": f"https://docs.google.com/forms/d/{b2b_form['formId']}/edit",
            "respond_url": b2b_form["responderUri"],
        },
    }

    resale_survey = load_json_survey(RESALE_SURVEY_FILE)
    if resale_survey:
        print("\n📋 Création du formulaire vendeur/seconde main...")
        resale_items, resale_section_refs, resale_navigation = build_items_from_json_definition(resale_survey)
        resale_form = create_form(
            service,
            title=resale_survey.get("title", "Questionnaire vendeur de vêtements seconde main"),
            description=resale_survey.get("description", ""),
            items=resale_items,
            section_refs=resale_section_refs,
            choice_navigation=resale_navigation,
        )

        print(f"  Revente (édition)  : https://docs.google.com/forms/d/{resale_form['formId']}/edit")
        print(f"  Revente (réponses) : {resale_form['responderUri']}")

        output["resale_survey"] = {
            "form_id": resale_form["formId"],
            "edit_url": f"https://docs.google.com/forms/d/{resale_form['formId']}/edit",
            "respond_url": resale_form["responderUri"],
        }

    output_path = SCRIPT_DIR / "forms_urls.json"
    output_path.write_text(json.dumps(output, indent=2, ensure_ascii=False))
    print(f"\n  URLs sauvegardées dans : {output_path}")


if __name__ == "__main__":
    main()