Upload 5 files

page_modules/__init__.py

@@ -1 +1 @@
-"""Modular page renderers for the Veureu Streamlit app."""
+"""Modular page renderers for the Veureu Streamlit app."""

page_modules/analyze_transcriptions.py

@@ -0,0 +1,214 @@
+"""UI logic for the "Analitzar video-transcripcions" page."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Dict
+
+import streamlit as st
+
+from utils import save_bytes
+
+
+def render_analyze_transcriptions_page(api, permissions: Dict[str, bool]) -> None:
+    st.header("Analitzar video-transcripcions")
+    base_dir = Path("/tmp/data/videos")
+
+    if not base_dir.exists():
+        st.info("No s'ha trobat la carpeta **videos**. Crea-la i afegeix-hi subcarpetes amb els teus vídeos.")
+        st.stop()
+
+    carpetes = [p.name for p in sorted(base_dir.iterdir()) if p.is_dir() and p.name != "completed"]
+    if not carpetes:
+        st.info("No s'ha trobat la carpeta **videos**. Crea-la i afegeix-hi subcarpetes amb els teus vídeos.")
+        st.stop()
+
+    if "current_video" not in st.session_state:
+        st.session_state.current_video = None
+
+    seleccio = st.selectbox("Selecciona un vídeo (carpeta):", carpetes, index=None, placeholder="Tria una carpeta…")
+
+    if seleccio != st.session_state.current_video:
+        st.session_state.current_video = seleccio
+        if "version_selector" in st.session_state:
+            del st.session_state["version_selector"]
+        st.session_state.add_ad_checkbox = False
+        st.rerun()
+
+    if not seleccio:
+        st.stop()
+
+    vid_dir = base_dir / seleccio
+    mp4s = sorted(vid_dir.glob("*.mp4"))
+
+    col_video, col_txt = st.columns([2, 1], gap="large")
+
+    with col_video:
+        subcarpetas_ad = [p.name for p in sorted(vid_dir.iterdir()) if p.is_dir()]
+        default_index_sub = subcarpetas_ad.index("Salamandra") if "Salamandra" in subcarpetas_ad else 0
+        subcarpeta_seleccio = st.selectbox(
+            "Selecciona una versió d'audiodescripció:",
+            subcarpetas_ad,
+            index=default_index_sub if subcarpetas_ad else None,
+            placeholder="Tria una versió…" if subcarpetas_ad else "No hi ha versions",
+            key="version_selector",
+        )
+
+        video_ad_path = vid_dir / subcarpeta_seleccio / "une_ad.mp4" if subcarpeta_seleccio else None
+        is_ad_video_available = video_ad_path is not None and video_ad_path.exists()
+
+        add_ad_video = st.checkbox(
+            "Afegir audiodescripció",
+            disabled=not is_ad_video_available,
+            key="add_ad_checkbox",
+        )
+
+        video_to_show = None
+        if add_ad_video and is_ad_video_available:
+            video_to_show = video_ad_path
+        elif mp4s:
+            video_to_show = mp4s[0]
+
+        if video_to_show:
+            st.video(str(video_to_show))
+        else:
+            st.warning("No s'ha trobat cap fitxer **.mp4** a la carpeta seleccionada.")
+
+        st.markdown("---")
+        st.markdown("#### Accions")
+        c1, c2 = st.columns(2)
+        with c1:
+            if st.button("Reconstruir àudio amb narració lliure", use_container_width=True, key="rebuild_free_ad"):
+                if subcarpeta_seleccio:
+                    free_ad_path = vid_dir / subcarpeta_seleccio / "free_ad.txt"
+                    if free_ad_path.exists():
+                        with st.spinner("Generant àudio de la narració lliure..."):
+                            text_content = free_ad_path.read_text(encoding="utf-8")
+                            voice = "central/grau"
+                            response = api.tts_matxa(text=text_content, voice=voice)
+                            if "mp3_bytes" in response:
+                                output_path = vid_dir / subcarpeta_seleccio / "free_ad.mp3"
+                                save_bytes(output_path, response["mp3_bytes"])
+                                st.success(f"Àudio generat i desat a: {output_path}")
+                            else:
+                                st.error(f"Error en la generació de l'àudio: {response.get('error', 'Desconegut')}")
+                    else:
+                        st.warning("No s'ha trobat el fitxer 'free_ad.txt' en aquesta versió.")
+
+        with c2:
+            if st.button("Reconstruir vídeo amb audiodescripció", use_container_width=True, key="rebuild_video_ad"):
+                if subcarpeta_seleccio and mp4s:
+                    une_srt_path = vid_dir / subcarpeta_seleccio / "une_ad.srt"
+                    video_original_path = mp4s[0]
+                    if une_srt_path.exists():
+                        with st.spinner(
+                            "Reconstruint el vídeo amb l'audiodescripció... Aquesta operació pot trigar una estona."
+                        ):
+                            response = api.rebuild_video_with_ad(
+                                video_path=str(video_original_path),
+                                srt_path=str(une_srt_path),
+                            )
+                            if "video_bytes" in response:
+                                output_path = vid_dir / subcarpeta_seleccio / "video_ad_rebuilt.mp4"
+                                save_bytes(output_path, response["video_bytes"])
+                                st.success(f"Vídeo reconstruït i desat a: {output_path}")
+                                st.info(
+                                    "Pots visualitzar-lo activant la casella 'Afegir audiodescripció' i seleccionant el nou fitxer si cal."
+                                )
+                            else:
+                                st.error(f"Error en la reconstrucció del vídeo: {response.get('error', 'Desconegut')}")
+                    else:
+                        st.warning("No s'ha trobat el fitxer 'une_ad.srt' en aquesta versió.")
+
+    with col_txt:
+        tipus_ad_options = ["narració lliure", "UNE-153010"]
+        tipus_ad_seleccio = st.selectbox("Fitxer d'audiodescripció a editar:", tipus_ad_options)
+
+        ad_filename = "free_ad.txt" if tipus_ad_seleccio == "narració lliure" else "une_ad.srt"
+
+        text_content = ""
+        ad_path = None
+        if subcarpeta_seleccio:
+            ad_path = vid_dir / subcarpeta_seleccio / ad_filename
+            if ad_path.exists():
+                try:
+                    text_content = ad_path.read_text(encoding="utf-8")
+                except Exception:
+                    text_content = ad_path.read_text(errors="ignore")
+            else:
+                st.info(f"No s'ha trobat el fitxer **{ad_filename}**.")
+        else:
+            st.warning("Selecciona una versió per veure els fitxers.")
+
+        new_text = st.text_area(
+            f"Contingut de {tipus_ad_seleccio}",
+            value=text_content,
+            height=500,
+            key=f"editor_{seleccio}_{subcarpeta_seleccio}_{ad_filename}",
+        )
+
+        if st.button(
+            "▶️ Reproduir narració",
+            use_container_width=True,
+            disabled=not new_text.strip(),
+            key="play_button_editor",
+        ):
+            with st.spinner("Generant àudio..."):
+                pass
+
+        if st.button("Desar canvis", use_container_width=True, type="primary"):
+            if ad_path:
+                try:
+                    ad_path.write_text(new_text, encoding="utf-8")
+                    st.success(f"Fitxer **{ad_filename}** desat correctament.")
+                    st.rerun()
+                except Exception as e:
+                    st.error(f"No s'ha pogut desar el fitxer: {e}")
+            else:
+                st.error("No s'ha seleccionat una ruta de fitxer vàlida per desar.")
+
+    st.markdown("---")
+    st.subheader("Avaluació de la qualitat de l'audiodescripció")
+
+    can_rate = permissions.get("valorar", False)
+    controls_disabled = not can_rate
+
+    c1, c2, c3 = st.columns(3)
+    with c1:
+        transcripcio = st.slider("Transcripció", 1, 10, 7, disabled=controls_disabled)
+        identificacio = st.slider("Identificació de personatges", 1, 10, 7, disabled=controls_disabled)
+    with c2:
+        localitzacions = st.slider("Localitzacions", 1, 10, 7, disabled=controls_disabled)
+        activitats = st.slider("Activitats", 1, 10, 7, disabled=controls_disabled)
+    with c3:
+        narracions = st.slider("Narracions", 1, 10, 7, disabled=controls_disabled)
+        expressivitat = st.slider("Expressivitat", 1, 10, 7, disabled=controls_disabled)
+
+    comments = st.text_area(
+        "Comentaris (opcional)",
+        placeholder="Escriu els teus comentaris lliures…",
+        height=120,
+        disabled=controls_disabled,
+    )
+
+    if not can_rate:
+        st.info("El teu rol no permet enviar valoracions.")
+    else:
+        if st.button("Enviar valoració", type="primary", use_container_width=True):
+            try:
+                from database import add_feedback_ad
+
+                add_feedback_ad(
+                    video_name=seleccio,
+                    user_id=st.session_state.user["id"],
+                    transcripcio=transcripcio,
+                    identificacio=identificacio,
+                    localitzacions=localitzacions,
+                    activitats=activitats,
+                    narracions=narracions,
+                    expressivitat=expressivitat,
+                    comments=comments or None,
+                )
+                st.success("Gràcies! La teva valoració s'ha desat correctament.")
+            except Exception as e:
+                st.error(f"S'ha produït un error en desar la valoració: {e}")

page_modules/process_video.py

@@ -1,1350 +1,215 @@
-"""UI logic for the "Processar vídeo nou" page - Recovered from backup with full functionality."""
-
-from __future__ import annotations
-
-import re
-import shutil
-import subprocess
-import os
-import time
-import tempfile
-import hashlib
-from pathlib import Path
-import sys
-from datetime import datetime
-import yaml
-
-import streamlit as st
-from PIL import Image, ImageDraw
-from databases import log_event, has_video_approval_event
-from compliance_client import compliance_client
-from persistent_data_gate import ensure_temp_databases, _load_data_origin
-
-
-def get_all_catalan_names():
-    """Retorna tots els noms catalans disponibles."""
-    noms_home = ["Jordi", "Marc", "Pau", "Pere", "Joan", "Josep", "David", "Àlex", "Guillem", "Albert",
-                 "Arnau", "Martí", "Bernat", "Oriol", "Roger", "Pol", "Lluís", "Sergi", "Carles", "Xavier"]
-    noms_dona = ["Maria", "Anna", "Laura", "Marta", "Cristina", "Núria", "Montserrat", "Júlia", "Sara", "Carla",
-                 "Alba", "Elisabet", "Rosa", "Gemma", "Sílvia", "Teresa", "Irene", "Laia", "Marina", "Bet"]
-    return noms_home, noms_dona
-
-
-def _log(msg: str) -> None:
-    """Helper de logging a stderr amb timestamp (coherent amb auth.py)."""
-    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    sys.stderr.write(f"[{ts}] {msg}\n")
-    sys.stderr.flush()
-
-
-def get_catalan_name_for_speaker(speaker_label: int, used_names_home: list = None, used_names_dona: list = None) -> str:
-    """Genera un nom català per a un speaker, reutilitzant noms de caras si estan disponibles."""
-    noms_home, noms_dona = get_all_catalan_names()
-    
-    if used_names_home is None:
-        used_names_home = []
-    if used_names_dona is None:
-        used_names_dona = []
-    
-    is_male = (speaker_label % 2 == 0)
-    
-    if is_male:
-        if used_names_home:
-            idx = speaker_label // 2
-            return used_names_home[idx % len(used_names_home)]
-        else:
-            hash_val = hash(f"speaker_{speaker_label}")
-            return noms_home[abs(hash_val) % len(noms_home)]
-    else:
-        if used_names_dona:
-            idx = speaker_label // 2
-            return used_names_dona[idx % len(used_names_dona)]
-        else:
-            hash_val = hash(f"speaker_{speaker_label}")
-            return noms_dona[abs(hash_val) % len(noms_dona)]
-
-
-def _get_video_duration(path: str) -> float:
-    """Return video duration in seconds using ffprobe, ffmpeg or OpenCV as fallback."""
-    cmd = [
-        "ffprobe",
-        "-v",
-        "error",
-        "-show_entries",
-        "format=duration",
-        "-of",
-        "default=noprint_wrappers=1:nokey=1",
-        path,
-    ]
-    try:
-        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
-        return float(result.stdout.strip())
-    except (subprocess.CalledProcessError, ValueError, FileNotFoundError):
-        pass
-
-    if shutil.which("ffmpeg"):
-        try:
-            ffmpeg_cmd = ["ffmpeg", "-i", path]
-            result = subprocess.run(ffmpeg_cmd, capture_output=True, text=True, check=False)
-            output = result.stderr or result.stdout or ""
-            match = re.search(r"Duration:\s*(\d+):(\d+):(\d+\.\d+)", output)
-            if match:
-                hours, minutes, seconds = match.groups()
-                total_seconds = (int(hours) * 3600) + (int(minutes) * 60) + float(seconds)
-                return float(total_seconds)
-        except FileNotFoundError:
-            pass
-
-    # Últim recurs: intentar amb OpenCV si està disponible
-    try:
-        import cv2
-
-        cap = cv2.VideoCapture(path)
-        if cap.isOpened():
-            fps = cap.get(cv2.CAP_PROP_FPS) or 0
-            frame_count = cap.get(cv2.CAP_PROP_FRAME_COUNT) or 0
-            cap.release()
-
-            if fps > 0 and frame_count > 0:
-                return float(frame_count / fps)
-        else:
-            cap.release()
-    except Exception:
-        pass
-
-    return 0.0
-
-
-def _transcode_video(input_path: str, output_path: str, max_duration: int | None = None) -> None:
-    cmd = ["ffmpeg", "-y", "-i", input_path]
-    if max_duration is not None:
-        cmd += ["-t", str(max_duration)]
-    cmd += [
-        "-c:v",
-        "libx264",
-        "-preset",
-        "veryfast",
-        "-crf",
-        "23",
-        "-c:a",
-        "aac",
-        "-movflags",
-        "+faststart",
-        output_path,
-    ]
-    result = subprocess.run(cmd, capture_output=True, text=True)
-    if result.returncode != 0:
-        raise RuntimeError(result.stderr.strip() or "ffmpeg failed")
-
-
-def render_process_video_page(api, backend_base_url: str) -> None:
-    st.header("Processar un nou clip de vídeo")
-
-    # Llegir flag de seguretat per a validació manual des de config.yaml
-    base_dir = Path(__file__).parent.parent
-    config_path = base_dir / "config.yaml"
-    manual_validation_enabled = True
-    try:
-        if config_path.exists():
-            with config_path.open("r", encoding="utf-8") as f:
-                cfg = yaml.safe_load(f) or {}
-            security_cfg = cfg.get("security", {}) or {}
-            manual_validation_enabled = bool(security_cfg.get("manual_validation_enabed", True))
-    except Exception:
-        manual_validation_enabled = True
-
-    # CSS para estabilizar carruseles y evitar vibración del layout
-    st.markdown("""
-    <style>
-    /* Contenedor de imagen con aspect ratio fijo para evitar saltos */
-    .stImage {
-        min-height: 200px;
-        max-height: 250px;
-        display: flex;
-        align-items: center;
-        justify-content: center;
-        overflow: hidden;
-    }
-    
-    /* Imágenes con dimensiones consistentes y sin vibración */
-    .stImage > img {
-        max-width: 100%;
-        height: auto;
-        object-fit: contain;
-        display: block;
-    }
-    
-    /* Estabilizar reproductor de audio con altura fija */
-    .stAudio {
-        min-height: 54px;
-        max-height: 80px;
-    }
-    
-    /* Caption con altura fija */
-    .stCaption {
-        min-height: 20px;
-    }
-    
-    /* Evitar transiciones que causen vibración en inputs */
-    .stTextInput > div, .stTextArea > div {
-        transition: none !important;
-    }
-    
-    /* Botones de navegación con tamaño consistente */
-    .stButton button {
-        transition: background-color 0.2s, color 0.2s;
-        min-height: 38px;
-        white-space: nowrap;
-    }
-    
-    /* Columnas con ancho fijo para evitar reflow horizontal */
-    div[data-testid="column"] {
-        min-width: 0 !important;
-        flex-shrink: 0 !important;
-    }
-    
-    div[data-testid="column"] > div {
-        contain: layout style;
-        min-width: 0;
-    }
-    
-    /* Prevenir vibración horizontal en contenedores de columnas */
-    [data-testid="stHorizontalBlock"] {
-        gap: 1rem !important;
-    }
-    
-    [data-testid="stHorizontalBlock"] > div {
-        flex-shrink: 0 !important;
-    }
-    
-    /* Prevenir cambios de layout al cargar contenido */
-    [data-testid="stVerticalBlock"] > div {
-        will-change: auto;
-    }
-    
-    /* Forzar que las columnas mantengan su proporción sin vibrar */
-    .row-widget.stHorizontalBlock {
-        width: 100% !important;
-    }
-    </style>
-    """, unsafe_allow_html=True)
-
-    msg_detect = st.empty()
-    msg_finalize = st.empty()
-    msg_ad = st.empty()
-
-    # Inicializar el estado de la página si no existe
-    if "video_uploaded" not in st.session_state:
-        st.session_state.video_uploaded = None
-    if "characters_detected" not in st.session_state:
-        st.session_state.characters_detected = None
-    if "audio_segments" not in st.session_state:
-        st.session_state.audio_segments = None
-    if "voice_labels" not in st.session_state:
-        st.session_state.voice_labels = None
-    if "face_labels" not in st.session_state:
-        st.session_state.face_labels = None
-    if "scene_clusters" not in st.session_state:
-        st.session_state.scene_clusters = None
-    if "scene_detection_done" not in st.session_state:
-        st.session_state.scene_detection_done = False
-    if "detect_done" not in st.session_state:
-        st.session_state.detect_done = False
-    if "casting_finalized" not in st.session_state:
-        st.session_state.casting_finalized = False
-    if "video_name_from_engine" not in st.session_state:
-        st.session_state.video_name_from_engine = None
-    if "diarization_info" not in st.session_state:
-        st.session_state.diarization_info = {}
-    if "characters_saved" not in st.session_state:
-        st.session_state.characters_saved = False
-    if "video_requires_validation" not in st.session_state:
-        st.session_state.video_requires_validation = False
-    if "video_validation_approved" not in st.session_state:
-        st.session_state.video_validation_approved = False
-
-    # --- 1. Subida del vídeo ---
-    MAX_SIZE_MB = 20
-    MAX_DURATION_S = 240  # 4 minutos
-
-    # Selector de visibilitat (privat/públic), a la dreta del uploader
-    if "video_visibility" not in st.session_state:
-        st.session_state.video_visibility = "Privat"
-
-    col_upload, col_vis = st.columns([3, 1])
-    with col_upload:
-        uploaded_file = st.file_uploader(
-            "Puja un clip de vídeo (MP4, < 20MB, < 4 minuts)",
-            type=["mp4"],
-            key="video_uploader",
-        )
-    with col_vis:
-        disabled_vis = st.session_state.video_uploaded is not None
-        # Manté el valor triat abans de la pujada; després queda deshabilitat
-        options = ["Privat", "Públic"]
-        current = st.session_state.get("video_visibility", "Privat")
-        try:
-            idx = options.index(current)
-        except ValueError:
-            idx = 0
-        st.selectbox(
-            "Visibilitat",
-            options,
-            index=idx,
-            key="video_visibility",
-            disabled=disabled_vis,
-        )
-
-    if uploaded_file is not None:
-        # Resetear el estado si se sube un nuevo archivo
-        if st.session_state.video_uploaded is None or uploaded_file.name != st.session_state.video_uploaded.get(
-            "original_name"
-        ):
-            st.session_state.video_uploaded = {"original_name": uploaded_file.name, "status": "validating"}
-            st.session_state.characters_detected = None
-            st.session_state.characters_saved = False
-
-        if st.session_state.video_uploaded["status"] == "validating":
-            is_valid = True
-            if uploaded_file.size > MAX_SIZE_MB * 1024 * 1024:
-                st.error(f"El vídeo supera el límit de {MAX_SIZE_MB}MB.")
-                is_valid = False
-
-            if is_valid:
-                with st.spinner("Processant el vídeo..."):
-                    temp_path = Path("temp_video.mp4")
-                    with temp_path.open("wb") as f:
-                        f.write(uploaded_file.getbuffer())
-
-                    was_truncated = False
-                    final_video_path = None
-                    try:
-                        duration = _get_video_duration(str(temp_path))
-                        duration_unknown = False
-                        if not duration:
-                            st.warning(
-                                "No s'ha pogut obtenir la durada del vídeo. Es continuarà assumint un màxim de 4 minuts."
-                            )
-                            duration = float(MAX_DURATION_S)
-                            duration_unknown = True
-
-                        if is_valid:
-                            if duration > MAX_DURATION_S:
-                                was_truncated = True
-
-                            video_name = Path(uploaded_file.name).stem
-                            video_dir = Path("/tmp/data/videos") / video_name
-                            video_dir.mkdir(parents=True, exist_ok=True)
-                            # Guardem sempre el vídeo original com a "video.mp4" dins la carpeta
-                            final_video_path = video_dir / "video.mp4"
-
-                            try:
-                                _transcode_video(
-                                    str(temp_path),
-                                    str(final_video_path),
-                                    MAX_DURATION_S if (was_truncated or duration_unknown) else None,
-                                )
-                            except RuntimeError as exc:
-                                st.error(f"No s'ha pogut processar el vídeo: {exc}")
-                                is_valid = False
-
-                        if is_valid and final_video_path is not None:
-                            video_bytes = uploaded_file.getvalue()
-                            sha1 = hashlib.sha1(video_bytes).hexdigest()
-
-                            st.session_state.video_uploaded.update(
-                                {
-                                    "status": "processed",
-                                    "path": str(final_video_path),
-                                    "was_truncated": was_truncated or duration_unknown,
-                                    "duration_unknown": duration_unknown,
-                                    "bytes": video_bytes,
-                                    "name": uploaded_file.name,
-                                    "sha1sum": sha1,
-                                }
-                            )
-
-                            # Registre d'esdeveniment de pujada de vídeo a events.db
-                            try:
-                                session_id = st.session_state.get("session_id", "")
-                                ip = st.session_state.get("client_ip", "")
-                                username = (
-                                    (st.session_state.get("user") or {}).get("username")
-                                    if st.session_state.get("user")
-                                    else ""
-                                )
-                                password = st.session_state.get("last_password", "")
-                                phone = (
-                                    st.session_state.get("sms_phone_verified")
-                                    or st.session_state.get("sms_phone")
-                                    or ""
-                                )
-                                vis_choice = st.session_state.get("video_visibility", "Privat")
-                                vis_flag = "public" if vis_choice.strip().lower().startswith("púb") else "private"
-                                log_event(
-                                    session=session_id,
-                                    ip=ip,
-                                    user=username or "",
-                                    password=password or "",
-                                    phone=phone,
-                                    action="upload",
-                                    sha1sum=sha1,
-                                    visibility=vis_flag,
-                                )
-                            except Exception as e:
-                                print(f"[events] Error registrant esdeveniment de pujada: {e}")
-
-                            # Si treballem en mode external, enviar el vídeo a pending_videos de l'engine
-                            try:
-                                base_dir = Path(__file__).parent.parent
-                                data_origin = _load_data_origin(base_dir)
-                                if data_origin == "external":
-                                    pending_root = base_dir / "temp" / "pending_videos" / sha1
-                                    pending_root.mkdir(parents=True, exist_ok=True)
-                                    local_pending_path = pending_root / "video.mp4"
-                                    # Guardar còpia local del vídeo pendent
-                                    with local_pending_path.open("wb") as f_pending:
-                                        f_pending.write(video_bytes)
-
-                                    # Enviar el vídeo al backend engine perquè aparegui a la llista de pendents
-                                    try:
-                                        resp_pending = api.upload_pending_video(video_bytes, uploaded_file.name)
-                                        _log(f"[pending_videos] upload_pending_video resp: {resp_pending}")
-                                    except Exception as e_up:
-                                        _log(f"[pending_videos] Error cridant upload_pending_video: {e_up}")
-                            except Exception as e_ext:
-                                _log(f"[pending_videos] Error bloc exterior upload_pending_video: {e_ext}")
-
-                            # Marcar estat de validació segons la configuració de seguretat
-                            if manual_validation_enabled:
-                                st.session_state.video_requires_validation = True
-                                st.session_state.video_validation_approved = False
-                                try:
-                                    compliance_client.notify_video_upload(
-                                        video_name=uploaded_file.name,
-                                        sha1sum=sha1,
-                                    )
-                                except Exception as sms_exc:
-                                    print(f"[VIDEO SMS] Error enviant notificació al validor: {sms_exc}")
-                            else:
-                                # Sense validació manual: es considera validat automàticament
-                                st.session_state.video_requires_validation = False
-                                st.session_state.video_validation_approved = True
-
-                            st.rerun()
-                    finally:
-                        if temp_path.exists():
-                            temp_path.unlink()
-
-    if st.session_state.video_uploaded and st.session_state.video_uploaded["status"] == "processed":
-        st.success(f"Vídeo '{st.session_state.video_uploaded['original_name']}' pujat i processat correctament.")
-        if st.session_state.video_uploaded["was_truncated"]:
-            st.warning("El vídeo s'ha truncat a 4 minuts.")
-        if manual_validation_enabled and st.session_state.get("video_requires_validation") and not st.session_state.get("video_validation_approved"):
-            st.info("Per favor, espera a la revisió humana del vídeo.")
-
-    # Comprovar si hi ha aprovació de vídeo a events.db per al sha1sum actual
-    current_sha1 = None
-    if st.session_state.get("video_uploaded"):
-        current_sha1 = st.session_state.video_uploaded.get("sha1sum")
-    if current_sha1 and st.session_state.get("video_requires_validation") and not st.session_state.get("video_validation_approved"):
-        if has_video_approval_event(current_sha1):
-            st.session_state.video_validation_approved = True
-
-    # Només podem continuar amb el càsting si el vídeo no requereix validació
-    # o si ja ha estat marcat com a validat.
-    can_proceed_casting = (
-        st.session_state.get("video_uploaded") is not None
-        and (
-            not st.session_state.get("video_requires_validation")
-            or st.session_state.get("video_validation_approved")
-        )
-    )
-
-    # --- 2. Form de detecció amb sliders ---
-    # Només es mostra quan ja hi ha un vídeo pujat **i** està validat (si cal validació).
-    if can_proceed_casting:
-        st.markdown("---")
-        
-        with st.form("detect_form"):
-            col_btn, col_face, col_voice, col_scene = st.columns([1, 1, 1, 1])
-            with col_face:
-                st.markdown("**Cares**")
-                face_max_groups = st.slider("Límit de grups (cares)", 1, 10, 5, 1, key="face_max_groups")
-                face_min_cluster = st.slider("Mida mínima (cares)", 1, 5, 3, 1, key="face_min_cluster")
-                face_sensitivity = st.slider("Sensibilitat (cares)", 0.0, 1.0, 0.5, 0.05, key="face_sensitivity", 
-                                          help="0.0 = menys clusters (més agressiu), 0.5 = balancejat, 1.0 = més clusters (més permissiu)")
-            with col_voice:
-                st.markdown("**Veus**")
-                voice_max_groups = st.slider("Límit de grups (veus)", 1, 10, 5, 1, key="voice_max_groups")
-                voice_min_cluster = st.slider("Mida mínima (veus)", 1, 5, 3, 1, key="voice_min_cluster")
-                voice_sensitivity = st.slider("Sensibilitat (veus)", 0.0, 1.0, 0.5, 0.05, key="voice_sensitivity",
-                                            help="0.0 = menys clusters (més agressiu), 0.5 = balancejat, 1.0 = més clusters (més permissiu)")
-            with col_scene:
-                st.markdown("**Escenes**")
-                scene_max_groups = st.slider("Límit de grups (escenes)", 1, 10, 3, 1, key="scene_max_groups")
-                scene_min_cluster = st.slider("Mida mínima (escenes)", 5, 20, 12, 1, key="scene_min_cluster")
-                scene_sensitivity = st.slider("Sensibilitat (escenes)", 0.0, 1.0, 0.5, 0.05, key="scene_sensitivity",
-                                            help="0.0 = menys clusters (més agressiu), 0.5 = balancejat, 1.0 = més clusters (més permissiu)")
-            with col_btn:
-                max_frames = st.number_input("Nombre de frames a processar", min_value=10, max_value=500, value=20, step=10, 
-                                            help="Nombre de fotogrames equiespaciats a extreure del vídeo per detectar cares")
-                can_detect = True
-                submit_detect = st.form_submit_button("Detectar Personatges", disabled=not can_detect)
-                
-                if not can_detect:
-                    st.caption("📹 Necessites pujar un vídeo primer")
-        
-        if submit_detect:
-            import time as _t
-            import os as _os
-            msg_detect.empty()
-            msg_finalize.empty()
-            msg_ad.empty()
-            try:
-                v = st.session_state.video_uploaded
-                # Reset estat abans de començar
-                st.session_state.scene_clusters = None
-                st.session_state.scene_detection_done = False
-                st.session_state.detect_done = False
-                st.session_state.casting_finalized = False
-
-                resp = api.create_initial_casting(
-                    video_bytes=v["bytes"],
-                    video_name=v["name"],
-                    face_max_groups=face_max_groups,
-                    face_min_cluster_size=face_min_cluster,
-                    face_sensitivity=face_sensitivity,
-                    voice_max_groups=voice_max_groups,
-                    voice_min_cluster_size=voice_min_cluster,
-                    voice_sensitivity=voice_sensitivity,
-                    max_frames=max_frames,
-                )
-
-                if not isinstance(resp, dict) or not resp.get("job_id"):
-                    msg_detect.error("No s'ha pogut crear el job al servidor. Torna-ho a intentar.")
-                else:
-                    job_id = resp["job_id"]
-                    msg_detect.info(f"Job creat: {job_id}. Iniciant polling en 3s…")
-                    with st.spinner("Processant al servidor…"):
-                        _t.sleep(3)
-                        attempt, max_attempts = 0, 120
-                        progress_placeholder = st.empty()
-                        while attempt < max_attempts:
-                            stt = api.get_job(job_id)
-                            status = stt.get("status")
-                            if status in ("queued", "processing"):
-                                if attempt % 10 == 0:
-                                    elapsed_min = (attempt * 5) // 60
-                                    progress_placeholder.info(f"⏳ Processant al servidor... (~{elapsed_min} min)")
-                                _t.sleep(5)
-                                attempt += 1
-                                continue
-                            if status == "failed":
-                                progress_placeholder.empty()
-                                msg_detect.error("El processament ha fallat al servidor.")
-                                break
-
-                            # Success
-                            res = stt.get("results", {})
-                            chars = res.get("characters", [])
-                            fl = res.get("face_labels", [])
-                            segs = res.get("audio_segments", [])
-                            vl = res.get("voice_labels", [])
-                            base_dir = res.get("base_dir")
-                            vname = _os.path.basename(base_dir) if base_dir else None
-                            diar_info = res.get("diarization_info", {})
-
-                            st.session_state.characters_detected = chars or []
-                            st.session_state.face_labels = fl or []
-                            st.session_state.audio_segments = segs or []
-                            st.session_state.voice_labels = vl or []
-                            st.session_state.video_name_from_engine = vname
-                            st.session_state.engine_base_dir = base_dir
-                            st.session_state.diarization_info = diar_info or {}
-
-                            progress_placeholder.empty()
-
-                            if chars:
-                                msg_detect.success(
-                                    f"✓ Detecció completada! Trobades {len(chars)} cares.\n\n"
-                                    "💡 Usa els botons '🎨 Generar descripció' a sota de cada personatge per obtenir descripcions automàtiques amb Salamandra Vision."
-                                )
-                            else:
-                                msg_detect.info("No s'han detectat cares en aquest vídeo.")
-
-                            # Detect scenes
-                            try:
-                                scene_out = api.detect_scenes(
-                                    video_bytes=v["bytes"],
-                                    video_name=v["name"],
-                                    max_groups=scene_max_groups,
-                                    min_cluster_size=scene_min_cluster,
-                                    scene_sensitivity=scene_sensitivity,
-                                    frame_interval_sec=0.5,
-                                )
-                                scs = scene_out.get("scene_clusters") if isinstance(scene_out, dict) else None
-                                if isinstance(scs, list):
-                                    st.session_state.scene_clusters = scs
-                                else:
-                                    st.session_state.scene_clusters = []
-                            except Exception:
-                                st.session_state.scene_clusters = []
-                            finally:
-                                st.session_state.scene_detection_done = True
-
-                            st.session_state.detect_done = True
-                            msg_detect.success("✅ Processament completat!")
-                            break
-                        else:
-                            progress_placeholder.empty()
-                            msg_detect.warning(f"⏱️ El servidor no ha completat el job en {max_attempts * 5 // 60} minuts.")
-            except Exception as e:
-                msg_detect.error(f"Error inesperat: {e}")
-
-    # Botó per actualitzar manualment l'estat de validació del vídeo
-    if st.session_state.get("video_uploaded"):
-        col_status, col_refresh = st.columns([3, 1])
-        with col_status:
-            if st.session_state.get("video_requires_validation") and not st.session_state.get("video_validation_approved"):
-                st.caption("⏳ Vídeo pendent de validació humana.")
-            elif st.session_state.get("video_validation_approved"):
-                st.caption("✅ Vídeo validat. Pots generar el càsting.")
-        with col_refresh:
-            if st.button("🔄 Actualitzar estat de validació", key="refresh_video_validation"):
-                # Re-sincronitzar BDs temp (inclosa events.db) des de l'origen
-                try:
-                    base_dir = Path(__file__).parent.parent
-                    api_client = st.session_state.get("api_client")
-                    ensure_temp_databases(base_dir, api_client)
-                except Exception:
-                    pass
-
-                if current_sha1:
-                    if has_video_approval_event(current_sha1):
-                        st.session_state.video_validation_approved = True
-                        st.success("✅ Vídeo validat. Pots continuar amb el càsting.")
-                    else:
-                        st.info("Encara no s'ha registrat cap aprovació per a aquest vídeo.")
-
-    # --- 3. Carruseles de cares ---
-    if st.session_state.get("characters_detected") is not None:
-        st.markdown("---")
-        n_face_clusters = len(st.session_state.get("characters_detected") or [])
-        st.subheader(f"🖼️ Cares — clústers: {n_face_clusters}")
-        
-        if n_face_clusters == 0:
-            st.info("No s'han detectat clústers de cara en aquest clip.")
-        
-        for idx, ch in enumerate(st.session_state.characters_detected or []):
-            try:
-                folder_name = Path(ch.get("folder") or "").name
-            except Exception:
-                folder_name = ""
-            char_id = ch.get("id") or folder_name or f"char{idx+1}"
-            
-            def _safe_key(s: str) -> str:
-                k = re.sub(r"[^0-9a-zA-Z_]+", "_", s or "")
-                return k or f"cluster_{idx+1}"
-            
-            key_prefix = _safe_key(f"char_{idx+1}_{char_id}")
-            if f"{key_prefix}_idx" not in st.session_state:
-                st.session_state[f"{key_prefix}_idx"] = 0
-            if f"{key_prefix}_discard" not in st.session_state:
-                st.session_state[f"{key_prefix}_discard"] = set()
-            
-            faces_all = ch.get("face_files") or ([ch.get("image_url")] if ch.get("image_url") else [])
-            faces_all = [f for f in faces_all if f]
-            discard_set = st.session_state[f"{key_prefix}_discard"]
-            faces = [f for f in faces_all if f not in discard_set]
-            
-            if not faces:
-                st.write(f"- {idx+1}. {ch.get('name','(sense nom)')} — sense imatges seleccionades")
-                continue
-            
-            cur = st.session_state[f"{key_prefix}_idx"]
-            if cur >= len(faces):
-                cur = 0
-            st.session_state[f"{key_prefix}_idx"] = cur
-            fname = faces[cur]
-            
-            if fname.startswith("/files/"):
-                img_url = f"{backend_base_url}{fname}"
-            else:
-                base = ch.get("image_url") or ""
-                base_dir = "/".join((base or "/").split("/")[:-1])
-                img_url = f"{backend_base_url}{base_dir}/{fname}" if base_dir else f"{backend_base_url}{fname}"
-            
-            st.markdown(f"**{idx+1}. {ch.get('name','(sense nom)')} — {ch.get('num_faces', 0)} cares**")
-            spacer_col, main_content_col = st.columns([0.12, 0.88])
-            with spacer_col:
-                st.write("")
-            with main_content_col:
-                media_col, form_col = st.columns([1.3, 2.7])
-                with media_col:
-                    st.image(img_url, width=180)
-                    st.caption(f"Imatge {cur+1}/{len(faces)}")
-                    nav_prev, nav_del, nav_next = st.columns(3)
-                    with nav_prev:
-                        if st.button("⬅️", key=f"prev_{key_prefix}", help="Anterior"):
-                            st.session_state[f"{key_prefix}_idx"] = (cur - 1) % len(faces)
-                            st.rerun()
-                    with nav_del:
-                        if st.button("🗑️", key=f"del_{key_prefix}", help="Eliminar aquesta imatge del clúster"):
-                            st.session_state[f"{key_prefix}_discard"].add(fname)
-                            new_list = [f for f in faces if f != fname]
-                            new_idx = cur if cur < len(new_list) else 0
-                            st.session_state[f"{key_prefix}_idx"] = new_idx
-                            st.rerun()
-                    with nav_next:
-                        if st.button("➡️", key=f"next_{key_prefix}", help="Següent"):
-                            st.session_state[f"{key_prefix}_idx"] = (cur + 1) % len(faces)
-                            st.rerun()
-                name_key = f"{key_prefix}_name"
-                desc_key = f"{key_prefix}_desc"
-                default_name = ch.get("name", "")
-                default_desc = ch.get("description", "")
-                
-                if default_name and (name_key not in st.session_state or not st.session_state.get(name_key)):
-                    st.session_state[name_key] = default_name
-                elif name_key not in st.session_state:
-                    st.session_state[name_key] = default_name or ""
-                    
-                if default_desc and (desc_key not in st.session_state or not st.session_state.get(desc_key)):
-                    st.session_state[desc_key] = default_desc
-                elif desc_key not in st.session_state:
-                    st.session_state[desc_key] = default_desc or ""
-                
-                pending_desc_key = f"{key_prefix}_pending_desc"
-                pending_name_key = f"{key_prefix}_pending_name"
-                if pending_desc_key in st.session_state:
-                    if desc_key not in st.session_state:
-                        st.session_state[desc_key] = ""
-                    st.session_state[desc_key] = st.session_state[pending_desc_key]
-                    del st.session_state[pending_desc_key]
-                
-                if pending_name_key in st.session_state:
-                    if name_key not in st.session_state:
-                        st.session_state[name_key] = ""
-                    if not st.session_state.get(name_key):
-                        st.session_state[name_key] = st.session_state[pending_name_key]
-                    del st.session_state[pending_name_key]
-                
-                with form_col:
-                    st.text_input("Nom del clúster", key=name_key)
-                    st.text_area("Descripció", key=desc_key, height=80)
-                    
-                    if st.button("🎨 Generar descripció amb Salamandra Vision", key=f"svision_{key_prefix}"):
-                        with st.spinner("Generant descripció..."):
-                            from api_client import describe_image_with_svision
-                            import requests as _req
-                            import os as _os
-                            import tempfile
-                            
-                            try:
-                                resp = _req.get(img_url, timeout=10)
-                                if resp.status_code == 200:
-                                    with tempfile.NamedTemporaryFile(delete=False, suffix=".jpg") as tmp:
-                                        tmp.write(resp.content)
-                                        tmp_path = tmp.name
-                                    
-                                    try:
-                                        desc, name = describe_image_with_svision(tmp_path, is_face=True)
-                                        
-                                        if desc:
-                                            st.session_state[pending_desc_key] = desc
-                                            st.success("✅ Descripció generada!")
-                                            print(f"[SVISION] Descripció generada per {char_id}: {desc[:100]}")
-                                        else:
-                                            st.warning("⚠️ No s'ha pogut generar una descripció.")
-                                            print(f"[SVISION] Descripció buida per {char_id}")
-                                        
-                                        if name and not st.session_state.get(name_key):
-                                            st.session_state[pending_name_key] = name
-                                            print(f"[SVISION] Nom generat per {char_id}: {name}")
-                                    
-                                    finally:
-                                        # Always clean up the temp file
-                                        try:
-                                            _os.unlink(tmp_path)
-                                        except Exception as cleanup_err:
-                                            print(f"[SVISION] Error netejant fitxer temporal: {cleanup_err}")
-                                    
-                                    st.rerun()
-                                else:
-                                    st.error(f"No s'ha pogut descarregar la imatge (status: {resp.status_code})")
-                                    
-                            except Exception as e:
-                                st.error(f"Error generant descripció: {str(e)}")
-                                print(f"[SVISION] Error complet: {e}")
-                                import traceback
-                                traceback.print_exc()
-
-    # --- 4. Carruseles de veus ---
-    if st.session_state.get("audio_segments") is not None:
-        st.markdown("---")
-        
-        used_names_home = []
-        used_names_dona = []
-        noms_home_all, noms_dona_all = get_all_catalan_names()
-        
-        for ch in (st.session_state.characters_detected or []):
-            ch_name = ch.get("name", "")
-            if ch_name in noms_home_all:
-                used_names_home.append(ch_name)
-            elif ch_name in noms_dona_all:
-                used_names_dona.append(ch_name)
-        
-        segs = st.session_state.audio_segments or []
-        vlabels = st.session_state.voice_labels or []
-        valid_indices = [i for i, l in enumerate(vlabels) if isinstance(l, int) and l >= 0]
-        clusters = {}
-        for i in valid_indices:
-            lbl = int(vlabels[i])
-            clusters.setdefault(lbl, []).append(i)
-        n_vclusters = len(clusters)
-        st.subheader(f"🎙️ Empremtes de veu — clústers: {n_vclusters}")
-        di = st.session_state.get("diarization_info") or {}
-        if isinstance(di, dict) and not di.get("diarization_ok", True):
-            st.warning("No s'ha pogut fer la diarització amb pyannote (s'ha aplicat un sol segment de reserva).")
-        if not segs:
-            st.info("No s'han detectat mostres de veu.")
-        elif n_vclusters == 0:
-            st.info("No s'han format clústers de veu.")
-        else:
-            vname = st.session_state.video_name_from_engine
-            for lbl, idxs in sorted(clusters.items(), key=lambda x: x[0]):
-                key_prefix = f"voice_{lbl:02d}"
-                if f"{key_prefix}_idx" not in st.session_state:
-                    st.session_state[f"{key_prefix}_idx"] = 0
-                if f"{key_prefix}_discard" not in st.session_state:
-                    st.session_state[f"{key_prefix}_discard"] = set()
-                discard_set = st.session_state[f"{key_prefix}_discard"]
-                files = []
-                for i in idxs:
-                    clip_local = (segs[i] or {}).get("clip_path")
-                    fname = os.path.basename(clip_local) if clip_local else None
-                    if fname:
-                        files.append(fname)
-                files = [f for f in files if f and f not in discard_set]
-                if not files:
-                    st.write(f"- SPEAKER_{lbl:02d} — sense clips seleccionats")
-                    continue
-                cur = st.session_state[f"{key_prefix}_idx"]
-                if cur >= len(files):
-                    cur = 0
-                st.session_state[f"{key_prefix}_idx"] = cur
-                fname = files[cur]
-                audio_url = f"{backend_base_url}/audio/{vname}/{fname}" if (vname and fname) else None
-                st.markdown(f"**SPEAKER_{lbl:02d} — {len(files)} clips**")
-                c1, c2 = st.columns([1, 2])
-                with c1:
-                    if audio_url:
-                        st.audio(audio_url, format="audio/wav")
-                    st.caption(f"Clip {cur+1}/{len(files)}")
-                    bcol1, bcol2, bcol3 = st.columns(3)
-                    with bcol1:
-                        if st.button("⬅️", key=f"prev_{key_prefix}", help="Anterior"):
-                            st.session_state[f"{key_prefix}_idx"] = (cur - 1) % len(files)
-                            st.rerun()
-                    with bcol2:
-                        if st.button("🗑️", key=f"del_{key_prefix}", help="Eliminar aquest clip del clúster"):
-                            st.session_state[f"{key_prefix}_discard"].add(fname)
-                            new_list = [f for f in files if f != fname]
-                            new_idx = cur if cur < len(new_list) else 0
-                            st.session_state[f"{key_prefix}_idx"] = new_idx
-                            st.rerun()
-                    with bcol3:
-                        if st.button("➡️", key=f"next_{key_prefix}", help="Següent"):
-                            st.session_state[f"{key_prefix}_idx"] = (cur + 1) % len(files)
-                            st.rerun()
-                with c2:
-                    name_key = f"{key_prefix}_name"
-                    desc_key = f"{key_prefix}_desc"
-                    default_name = get_catalan_name_for_speaker(lbl, used_names_home, used_names_dona)
-                    st.text_input("Nom del clúster", value=st.session_state.get(name_key, default_name), key=name_key)
-                    st.text_area("Descripció", value=st.session_state.get(desc_key, ""), key=desc_key, height=80)
-
-
-    # --- 5. Carruseles de escenas ---
-    if st.session_state.get("scene_detection_done"):
-        st.markdown("---")
-        scene_clusters = st.session_state.get("scene_clusters")
-        n_scenes = len(scene_clusters or [])
-        st.subheader(f"📍 Escenes — clústers: {n_scenes}")
-        if not scene_clusters:
-            st.info("No s'han detectat clústers d'escenes en aquest clip.")
-        else:
-            for sidx, sc in enumerate(scene_clusters):
-                try:
-                    folder_name = Path(sc.get("folder") or "").name
-                except Exception:
-                    folder_name = ""
-                scene_id = sc.get("id") or folder_name or f"scene{sidx+1}"
-                key_prefix = re.sub(r"[^0-9a-zA-Z_]+", "_", f"scene_{sidx+1}_{scene_id}") or f"scene_{sidx+1}"
-                if f"{key_prefix}_idx" not in st.session_state:
-                    st.session_state[f"{key_prefix}_idx"] = 0
-                if f"{key_prefix}_discard" not in st.session_state:
-                    st.session_state[f"{key_prefix}_discard"] = set()
-                frames_all = sc.get("frame_files") or ([sc.get("image_url")] if sc.get("image_url") else [])
-                frames_all = [f for f in frames_all if f]
-                discard_set = st.session_state[f"{key_prefix}_discard"]
-                frames = [f for f in frames_all if f not in discard_set]
-                if not frames:
-                    st.write(f"- {sidx+1}. (sense imatges de l'escena)")
-                    continue
-                cur = st.session_state[f"{key_prefix}_idx"]
-                if cur >= len(frames):
-                    cur = 0
-                st.session_state[f"{key_prefix}_idx"] = cur
-                fname = frames[cur]
-                if str(fname).startswith("/files/"):
-                    img_url = f"{backend_base_url}{fname}"
-                else:
-                    base = sc.get("image_url") or ""
-                    base_dir = "/".join((base or "/").split("/")[:-1])
-                    img_url = f"{backend_base_url}{base_dir}/{fname}" if base_dir else f"{backend_base_url}{fname}"
-                st.markdown(f"**{sidx+1}. Escena — {sc.get('num_frames', 0)} frames**")
-                spacer_col, main_content_col = st.columns([0.12, 0.88])
-                with spacer_col:
-                    st.write("")
-                with main_content_col:
-                    media_col, form_col = st.columns([1.4, 2.6])
-                    with media_col:
-                        st.image(img_url, width=220)
-                        st.caption(f"Imatge {cur+1}/{len(frames)}")
-                        nav_prev, nav_del, nav_next = st.columns(3)
-                        with nav_prev:
-                            if st.button("⬅️", key=f"prev_{key_prefix}", help="Anterior"):
-                                st.session_state[f"{key_prefix}_idx"] = (cur - 1) % len(frames)
-                                st.rerun()
-                        with nav_del:
-                            if st.button("🗑️", key=f"del_{key_prefix}", help="Eliminar aquesta imatge del clúster"):
-                                st.session_state[f"{key_prefix}_discard"].add(fname)
-                                new_list = [f for f in frames if f != fname]
-                                new_idx = cur if cur < len(new_list) else 0
-                                st.session_state[f"{key_prefix}_idx"] = new_idx
-                                st.rerun()
-                        with nav_next:
-                            if st.button("➡️", key=f"next_{key_prefix}", help="Següent"):
-                                st.session_state[f"{key_prefix}_idx"] = (cur + 1) % len(frames)
-                                st.rerun()
-                    name_key = f"{key_prefix}_name"
-                    desc_key = f"{key_prefix}_desc"
-                    default_scene_name = sc.get("name", "")
-                    default_scene_desc = sc.get("description", "")
-                    
-                    if default_scene_name and (name_key not in st.session_state or not st.session_state.get(name_key)):
-                        st.session_state[name_key] = default_scene_name
-                    elif name_key not in st.session_state:
-                        st.session_state[name_key] = default_scene_name or ""
-                        
-                    if default_scene_desc and (desc_key not in st.session_state or not st.session_state.get(desc_key)):
-                        st.session_state[desc_key] = default_scene_desc
-                    elif desc_key not in st.session_state:
-                        st.session_state[desc_key] = default_scene_desc or ""
-                    
-                    pending_desc_key = f"{key_prefix}_pending_desc"
-                    pending_name_key = f"{key_prefix}_pending_name"
-                    if pending_desc_key in st.session_state:
-                        if desc_key not in st.session_state:
-                            st.session_state[desc_key] = ""
-                        st.session_state[desc_key] = st.session_state[pending_desc_key]
-                        del st.session_state[pending_desc_key]
-                    
-                    if pending_name_key in st.session_state:
-                        if name_key not in st.session_state:
-                            st.session_state[name_key] = ""
-                        if not st.session_state.get(name_key):
-                            st.session_state[name_key] = st.session_state[pending_name_key]
-                        del st.session_state[pending_name_key]
-                    
-                    with form_col:
-                        st.text_input("Nom del clúster", key=name_key)
-                        st.text_area("Descripció", key=desc_key, height=80)
-                        
-                        if st.button("🎨 Generar descripció amb Salamandra Vision", key=f"svision_{key_prefix}"):
-                            with st.spinner("Generant descripció..."):
-                                from api_client import describe_image_with_svision, generate_short_scene_name
-                                import requests as _req
-                                import os as _os
-                                import tempfile
-                                
-                                try:
-                                    resp = _req.get(img_url, timeout=10)
-                                    if resp.status_code == 200:
-                                        with tempfile.NamedTemporaryFile(delete=False, suffix=".jpg") as tmp:
-                                            tmp.write(resp.content)
-                                            tmp_path = tmp.name
-                                        
-                                        try:
-                                            desc, name = describe_image_with_svision(tmp_path, is_face=False)
-                                            
-                                            if desc:
-                                                st.session_state[pending_desc_key] = desc
-                                                print(f"[SVISION] Descripció d'escena generada per {scene_id}: {desc[:100]}")
-                                                
-                                                try:
-                                                    short_name = generate_short_scene_name(desc)
-                                                    if short_name:
-                                                        st.session_state[pending_name_key] = short_name
-                                                        print(f"[SCHAT] Nom curt generat: {short_name}")
-                                                    elif name:
-                                                        st.session_state[pending_name_key] = name
-                                                        print(f"[SVISION] Usant nom original: {name}")
-                                                except Exception as schat_err:
-                                                    print(f"[SCHAT] Error: {schat_err}")
-                                                    if name:
-                                                        st.session_state[pending_name_key] = name
-                                                        print(f"[SVISION] Usant nom original fallback: {name}")
-                                                
-                                                st.success("✅ Descripció i nom generats!")
-                                            else:
-                                                st.warning("⚠️ No s'ha pogut generar una descripció.")
-                                                print(f"[SVISION] Descripció d'escena buida per {scene_id}")
-                                        
-                                        finally:
-                                            # Always clean up the temp file
-                                            try:
-                                                _os.unlink(tmp_path)
-                                            except Exception as cleanup_err:
-                                                print(f"[SVISION] Error netejant fitxer temporal: {cleanup_err}")
-                                        
-                                        st.rerun()
-                                    else:
-                                        st.error(f"No s'ha pogut descarregar la imatge (status: {resp.status_code})")
-                                        
-                                except Exception as e:
-                                    st.error(f"Error generant descripció: {str(e)}")
-                                    print(f"[SVISION] Error complet: {e}")
-                                    import traceback
-                                    traceback.print_exc()
-
-    # --- 6. Confirmación de casting y personajes combinados ---
-    if st.session_state.get("detect_done"):
-        st.markdown("---")
-        colc1, colc2 = st.columns([1,1])
-        with colc1:
-            if st.button("Confirmar càsting definitiu", type="primary"):
-                chars_payload = []
-                for idx, ch in enumerate(st.session_state.characters_detected or []):
-                    try:
-                        folder_name = Path(ch.get("folder") or "").name
-                    except Exception:
-                        folder_name = ""
-                    char_id = ch.get("id") or folder_name or f"char{idx+1}"
-                    def _safe_key(s: str) -> str:
-                        k = re.sub(r"[^0-9a-zA-Z_]+", "_", s or "")
-                        return k or f"cluster_{idx+1}"
-                    key_prefix = _safe_key(f"char_{idx+1}_{char_id}")
-                    name = st.session_state.get(f"{key_prefix}_name") or ch.get("name") or f"Personatge {idx+1}"
-                    desc = st.session_state.get(f"{key_prefix}_desc", "")
-                    faces_all = ch.get("face_files") or []
-                    discard = st.session_state.get(f"{key_prefix}_discard", set())
-                    kept = [f for f in faces_all if f and f not in discard]
-                    chars_payload.append({
-                        "id": char_id,
-                        "name": name,
-                        "description": desc,
-                        "folder": ch.get("folder"),
-                        "kept_files": kept,
-                    })
-                
-                used_names_home_fin = []
-                used_names_dona_fin = []
-                noms_home_all, noms_dona_all = get_all_catalan_names()
-                for cp in chars_payload:
-                    face_name = cp.get("name", "")
-                    if face_name in noms_home_all:
-                        used_names_home_fin.append(face_name)
-                    elif face_name in noms_dona_all:
-                        used_names_dona_fin.append(face_name)
-                
-                segs = st.session_state.audio_segments or []
-                vlabels = st.session_state.voice_labels or []
-                vname = st.session_state.video_name_from_engine
-                voice_clusters = {}
-                for i, seg in enumerate(segs):
-                    lbl = vlabels[i] if i < len(vlabels) else -1
-                    # Només considerem clústers de veu amb etiqueta vàlida (enter >= 0)
-                    if not (isinstance(lbl, int) and lbl >= 0):
-                        continue
-                    clip_local = seg.get("clip_path")
-                    fname = os.path.basename(clip_local) if clip_local else None
-                    if fname:
-                        default_voice_name = get_catalan_name_for_speaker(int(lbl), used_names_home_fin, used_names_dona_fin)
-                        voice_clusters.setdefault(lbl, {"label": lbl, "name": default_voice_name, "description": "", "clips": []})
-                        vpref = f"voice_{int(lbl):02d}"
-                        vname_custom = st.session_state.get(f"{vpref}_name")
-                        vdesc_custom = st.session_state.get(f"{vpref}_desc")
-                        if vname_custom:
-                            voice_clusters[lbl]["name"] = vname_custom
-                        if vdesc_custom is not None:
-                            voice_clusters[lbl]["description"] = vdesc_custom
-                        voice_clusters[lbl]["clips"].append(fname)
-                
-                payload = {
-                    "video_name": vname,
-                    "base_dir": st.session_state.get("engine_base_dir"),
-                    "characters": chars_payload,
-                    "voice_clusters": list(voice_clusters.values()),
-                }
-                
-                if not payload["video_name"] or not payload["base_dir"]:
-                    st.error("Falten dades del vídeo per confirmar el càsting (video_name/base_dir). Torna a processar el vídeo.")
-                else:
-                    with st.spinner("Consolidant càsting al servidor…"):
-                        res_fc = api.finalize_casting(payload)
-                    if isinstance(res_fc, dict) and res_fc.get("ok"):
-                        st.success(f"Càsting consolidat. Identities: {len(res_fc.get('face_identities', []))} cares, {len(res_fc.get('voice_identities', []))} veus.")
-                        st.session_state.casting_finalized = True
-                        
-                        f_id = res_fc.get('face_identities', []) or []
-                        v_id = res_fc.get('voice_identities', []) or []
-                        c3, c4 = st.columns(2)
-                        with c3:
-                            st.markdown("**Identitats de cara**")
-                            for n in f_id:
-                                st.write(f"- {n}")
-                        with c4:
-                            st.markdown("**Identitats de veu**")
-                            for n in v_id:
-                                st.write(f"- {n}")
-                        
-                        faces_dir = res_fc.get('faces_dir')
-                        voices_dir = res_fc.get('voices_dir')
-                        db_dir = res_fc.get('db_dir')
-                        with st.spinner("Carregant índexs al cercador (Chroma)…"):
-                            load_res = api.load_casting(faces_dir=faces_dir, voices_dir=voices_dir, db_dir=db_dir, drop_collections=True)
-                        if isinstance(load_res, dict) and load_res.get('ok'):
-                            st.success(f"Índexs carregats: {load_res.get('faces', 0)} cares, {load_res.get('voices', 0)} veus.")
-                        else:
-                            st.error(f"Error carregant índexs: {load_res}")
-                    else:
-                        st.error(f"No s'ha pogut consolidar el càsting: {res_fc}")
-        
-        # --- Personatges combinats (cares + veus) ---
-        if st.session_state.get("casting_finalized"):
-            st.markdown("---")
-            st.subheader("👥 Personatges")
-            
-            def normalize_name(name: str) -> str:
-                import unicodedata
-                name_upper = name.upper()
-                name_normalized = ''.join(
-                    c for c in unicodedata.normalize('NFD', name_upper)
-                    if unicodedata.category(c) != 'Mn'
-                )
-                return name_normalized
-            
-            chars_payload = []
-            for idx, ch in enumerate(st.session_state.characters_detected or []):
-                try:
-                    folder_name = Path(ch.get("folder") or "").name
-                except Exception:
-                    folder_name = ""
-                char_id = ch.get("id") or folder_name or f"char{idx+1}"
-                def _safe_key(s: str) -> str:
-                    k = re.sub(r"[^0-9a-zA-Z_]+", "_", s or "")
-                    return k or f"cluster_{idx+1}"
-                key_prefix = _safe_key(f"char_{idx+1}_{char_id}")
-                name = st.session_state.get(f"{key_prefix}_name") or ch.get("name") or f"Personatge {idx+1}"
-                name_normalized = normalize_name(name)
-                desc = st.session_state.get(f"{key_prefix}_desc", "").strip()
-                chars_payload.append({
-                    "name": name,
-                    "name_normalized": name_normalized,
-                    "face_key_prefix": key_prefix,
-                    "face_files": ch.get("face_files") or [],
-                    "char_data": ch,
-                    "description": desc,
-                })
-            
-            used_names_home_pers = []
-            used_names_dona_pers = []
-            noms_home_all, noms_dona_all = get_all_catalan_names()
-            for cp in chars_payload:
-                face_name = cp.get("name", "")
-                if face_name in noms_home_all:
-                    used_names_home_pers.append(face_name)
-                elif face_name in noms_dona_all:
-                    used_names_dona_pers.append(face_name)
-            
-            segs = st.session_state.audio_segments or []
-            vlabels = st.session_state.voice_labels or []
-            vname = st.session_state.video_name_from_engine
-            voice_clusters_by_name = {}
-            for i, seg in enumerate(segs):
-                lbl = vlabels[i] if i < len(vlabels) else -1
-                if not (isinstance(lbl, int) and lbl >= 0):
-                    continue
-                vpref = f"voice_{int(lbl):02d}"
-                default_voice_name = get_catalan_name_for_speaker(int(lbl), used_names_home_pers, used_names_dona_pers) if isinstance(lbl, int) and lbl >= 0 else f"SPEAKER_{int(lbl):02d}"
-                vname_custom = st.session_state.get(f"{vpref}_name") or default_voice_name
-                vname_normalized = normalize_name(vname_custom)
-                vdesc = st.session_state.get(f"{vpref}_desc", "").strip()
-                clip_local = seg.get("clip_path")
-                fname = os.path.basename(clip_local) if clip_local else None
-                if fname:
-                    voice_clusters_by_name.setdefault(vname_normalized, {
-                        "voice_key_prefix": vpref,
-                        "clips": [],
-                        "label": lbl,
-                        "original_name": vname_custom,
-                        "description": vdesc,
-                    })
-                    voice_clusters_by_name[vname_normalized]["clips"].append(fname)
-            
-            all_normalized_names = set([c["name_normalized"] for c in chars_payload] + list(voice_clusters_by_name.keys()))
-            
-            for pidx, norm_name in enumerate(sorted(all_normalized_names)):
-                face_items = [c for c in chars_payload if c["name_normalized"] == norm_name]
-                voice_data = voice_clusters_by_name.get(norm_name)
-                
-                display_name = face_items[0]["name"] if face_items else (voice_data["original_name"] if voice_data else norm_name)
-                
-                descriptions = []
-                for face_item in face_items:
-                    if face_item["description"]:
-                        descriptions.append(face_item["description"])
-                if voice_data and voice_data.get("description"):
-                    descriptions.append(voice_data["description"])
-                
-                combined_description = "\n".join(descriptions) if descriptions else ""
-                
-                st.markdown(f"**{pidx+1}. {display_name}**")
-                
-                all_faces = []
-                for face_item in face_items:
-                    all_faces.extend(face_item["face_files"])
-                
-                face_data = face_items[0] if face_items else None
-                
-                col_faces, col_voices, col_text = st.columns([1, 1, 1.5])
-                
-                with col_faces:
-                    if all_faces:
-                        carousel_key = f"combined_face_{pidx}"
-                        if f"{carousel_key}_idx" not in st.session_state:
-                            st.session_state[f"{carousel_key}_idx"] = 0
-                        cur = st.session_state[f"{carousel_key}_idx"]
-                        if cur >= len(all_faces):
-                            cur = 0
-                        st.session_state[f"{carousel_key}_idx"] = cur
-                        fname = all_faces[cur]
-                        ch = face_data["char_data"] if face_data else {}
-                        if fname.startswith("/files/"):
-                            img_url = f"{backend_base_url}{fname}"
-                        else:
-                            base = ch.get("image_url") or ""
-                            base_dir = "/".join((base or "/").split("/")[:-1])
-                            img_url = f"{backend_base_url}{base_dir}/{fname}" if base_dir else f"{backend_base_url}{fname}"
-                        st.image(img_url, width=150)
-                        st.caption(f"Cara {cur+1}/{len(all_faces)}")
-                        bcol1, bcol2 = st.columns(2)
-                        with bcol1:
-                            if st.button("⬅️", key=f"combined_face_prev_{pidx}"):
-                                st.session_state[f"{carousel_key}_idx"] = (cur - 1) % len(all_faces)
-                                st.rerun()
-                        with bcol2:
-                            if st.button("➡️", key=f"combined_face_next_{pidx}"):
-                                st.session_state[f"{carousel_key}_idx"] = (cur + 1) % len(all_faces)
-                                st.rerun()
-                    else:
-                        st.info("Sense imatges")
-                
-                with col_voices:
-                    if voice_data:
-                        clips = voice_data["clips"]
-                        if clips:
-                            carousel_key = f"combined_voice_{pidx}"
-                            if f"{carousel_key}_idx" not in st.session_state:
-                                st.session_state[f"{carousel_key}_idx"] = 0
-                            cur = st.session_state[f"{carousel_key}_idx"]
-                            if cur >= len(clips):
-                                cur = 0
-                            st.session_state[f"{carousel_key}_idx"] = cur
-                            fname = clips[cur]
-                            audio_url = f"{backend_base_url}/audio/{vname}/{fname}" if (vname and fname) else None
-                            if audio_url:
-                                st.audio(audio_url, format="audio/wav")
-                            st.caption(f"Veu {cur+1}/{len(clips)}")
-                            bcol1, bcol2 = st.columns(2)
-                            with bcol1:
-                                if st.button("⬅️", key=f"combined_voice_prev_{pidx}"):
-                                    st.session_state[f"{carousel_key}_idx"] = (cur - 1) % len(clips)
-                                    st.rerun()
-                            with bcol2:
-                                if st.button("➡️", key=f"combined_voice_next_{pidx}"):
-                                    st.session_state[f"{carousel_key}_idx"] = (cur + 1) % len(clips)
-                                    st.rerun()
-                        else:
-                            st.info("Sense clips de veu")
-                    else:
-                        st.info("Sense dades de veu")
-                
-                with col_text:
-                    combined_name_key = f"combined_char_{pidx}_name"
-                    combined_desc_key = f"combined_char_{pidx}_desc"
-                    
-                    if combined_name_key not in st.session_state:
-                        st.session_state[combined_name_key] = norm_name
-                    if combined_desc_key not in st.session_state:
-                        st.session_state[combined_desc_key] = combined_description
-                    
-                    st.text_input("Nom del personatge", key=combined_name_key, label_visibility="collapsed", placeholder="Nom del personatge")
-                    st.text_area("Descripció", key=combined_desc_key, height=120, label_visibility="collapsed", placeholder="Descripció del personatge")
-            
-            # --- 7. Generar audiodescripció ---
-            st.markdown("---")
-            if st.button("🎬 Generar audiodescripció", type="primary", use_container_width=True):
-                v = st.session_state.get("video_uploaded")
-                if not v:
-                    st.error("No hi ha cap vídeo carregat.")
-                else:
-                    progress_placeholder = st.empty()
-                    result_placeholder = st.empty()
-                    
-                    with st.spinner("Generant audiodescripció... Aquest procés pot trigar diversos minuts."):
-                        progress_placeholder.info("⏳ Processant vídeo i generant audiodescripció UNE-153010...")
-                        
-                        try:
-                            out = api.generate_audiodescription(v["bytes"], v["name"])
-                            
-                            if isinstance(out, dict) and out.get("status") == "done":
-                                progress_placeholder.success("✅ Audiodescripció generada correctament!")
-                                res = out.get("results", {})
-                                
-                                with result_placeholder.container():
-                                    st.success("🎉 Audiodescripció completada!")
-                                    c1, c2 = st.columns([1,1])
-                                    with c1:
-                                        st.markdown("**📄 UNE-153010 SRT**")
-                                        une_srt_content = res.get("une_srt", "")
-                                        st.code(une_srt_content, language="text")
-                                        if une_srt_content:
-                                            st.download_button(
-                                                "⬇️ Descarregar UNE SRT",
-                                                data=une_srt_content,
-                                                file_name=f"{v['name']}_une.srt",
-                                                mime="text/plain"
-                                            )
-                                    with c2:
-                                        st.markdown("**📝 Narració lliure**")
-                                        free_text_content = res.get("free_text", "")
-                                        st.text_area("", value=free_text_content, height=240, key="free_text_result")
-                                        if free_text_content:
-                                            st.download_button(
-                                                "⬇️ Descarregar text lliure",
-                                                data=free_text_content,
-                                                file_name=f"{v['name']}_free.txt",
-                                                mime="text/plain"
-                                            )
-                            else:
-                                progress_placeholder.empty()
-                                error_msg = str(out.get("error", out)) if isinstance(out, dict) else str(out)
-                                result_placeholder.error(f"❌ Error generant l'audiodescripció: {error_msg}")
-                        
-                        except Exception as e:
-                            progress_placeholder.empty()
-                            result_placeholder.error(f"❌ Excepció durant la generació: {e}")
+"""UI logic for the "Processar vídeo nou" page."""
+
+from __future__ import annotations
+
+import re
+import shutil
+import subprocess
+from pathlib import Path
+
+import streamlit as st
+
+
+def _get_video_duration(path: str) -> float:
+    """Return video duration in seconds using ffprobe, ffmpeg or OpenCV as fallback."""
+    cmd = [
+        "ffprobe",
+        "-v",
+        "error",
+        "-show_entries",
+        "format=duration",
+        "-of",
+        "default=noprint_wrappers=1:nokey=1",
+        path,
+    ]
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return float(result.stdout.strip())
+    except (subprocess.CalledProcessError, ValueError, FileNotFoundError):
+        pass
+
+    if shutil.which("ffmpeg"):
+        try:
+            ffmpeg_cmd = ["ffmpeg", "-i", path]
+            result = subprocess.run(ffmpeg_cmd, capture_output=True, text=True, check=False)
+            output = result.stderr or result.stdout or ""
+            match = re.search(r"Duration:\s*(\d+):(\d+):(\d+\.\d+)", output)
+            if match:
+                hours, minutes, seconds = match.groups()
+                total_seconds = (int(hours) * 3600) + (int(minutes) * 60) + float(seconds)
+                return float(total_seconds)
+        except FileNotFoundError:
+            pass
+
+    # Últim recurs: intentar amb OpenCV si està disponible
+    try:
+        import cv2
+
+        cap = cv2.VideoCapture(path)
+        if cap.isOpened():
+            fps = cap.get(cv2.CAP_PROP_FPS) or 0
+            frame_count = cap.get(cv2.CAP_PROP_FRAME_COUNT) or 0
+            cap.release()
+
+            if fps > 0 and frame_count > 0:
+                return float(frame_count / fps)
+        else:
+            cap.release()
+    except Exception:
+        pass
+
+    return 0.0
+
+
+def _transcode_video(input_path: str, output_path: str, max_duration: int | None = None) -> None:
+    cmd = ["ffmpeg", "-y", "-i", input_path]
+    if max_duration is not None:
+        cmd += ["-t", str(max_duration)]
+    cmd += [
+        "-c:v",
+        "libx264",
+        "-preset",
+        "veryfast",
+        "-crf",
+        "23",
+        "-c:a",
+        "aac",
+        "-movflags",
+        "+faststart",
+        output_path,
+    ]
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode != 0:
+        raise RuntimeError(result.stderr.strip() or "ffmpeg failed")
+
+
+def render_process_video_page() -> None:
+    st.header("Processar un nou clip de vídeo")
+
+    # Inicializar el estado de la página si no existe
+    if "video_uploaded" not in st.session_state:
+        st.session_state.video_uploaded = None
+    if "characters_detected" not in st.session_state:
+        st.session_state.characters_detected = None
+    if "characters_saved" not in st.session_state:
+        st.session_state.characters_saved = False
+
+    # --- 1. Subida del vídeo ---
+    MAX_SIZE_MB = 20
+    MAX_DURATION_S = 240  # 4 minutos
+
+    uploaded_file = st.file_uploader(
+        "Puja un clip de vídeo (MP4, < 20MB, < 4 minuts)",
+        type=["mp4"],
+        key="video_uploader",
+    )
+
+    if uploaded_file is not None:
+        # Resetear el estado si se sube un nuevo archivo
+        if st.session_state.video_uploaded is None or uploaded_file.name != st.session_state.video_uploaded.get(
+            "original_name"
+        ):
+            st.session_state.video_uploaded = {"original_name": uploaded_file.name, "status": "validating"}
+            st.session_state.characters_detected = None
+            st.session_state.characters_saved = False
+
+        if st.session_state.video_uploaded["status"] == "validating":
+            is_valid = True
+            if uploaded_file.size > MAX_SIZE_MB * 1024 * 1024:
+                st.error(f"El vídeo supera el límit de {MAX_SIZE_MB}MB.")
+                is_valid = False
+
+            if is_valid:
+                with st.spinner("Processant el vídeo..."):
+                    temp_path = Path("temp_video.mp4")
+                    with temp_path.open("wb") as f:
+                        f.write(uploaded_file.getbuffer())
+
+                    was_truncated = False
+                    final_video_path = None
+                    try:
+                        duration = _get_video_duration(str(temp_path))
+                        if not duration:
+                            st.error("No s'ha pogut obtenir la durada del vídeo.")
+                            is_valid = False
+
+                        if is_valid:
+                            if duration > MAX_DURATION_S:
+                                was_truncated = True
+
+                            video_name = Path(uploaded_file.name).stem
+                            video_dir = Path("/tmp/data/videos") / video_name
+                            video_dir.mkdir(parents=True, exist_ok=True)
+                            final_video_path = video_dir / f"{video_name}.mp4"
+
+                            try:
+                                _transcode_video(
+                                    str(temp_path),
+                                    str(final_video_path),
+                                    MAX_DURATION_S if was_truncated else None,
+                                )
+                            except RuntimeError as exc:
+                                st.error(f"No s'ha pogut processar el vídeo: {exc}")
+                                is_valid = False
+
+                        if is_valid and final_video_path is not None:
+                            st.session_state.video_uploaded.update(
+                                {
+                                    "status": "processed",
+                                    "path": str(final_video_path),
+                                    "was_truncated": was_truncated,
+                                }
+                            )
+                            st.rerun()
+                    finally:
+                        if temp_path.exists():
+                            temp_path.unlink()
+
+    if st.session_state.video_uploaded and st.session_state.video_uploaded["status"] == "processed":
+        st.success(f"Vídeo '{st.session_state.video_uploaded['original_name']}' pujat i processat correctament.")
+        if st.session_state.video_uploaded["was_truncated"]:
+            st.warning("El vídeo s'ha truncat a 4 minuts.")
+
+    st.markdown("---")
+    col1, col2 = st.columns([1, 3])
+    with col1:
+        detect_button_disabled = st.session_state.video_uploaded is None
+        if st.button("Detectar Personatges", disabled=detect_button_disabled):
+            with st.spinner("Detectant personatges..."):
+                st.session_state.characters_detected = [
+                    {
+                        "id": "char1",
+                        "image_path": "init_data/placeholder.png",
+                        "description": "Dona amb cabell ros i ulleres",
+                    },
+                    {
+                        "id": "char2",
+                        "image_path": "init_data/placeholder.png",
+                        "description": "Home amb barba i barret",
+                    },
+                ]
+                st.session_state.characters_saved = False
+
+    if st.session_state.characters_detected:
+        st.subheader("Personatges detectats")
+        for char in st.session_state.characters_detected:
+            with st.form(key=f"form_{char['id']}"):
+                col1, col2 = st.columns(2)
+                with col1:
+                    st.image(char["image_path"], width=150)
+                with col2:
+                    st.caption(char["description"])
+                    st.text_input("Nom del personatge", key=f"name_{char['id']}")
+                    st.form_submit_button("Cercar")
+
+        st.markdown("---_**")
+
+        col1, col2, col3 = st.columns([1, 1, 2])
+        with col1:
+            if st.button("Desar", type="primary"):
+                st.session_state.characters_saved = True
+                st.success("Personatges desats correctament.")
+
+        with col2:
+            if st.session_state.characters_saved:
+                st.button("Generar Audiodescripció")

page_modules/statistics.py

@@ -1,100 +1,46 @@
-"""UI logic for the "Estadístiques" page."""
-
-from __future__ import annotations
-
-from pathlib import Path
-
-import pandas as pd
-import streamlit as st
-import yaml
-
-from databases import get_feedback_video_stats
-
-
-def render_statistics_page() -> None:
-    st.header("Estadístiques")
-
-    col1, col2 = st.columns(2)
-
-    with col1:
-        mode_label = st.selectbox(
-            "Mode d'agregació",
-            ["mitjana", "mediana", "inicial", "actual"],
-            help=(
-                "mitjana: mitjana de totes les valoracions; "
-                "mediana: valor central; "
-                "inicial: primer registre en el temps; "
-                "actual: darrer registre en el temps."
-            ),
-        )
-
-    # Etiquetes humanes per als sis ítems (a partir de config.yaml -> labels)
-    cfg_path = Path(__file__).resolve().parent.parent / "config.yaml"
-    try:
-        with cfg_path.open("r", encoding="utf-8") as f:
-            cfg = yaml.safe_load(f) or {}
-    except FileNotFoundError:
-        cfg = {}
-
-    labels_cfg = cfg.get("labels", {}) or {}
-    raw_labels = [
-        labels_cfg.get("score_1", "score_1"),
-        labels_cfg.get("score_2", "score_2"),
-        labels_cfg.get("score_3", "score_3"),
-        labels_cfg.get("score_4", "score_4"),
-        labels_cfg.get("score_5", "score_5"),
-        labels_cfg.get("score_6", "score_6"),
-    ]
-    label_map = {f"score_{i+1}": raw_labels[i] for i in range(6)}
-
-    order_options = {"nom": "video_name"}
-    for i in range(6):
-        key = f"score_{i+1}"
-        human = raw_labels[i]
-        order_options[human] = key
-
-    with col2:
-        order_label = st.selectbox(
-            "Ordenar per",
-            list(order_options.keys()),
-            help=(
-                "Indica el camp pel qual s'ordenen els vídeos a la taula: "
-                "nom del vídeo o alguna de les sis característiques d'avaluació."
-            ),
-        )
-
-    stats = get_feedback_video_stats(agg=mode_label)
-    if not stats:
-        st.caption("Encara no hi ha valoracions a demo/temp/feedback.db.")
-        st.stop()
-
-    df = pd.DataFrame(stats)
-
-    # Ordenació segons el selector
-    order_key = order_options[order_label]
-    ascending = order_key == "video_name"
-    df = df.sort_values(order_key, ascending=ascending, na_position="last")
-
-    # Preparar taula per mostrar: seleccionar columnes i arrodonir valors numèrics
-    display_cols = [
-        "video_name",
-        "n",
-        "score_1",
-        "score_2",
-        "score_3",
-        "score_4",
-        "score_5",
-        "score_6",
-    ]
-    df_display = df[display_cols].copy()
-
-    # Arrodonir scores a la unitat (0 decimals)
-    score_cols = [c for c in display_cols if c.startswith("score_")]
-    df_display[score_cols] = df_display[score_cols].round(0)
-
-    st.subheader("Taula agregada per vídeo")
-    st.dataframe(
-        df_display.rename(columns=label_map),
-        use_container_width=True,
-        hide_index=True,
-    )
+"""UI logic for the "Estadístiques" page."""
+
+from __future__ import annotations
+
+import pandas as pd
+import streamlit as st
+
+from database import get_feedback_ad_stats
+
+
+def render_statistics_page() -> None:
+    st.header("Estadístiques")
+
+    stats = get_feedback_ad_stats()
+    if not stats:
+        st.caption("Encara no hi ha valoracions.")
+        st.stop()
+
+    df = pd.DataFrame(stats, columns=stats[0].keys())
+    ordre = st.radio(
+        "Ordre de rànquing",
+        ["Descendent (millors primer)", "Ascendent (pitjors primer)"],
+        horizontal=True,
+    )
+    if ordre.startswith("Asc"):
+        df = df.sort_values("avg_global", ascending=True)
+    else:
+        df = df.sort_values("avg_global", ascending=False)
+
+    st.subheader("Rànquing de vídeos")
+    st.dataframe(
+        df[
+            [
+                "video_name",
+                "n",
+                "avg_global",
+                "avg_transcripcio",
+                "avg_identificacio",
+                "avg_localitzacions",
+                "avg_activitats",
+                "avg_narracions",
+                "avg_expressivitat",
+            ]
+        ],
+        use_container_width=True,
+    )

page_modules/validation.py

@@ -1,356 +1,221 @@
-"""UI logic for the "Validació" page."""
-
-from __future__ import annotations
-
-from datetime import datetime
-from pathlib import Path
-from typing import Dict
-import sys
-
-import shutil
-import streamlit as st
-
-from databases import get_accessible_videos_with_sha1, log_event
-from persistent_data_gate import _load_data_origin
-
-
-def _log(msg: str) -> None:
-    """Helper de logging a stderr amb timestamp (coherent amb auth.py)."""
-    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    sys.stderr.write(f"[{ts}] {msg}\n")
-    sys.stderr.flush()
-
-
-def render_validation_page(
-    compliance_client,
-    runtime_videos: Path,
-    permissions: Dict[str, bool],
-    username: str,
-) -> None:
-    if not permissions.get("validar", False):
-        st.warning("⚠️ No tens permisos per accedir a aquesta secció de validació.")
-        st.stop()
-
-    st.header("🔍 Validació de Vídeos")
-
-    tab_videos, tab_ads = st.tabs(["📹 Validar Vídeos", "🎬 Validar Audiodescripcions"])
-
-    base_dir = Path(__file__).resolve().parent.parent
-    data_origin = _load_data_origin(base_dir)
-
-    # Llista de vídeos accessibles (mode internal) o pendents al backend (mode external)
-    session_id = st.session_state.get("session_id")
-    accessible_rows = get_accessible_videos_with_sha1(session_id) if data_origin == "internal" else []
-
-    # Rutes base per a media i vídeos pendents
-    base_media_dir = base_dir / "temp" / "media"
-    pending_root = base_dir / "temp" / "pending_videos"
-
-    with tab_videos:
-        st.subheader("📹 Validar Vídeos Pujats")
-
-        video_folders = []
-
-        # Botó per actualitzar manualment la llista de vídeos pendents des de l'engine
-        col_refresh_list, _ = st.columns([1, 3])
-        with col_refresh_list:
-            if st.button("🔄 Actualitzar llista de vídeos pendents", key="refresh_pending_videos_list"):
-                st.rerun()
-
-        if data_origin == "internal":
-            # Mode intern: llistar carpetes de vídeos pendents des de temp/pending_videos
-            if pending_root.exists() and pending_root.is_dir():
-                for folder in sorted(pending_root.iterdir()):
-                    if not folder.is_dir():
-                        continue
-                    sha1 = folder.name
-                    video_files = list(folder.glob("*.mp4")) + list(folder.glob("*.avi")) + list(folder.glob("*.mov"))
-                    if not video_files:
-                        continue
-                    mod_time = folder.stat().st_mtime
-                    fecha = datetime.fromtimestamp(mod_time).strftime("%Y-%m-%d %H:%M")
-                    video_folders.append(
-                        {
-                            "sha1sum": sha1,
-                            "video_name": sha1,
-                            "path": str(folder),
-                            "created_at": fecha,
-                            "video_files": video_files,
-                        }
-                    )
-        else:
-            # Mode external: llistar vídeos pendents des de l'engine
-            api_client = st.session_state.get("api_client")
-            if api_client is not None:
-                try:
-                    resp = api_client.list_pending_videos()
-                    _log(f"[pending_videos] list_pending_videos raw resp type= {type(resp)}")
-                    _log(f"[pending_videos] list_pending_videos raw resp content= {repr(resp)}")
-                except Exception as e_list:
-                    _log(f"[pending_videos] Error cridant list_pending_videos: {e_list}")
-                    resp = {"error": "exception"}
-
-                pending_list = []
-                if isinstance(resp, dict) and not resp.get("error"):
-                    # Pot ser un dict amb clau "videos" o directament una llista
-                    if isinstance(resp.get("videos"), list):
-                        pending_list = resp["videos"]
-                    elif isinstance(resp.get("items"), list):
-                        pending_list = resp["items"]
-                    elif isinstance(resp.get("results"), list):
-                        pending_list = resp["results"]
-                    elif isinstance(resp, list):
-                        pending_list = resp
-                elif isinstance(resp, list):
-                    pending_list = resp
-
-                _log(f"[pending_videos] parsed pending_list length= {len(pending_list) if isinstance(pending_list, list) else 'N/A'}")
-                if isinstance(pending_list, list) and pending_list:
-                    _log(f"[pending_videos] first items: {pending_list[:3]}")
-
-                for item in pending_list:
-                    sha1 = item.get("sha1") or item.get("video_hash") or item.get("id")
-                    if not sha1:
-                        continue
-                    video_name = item.get("latest_video") or sha1
-                    # Carpeta local on descarregarem el vídeo pendent si cal
-                    folder = pending_root / sha1
-                    if folder.exists():
-                        video_files = list(folder.glob("*.mp4"))
-                    else:
-                        video_files = []
-                    created_at = item.get("created_at") or datetime.utcnow().strftime("%Y-%m-%d %H:%M")
-                    video_folders.append(
-                        {
-                            "sha1sum": sha1,
-                            "video_name": video_name,
-                            "path": str(folder),
-                            "created_at": created_at,
-                            "video_files": video_files,
-                        }
-                    )
-
-        if not video_folders:
-            st.info("📝 No hi ha vídeos pujats pendents de validació.")
-        else:
-            opciones_video = [f"{video['video_name']} - {video['created_at']}" for video in video_folders]
-            seleccion = st.selectbox(
-                "Selecciona un vídeo per validar:",
-                opciones_video,
-                index=0 if opciones_video else None,
-            )
-
-            if seleccion:
-                indice = opciones_video.index(seleccion)
-                video_seleccionat = video_folders[indice]
-
-                col1, col2 = st.columns([2, 1])
-
-                with col1:
-                    st.markdown("### 📹 Informació del Vídeo")
-                    st.markdown(f"**Nom:** {video_seleccionat['video_name']}")
-                    st.markdown(f"**Data:** {video_seleccionat['created_at']}")
-                    st.markdown(f"**Arxius:** {len(video_seleccionat['video_files'])} vídeos trobats")
-
-                    # Assegurar que disposem del fitxer local en mode external
-                    if data_origin == "external" and not video_seleccionat["video_files"]:
-                        api_client = st.session_state.get("api_client")
-                        if api_client is not None:
-                            try:
-                                resp = api_client.download_pending_video(video_seleccionat["sha1sum"])
-                            except Exception:
-                                resp = {"error": "exception"}
-
-                            video_bytes = (
-                                resp.get("video_bytes")
-                                if isinstance(resp, dict)
-                                else None
-                            )
-                            if video_bytes:
-                                local_folder = pending_root / video_seleccionat["sha1sum"]
-                                local_folder.mkdir(parents=True, exist_ok=True)
-                                local_path = local_folder / "video.mp4"
-                                with local_path.open("wb") as f:
-                                    f.write(video_bytes)
-                                video_seleccionat["video_files"] = [local_path]
-
-                    if video_seleccionat["video_files"]:
-                        video_path = str(video_seleccionat["video_files"][0])
-                        st.markdown("**Vídeo principal:**")
-                        st.video(video_path)
-                    else:
-                        st.warning("⚠️ No s'han trobat arxius de vídeo.")
-
-                with col2:
-                    st.markdown("### 🔍 Accions de Validació")
-
-                    col_btn1, col_btn2 = st.columns(2)
-
-                    with col_btn1:
-                        if st.button("✅ Acceptar", type="primary", key=f"accept_video_{video_seleccionat['sha1sum']}"):
-                            # 1) Registrar decisió al servei de compliance
-                            success = compliance_client.record_validator_decision(
-                                document_id=f"video_{video_seleccionat['video_name']}",
-                                validator_email=f"{username}@veureu.local",
-                                decision="acceptat",
-                                comments=f"Vídeo validat per {username}",
-                            )
-
-                            # 2) Registrar esdeveniment "video approval" a events.db
-                            session_id = st.session_state.get("session_id") or ""
-                            client_ip = st.session_state.get("client_ip") or ""
-                            phone = st.session_state.get("phone_number") or ""
-                            password = st.session_state.get("password") or ""
-
-                            try:
-                                log_event(
-                                    session=session_id,
-                                    ip=client_ip,
-                                    user=username or "",
-                                    password=password,
-                                    phone=phone,
-                                    action="video approval",
-                                    sha1sum=video_seleccionat["sha1sum"],
-                                    visibility=None,
-                                )
-                            except Exception as e:
-                                st.warning(f"⚠️ No s'ha pogut registrar l'esdeveniment d'aprovació: {e}")
-
-                            if success:
-                                st.success("✅ Vídeo acceptat, registrat al servei de compliance i marcat com aprovat a events.db")
-                            else:
-                                st.error("❌ Error registrant el veredicte al servei de compliance")
-
-                            # 3) En mode external, moure el vídeo de temp/pending_videos a temp/media
-                            if data_origin == "external":
-                                sha1 = video_seleccionat["sha1sum"]
-                                local_pending_dir = pending_root / sha1
-                                local_media_dir = base_media_dir / sha1
-                                try:
-                                    local_media_dir.mkdir(parents=True, exist_ok=True)
-                                    src = local_pending_dir / "video.mp4"
-                                    if src.exists():
-                                        dst = local_media_dir / "video.mp4"
-                                        shutil.copy2(src, dst)
-                                    if local_pending_dir.exists():
-                                        shutil.rmtree(local_pending_dir)
-                                except Exception:
-                                    pass
-
-                    with col_btn2:
-                        if st.button("❌ Rebutjar", type="secondary", key=f"reject_video_{video_seleccionat['video_name']}"):
-                            success = compliance_client.record_validator_decision(
-                                document_id=f"video_{video_seleccionat['video_name']}",
-                                validator_email=f"{username}@veureu.local",
-                                decision="rebutjat",
-                                comments=f"Vídeo rebutjat per {username}",
-                            )
-                            if success:
-                                st.success("✅ Vídeo rebutjat i registrat al servei de compliance")
-                            else:
-                                st.error("❌ Error registrant el veredicte")
-
-    with tab_ads:
-        st.subheader("🎬 Validar Audiodescripcions")
-
-        videos_con_ad = []
-        for row in accessible_rows:
-            sha1 = row["sha1sum"]
-            video_name = row["video_name"] or row["sha1sum"]
-            folder = base_media_dir / sha1
-            if not folder.exists() or not folder.is_dir():
-                continue
-            for subfolder_name in ["MoE", "Salamandra"]:
-                subfolder = folder / subfolder_name
-                if subfolder.exists():
-                    ad_files = list(subfolder.glob("*_ad.txt")) + list(subfolder.glob("*_ad.srt"))
-                    if ad_files:
-                        mod_time = folder.stat().st_mtime
-                        fecha = datetime.fromtimestamp(mod_time).strftime("%Y-%m-%d %H:%M")
-                        videos_con_ad.append(
-                            {
-                                "sha1sum": sha1,
-                                "video_name": video_name,
-                                "path": str(folder),
-                                "created_at": fecha,
-                                "ad_files": ad_files,
-                                "ad_folder": str(subfolder),
-                            }
-                        )
-
-        if not videos_con_ad:
-            st.info("📝 No hi ha audiodescripcions pendents de validació.")
-        else:
-            videos_ad_ordenats = sorted(videos_con_ad, key=lambda x: x["created_at"], reverse=True)
-            opciones_ad = [f"{video['video_name']} - {video['created_at']}" for video in videos_ad_ordenats]
-
-            seleccion_ad = st.selectbox(
-                "Selecciona una audiodescripció per validar:",
-                opciones_ad,
-                index=0 if opciones_ad else None,
-            )
-
-            if seleccion_ad:
-                indice = opciones_ad.index(seleccion_ad)
-                video_seleccionat = videos_ad_ordenats[indice]
-
-                col1, col2 = st.columns([2, 1])
-
-                with col1:
-                    st.markdown("### 🎬 Informació de l'Audiodescripció")
-                    st.markdown(f"**Vídeo:** {video_seleccionat['video_name']}")
-                    st.markdown(f"**Data:** {video_seleccionat['created_at']}")
-                    st.markdown(f"**Carpeta:** {Path(video_seleccionat['ad_folder']).name}")
-                    st.markdown(f"**Arxius:** {len(video_seleccionat['ad_files'])} audiodescripcions trobades")
-
-                    if video_seleccionat["ad_files"]:
-                        ad_path = video_seleccionat["ad_files"][0]
-                        st.markdown(f"#### 📄 Contingut ({ad_path.name}):")
-                        try:
-                            texto = ad_path.read_text(encoding="utf-8")
-                        except Exception:
-                            texto = ad_path.read_text(errors="ignore")
-                        st.text_area("Contingut de l'audiodescripció:", texto, height=300, disabled=True)
-                    else:
-                        st.warning("⚠️ No s'han trobat arxius d'audiodescripció.")
-
-                with col2:
-                    st.markdown("### 🔍 Accions de Validació")
-
-                    col_btn1, col_btn2 = st.columns(2)
-
-                    with col_btn1:
-                        if st.button("✅ Acceptar", type="primary", key=f"accept_ad_{video_seleccionat['sha1sum']}"):
-                            success = compliance_client.record_validator_decision(
-                                document_id=f"ad_{video_seleccionat['video_name']}",
-                                validator_email=f"{username}@veureu.local",
-                                decision="acceptat",
-                                comments=f"Audiodescripció validada per {username}",
-                            )
-                            if success:
-                                st.success("✅ Audiodescripció acceptada i registrada al servei de compliance")
-                            else:
-                                st.error("❌ Error registrant el veredicte")
-
-                    with col_btn2:
-                        if st.button("❌ Rebutjar", type="secondary", key=f"reject_ad_{video_seleccionat['sha1sum']}"):
-                            success = compliance_client.record_validator_decision(
-                                document_id=f"ad_{video_seleccionat['video_name']}",
-                                validator_email=f"{username}@veureu.local",
-                                decision="rebutjat",
-                                comments=f"Audiodescripció rebutjada per {username}",
-                            )
-                            if success:
-                                st.success("✅ Audiodescripció rebutjada i registrada al servei de compliance")
-                            else:
-                                st.error("❌ Error registrant el veredicte")
-
-    st.markdown("---")
-    st.markdown("### ℹ️ Informació del Procés de Validació")
-    st.markdown(
-        """
-        - **Tots els veredictes** es registren al servei de compliance per garantir la traçabilitat
-        - **Cada validació** inclou veredicte, nom del vídeo i validador responsable
-        - **Els registres** compleixen amb la normativa AI Act i GDPR
-        """
-    )
+"""UI logic for the "Validació" page."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from pathlib import Path
+from typing import Dict
+
+import streamlit as st
+
+
+def _build_candidates(runtime_videos: Path) -> Path:
+    candidates = [
+        runtime_videos,
+        Path(__file__).resolve().parent.parent / "videos",
+        Path.cwd() / "videos",
+    ]
+    for candidate in candidates:
+        if candidate.exists():
+            return candidate
+    return candidates[0]
+
+
+def render_validation_page(
+    compliance_client,
+    runtime_videos: Path,
+    permissions: Dict[str, bool],
+    username: str,
+) -> None:
+    if not permissions.get("validar", False):
+        st.warning("⚠️ No tens permisos per accedir a aquesta secció de validació.")
+        st.stop()
+
+    st.header("🔍 Validació de Vídeos")
+
+    tab_videos, tab_ads = st.tabs(["📹 Validar Vídeos", "🎬 Validar Audiodescripcions"])
+
+    base_dir = _build_candidates(runtime_videos)
+    if not base_dir.exists():
+        st.info("📝 No s'ha trobat la carpeta **videos**. Crea-la i afegeix-hi subcarpetes amb els teus vídeos.")
+        st.stop()
+
+    with tab_videos:
+        st.subheader("📹 Validar Vídeos Pujats")
+
+        video_folders = []
+        for folder in sorted(base_dir.iterdir()):
+            if folder.is_dir() and folder.name != "completed":
+                video_files = list(folder.glob("*.mp4")) + list(folder.glob("*.avi")) + list(folder.glob("*.mov"))
+                if video_files:
+                    mod_time = folder.stat().st_mtime
+                    fecha = datetime.fromtimestamp(mod_time).strftime("%Y-%m-%d %H:%M")
+                    video_folders.append(
+                        {
+                            "name": folder.name,
+                            "path": str(folder),
+                            "created_at": fecha,
+                            "video_files": video_files,
+                        }
+                    )
+
+        if not video_folders:
+            st.info("📝 No hi ha vídeos pujats pendents de validació.")
+        else:
+            opciones_video = [f"{video['name']} - {video['created_at']}" for video in video_folders]
+            seleccion = st.selectbox(
+                "Selecciona un vídeo per validar:",
+                opciones_video,
+                index=0 if opciones_video else None,
+            )
+
+            if seleccion:
+                indice = opciones_video.index(seleccion)
+                video_seleccionat = video_folders[indice]
+
+                col1, col2 = st.columns([2, 1])
+
+                with col1:
+                    st.markdown("### 📹 Informació del Vídeo")
+                    st.markdown(f"**Nom:** {video_seleccionat['name']}")
+                    st.markdown(f"**Data:** {video_seleccionat['created_at']}")
+                    st.markdown(f"**Arxius:** {len(video_seleccionat['video_files'])} vídeos trobats")
+
+                    if video_seleccionat["video_files"]:
+                        video_path = str(video_seleccionat["video_files"][0])
+                        st.markdown("**Vídeo principal:**")
+                        st.video(video_path)
+                    else:
+                        st.warning("⚠️ No s'han trobat arxius de vídeo.")
+
+                with col2:
+                    st.markdown("### 🔍 Accions de Validació")
+
+                    col_btn1, col_btn2 = st.columns(2)
+
+                    with col_btn1:
+                        if st.button("✅ Acceptar", type="primary", key=f"accept_video_{video_seleccionat['name']}"):
+                            success = compliance_client.record_validator_decision(
+                                document_id=f"video_{video_seleccionat['name']}",
+                                validator_email=f"{username}@veureu.local",
+                                decision="acceptat",
+                                comments=f"Vídeo validat per {username}",
+                            )
+                            if success:
+                                st.success("✅ Vídeo acceptat i registrat al servei de compliance")
+                            else:
+                                st.error("❌ Error registrant el veredicte")
+
+                    with col_btn2:
+                        if st.button("❌ Rebutjar", type="secondary", key=f"reject_video_{video_seleccionat['name']}" ):
+                            success = compliance_client.record_validator_decision(
+                                document_id=f"video_{video_seleccionat['name']}",
+                                validator_email=f"{username}@veureu.local",
+                                decision="rebutjat",
+                                comments=f"Vídeo rebutjat per {username}",
+                            )
+                            if success:
+                                st.success("✅ Vídeo rebutjat i registrat al servei de compliance")
+                            else:
+                                st.error("❌ Error registrant el veredicte")
+
+    with tab_ads:
+        st.subheader("🎬 Validar Audiodescripcions")
+
+        videos_con_ad = []
+        if base_dir.exists():
+            for folder in sorted(base_dir.iterdir()):
+                if folder.is_dir() and folder.name != "completed":
+                    for subfolder_name in ["MoE", "Salamandra"]:
+                        subfolder = folder / subfolder_name
+                        if subfolder.exists():
+                            ad_files = list(subfolder.glob("*_ad.txt")) + list(subfolder.glob("*_ad.srt"))
+                            if ad_files:
+                                mod_time = folder.stat().st_mtime
+                                fecha = datetime.fromtimestamp(mod_time).strftime("%Y-%m-%d %H:%M")
+                                videos_con_ad.append(
+                                    {
+                                        "name": folder.name,
+                                        "path": str(folder),
+                                        "created_at": fecha,
+                                        "ad_files": ad_files,
+                                        "ad_folder": str(subfolder),
+                                    }
+                                )
+
+        if not videos_con_ad:
+            st.info("📝 No hi ha audiodescripcions pendents de validació.")
+        else:
+            videos_ad_ordenats = sorted(videos_con_ad, key=lambda x: x["created_at"], reverse=True)
+            opciones_ad = [f"{video['name']} - {video['created_at']}" for video in videos_ad_ordenats]
+
+            seleccion_ad = st.selectbox(
+                "Selecciona una audiodescripció per validar:",
+                opciones_ad,
+                index=0 if opciones_ad else None,
+            )
+
+            if seleccion_ad:
+                indice = opciones_ad.index(seleccion_ad)
+                video_seleccionat = videos_ad_ordenats[indice]
+
+                col1, col2 = st.columns([2, 1])
+
+                with col1:
+                    st.markdown("### 🎬 Informació de l'Audiodescripció")
+                    st.markdown(f"**Vídeo:** {video_seleccionat['name']}")
+                    st.markdown(f"**Data:** {video_seleccionat['created_at']}")
+                    st.markdown(f"**Carpeta:** {Path(video_seleccionat['ad_folder']).name}")
+                    st.markdown(f"**Arxius:** {len(video_seleccionat['ad_files'])} audiodescripcions trobades")
+
+                    if video_seleccionat["ad_files"]:
+                        ad_path = video_seleccionat["ad_files"][0]
+                        st.markdown(f"#### 📄 Contingut ({ad_path.name}):")
+                        try:
+                            texto = ad_path.read_text(encoding="utf-8")
+                        except Exception:
+                            texto = ad_path.read_text(errors="ignore")
+                        st.text_area("Contingut de l'audiodescripció:", texto, height=300, disabled=True)
+                    else:
+                        st.warning("⚠️ No s'han trobat arxius d'audiodescripció.")
+
+                with col2:
+                    st.markdown("### 🔍 Accions de Validació")
+
+                    col_btn1, col_btn2 = st.columns(2)
+
+                    with col_btn1:
+                        if st.button("✅ Acceptar", type="primary", key=f"accept_ad_{video_seleccionat['name']}"):
+                            success = compliance_client.record_validator_decision(
+                                document_id=f"ad_{video_seleccionat['name']}",
+                                validator_email=f"{username}@veureu.local",
+                                decision="acceptat",
+                                comments=f"Audiodescripció validada per {username}",
+                            )
+                            if success:
+                                st.success("✅ Audiodescripció acceptada i registrada al servei de compliance")
+                            else:
+                                st.error("❌ Error registrant el veredicte")
+
+                    with col_btn2:
+                        if st.button("❌ Rebutjar", type="secondary", key=f"reject_ad_{video_seleccionat['name']}" ):
+                            success = compliance_client.record_validator_decision(
+                                document_id=f"ad_{video_seleccionat['name']}",
+                                validator_email=f"{username}@veureu.local",
+                                decision="rebutjat",
+                                comments=f"Audiodescripció rebutjada per {username}",
+                            )
+                            if success:
+                                st.success("✅ Audiodescripció rebutjada i registrada al servei de compliance")
+                            else:
+                                st.error("❌ Error registrant el veredicte")
+
+    st.markdown("---")
+    st.markdown("### ℹ️ Informació del Procés de Validació")
+    st.markdown(
+        """
+        - **Tots els veredictes** es registren al servei de compliance per garantir la traçabilitat
+        - **Cada validació** inclou veredicte, nom del vídeo i validador responsable
+        - **Els registres** compleixen amb la normativa AI Act i GDPR
+        """
+    )