#!/usr/bin/env python3
"""Validate a radio juridique script before TTS generation.

Checks for:
- Valid voice roles
- Non-empty text segments
- Required segments present
- Dialogue alternation (presentateur <-> expert)
- No hallucinated names
- No dots/symbols that would break TTS

Note: No character limits — content is transcribed in full.
"""

import sys
import re

VALID_ROLES = {"presentateur", "expert_breves", "expert_focus", "jingle"}
REQUIRED_SEGMENTS = {"intro_jingle", "intro_host", "outro"}


def validate_juridique_script(script: dict) -> tuple:
    """
    Validate a radio juridique script.

    Returns:
        (errors, warnings) — lists of strings
    """
    errors = []
    warnings = []

    # 1. Check required segments
    for seg in REQUIRED_SEGMENTS:
        if seg not in script:
            errors.append(f"Segment manquant : '{seg}'")

    # 2. Check each segment
    prev_role = None
    for name, segment in script.items():
        text = segment.get("text", "")
        role = segment.get("voice_role", "presentateur")

        # Role validation
        if role not in VALID_ROLES:
            errors.append(f"Segment '{name}' : role TTS invalide '{role}'. Validés : {sorted(VALID_ROLES)}")

        # Text non-empty
        if not text or not text.strip():
            warnings.append(f"Segment '{name}' : texte vide")

        # Dialogue alternation check
        if role == "presentateur" and prev_role == "presentateur":
            warnings.append(f"Segment '{name}' : deux presentateurs consecutifs — verifier l'alternance")
        elif role != "presentateur" and prev_role == role:
            warnings.append(f"Segment '{name}' : meme expert consecutif ({role}) — verifier l'alternance")

        prev_role = role

    # 3. Check TTS-clean text issues
    for name, segment in script.items():
        text = segment.get("text", "")
        if "." in text:
            warnings.append(f"Segment '{name}' : points detectes (seront supprimes automatiquement par clean_tts_text)")
        if "•" in text:
            warnings.append(f"Segment '{name}' : symbole '•' detecte (sera remplace par une virgule)")

    # 4. Check anti-répétition : l'expert ne doit pas répéter le titre du présentateur
    # Pour chaque paire présentateur→expert consécutive, vérifier que l'expert
    # ne commence pas par une phrase qui répète ce que le présentateur vient de dire.
    items = list(script.items())
    for i in range(len(items) - 1):
        curr_name, curr_seg = items[i]
        next_name, next_seg = items[i + 1]
        curr_role = curr_seg.get("voice_role", "")
        next_role = next_seg.get("voice_role", "")
        curr_text = curr_seg.get("text", "").strip()
        next_text = next_seg.get("text", "").strip()

        # Si présentateur suivi d'expert, vérifier anti-répétition
        if curr_role == "presentateur" and next_role in ("expert_breves", "expert_focus"):
            # Extraire les mots significatifs du présentateur (mots de > 4 chars)
            curr_words = set(w.lower() for w in re.findall(r'\b\w{5,}\b', curr_text))
            if not curr_words:
                continue
            # Vérifier les 100 premiers caractères de la réponse de l'expert
            next_start = next_text[:150].lower()
            # Compter combien de mots significatifs du présentateur apparaissent dans le début de la réponse
            matches = sum(1 for w in curr_words if w in next_start)
            ratio = matches / len(curr_words) if curr_words else 0
            if ratio > 0.5 and len(curr_words) >= 3:
                warnings.append(
                    f"Anti-repetition : '{next_name}' ({next_role}) reprend trop de mots "
                    f"de '{curr_name}' — verifier que l'expert ne repete pas le titre"
                )

    return errors, warnings


def format_report(errors: list, warnings: list) -> str:
    lines = []
    if errors:
        lines.append(f"ERREURS ({len(errors)}):")
        for e in errors:
            lines.append(f"  x {e}")
    if warnings:
        lines.append(f"\nATTENTION ({len(warnings)}):")
        for w in warnings:
            lines.append(f"  ! {w}")
    if not errors and not warnings:
        lines.append("OK — Script valide, aucune erreur ni warning.")
    return "\n".join(lines)


if __name__ == "__main__":
    # Quick test
    test_script = {
        "intro_jingle": {"voice_role": "jingle", "text": "Radio Juridique"},
        "intro_host": {"voice_role": "presentateur", "text": "Bonjour, bienvenue dans Radio Juridique"},
        "partie1_intro": {"voice_role": "presentateur", "text": "Marc, qu'est-ce qu'on retient de cette semaine ?"},
        "partie1_expert": {"voice_role": "expert_breves", "text": "Plusieurs arrets importants cette semaine."},
        "partie2_intro": {"voice_role": "presentateur", "text": "Passons au focus. Sophie, expliques-nous."},
        "partie2_expert": {"voice_role": "expert_focus", "text": "Le sujet de cette semaine concerne le preavis."},
        "outro": {"voice_role": "presentateur", "text": "Merci a tous, a bientot"},
    }

    errors, warnings = validate_juridique_script(test_script)
    print(format_report(errors, warnings))