Upload 9 files

app.py

@@ -1,65 +1,23 @@
 import os
-import io
-import json
 import yaml
 import shutil
-import subprocess
 from pathlib import Path
-from datetime import datetime
-from passlib.hash import bcrypt
 try:
     import tomllib
 except ModuleNotFoundError:  # Py<3.11
     import tomli as tomllib
 import streamlit as st
 
-from database import set_db_path, init_schema, create_video, update_video_status, list_videos, get_video, upsert_result, get_results, add_feedback, get_feedback_for_video, get_feedback_stats
+from database import set_db_path, init_schema
 from api_client import APIClient
-from utils import ensure_dirs, save_bytes, save_text, human_size
+from utils import ensure_dirs
 from auth import initialize_auth_system, render_login_form, render_sidebar, require_login
 from mobile_verification import render_mobile_verification_screen, get_user_permissions
 from compliance_client import compliance_client
-
-
-def _get_video_duration(path: str) -> float:
-    """Return video duration in seconds using ffprobe."""
-    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):
-        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")
+from pages.process_video import render_process_video_page
+from pages.analyze_transcriptions import render_analyze_transcriptions_page
+from pages.statistics import render_statistics_page
+from pages.validation import render_validation_page
 
 
 # -- Move DB ---
@@ -136,6 +94,7 @@ if not st.session_state.user:
 if st.session_state.user and 'sms_verified' not in st.session_state:
     st.session_state.sms_verified = None
 
+permissions = None
 if st.session_state.user:
     username = st.session_state.user['username']
     role = st.session_state.user['role']
@@ -155,583 +114,23 @@ if st.session_state.user:
 if page == "Processar vídeo nou":
     require_login(render_login_form)
     
-    # Verificar permisos
     permissions = get_user_permissions(role, st.session_state.get('sms_verified'))
     if not permissions["procesar_videos"]:
         st.error("No tens permisos per processar nous vídeos. Verifica el teu mòbil per obtenir accés complet.")
         st.stop()
 
-    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
-
-        # --- Validación y Procesamiento ---
-        if st.session_state.video_uploaded['status'] == 'validating':
-            is_valid = True
-            # 1. Validar tamaño
-            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..."):
-                    # Guardar temporalmente para analizarlo
-                    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()
-
-    # --- Mensajes de estado ---
-    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(f"El vídeo s'ha truncat a {MAX_DURATION_S // 60} minuts.")
-
-    # --- 2. Detección de personajes ---
-    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..."):
-                # Aquí iría la llamada a la API para detectar personajes
-                # Por ahora, usamos datos de ejemplo
-                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 # Resetear el estado de guardado
-
-    # --- 3. Formularios de personajes ---
-    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("---_**")
-
-        # --- 4. Guardar y Generar ---
-        col1, col2, col3 = st.columns([1,1,2])
-        with col1:
-            if st.button("Desar", type="primary"):
-                # Aquí iría la lógica para guardar los nombres de los personajes
-                st.session_state.characters_saved = True
-                st.success("Personatges desats correctament.")
-
-        with col2:
-            if st.session_state.characters_saved:
-                st.button("Generar Audiodescripció")
+    render_process_video_page()
 
 elif page == "Analitzar video-transcripcions":
     require_login(render_login_form)
-    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()
-
-    # --- Lógica de Estado y Selección ---
-
-    # Detectar si el vídeo principal ha cambiado para resetear el estado secundario
-    if 'current_video' not in st.session_state:
-        st.session_state.current_video = None
-
-    # Widget de selección de vídeo
-    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
-        # Forzar reseteo de los widgets dependientes
-        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"))
-
-    # --- Dibujado de la Interfaz ---
-    col_video, col_txt = st.columns([2, 1], gap="large")
-
-    with col_video:
-        # Selección de versión
-        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"
-        )
-
-        # Lógica de vídeo AD
-        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()
-
-        # Checkbox
-        add_ad_video = st.checkbox("Afegir audiodescripció", disabled=not is_ad_video_available, key="add_ad_checkbox")
-
-        # Decidir qué vídeo mostrar
-        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("---")
-
-        # Sección de ACCIONES
-        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" # Voz fijada
-                            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ó.")
-
-
-    # --- Columna Derecha (Editor de texto y guardado) ---
-    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"
-        
-        # Cargar el contenido del fichero seleccionado
-        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.")
-
-        # Área de texto para edición
-        new_text = st.text_area(f"Contingut de {tipus_ad_seleccio}", value=text_content, height=500, key=f"editor_{seleccio}_{subcarpeta_seleccio}_{ad_filename}")
-
-        # Controles de reproducción de narración (selector de voz eliminado)
-        if st.button("▶️ Reproduir narració", use_container_width=True, disabled=not new_text.strip(), key="play_button_editor"):
-            with st.spinner("Generant àudio..."):
-                # Lógica de TTS con el texto del área
-                pass # Implementación de la llamada a la API TTS
-
-        # Botón de guardado
-        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ó")
-
-    role = st.session_state.user["role"]
     permissions = get_user_permissions(role, st.session_state.get('sms_verified'))
-    can_rate = permissions["valorar"]
-    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}")
-
+    render_analyze_transcriptions_page(api, permissions)
 
 elif page == "Estadístiques":
     require_login(render_login_form)
-    st.header("Estadístiques")
-
-    from database import get_feedback_ad_stats
-    stats = get_feedback_ad_stats()  # medias por vídeo + avg_global
-    if not stats:
-        st.caption("Encara no hi ha valoracions.")
-        st.stop()
-
-    import pandas as pd
-    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
-    )
-
+    render_statistics_page()
 
 elif page == "Validació":
     require_login(render_login_form)
-
-    username = st.session_state.user["username"]
-    role = st.session_state.user["role"]
     permissions = get_user_permissions(role, st.session_state.get('sms_verified'))
-
-    if not permissions["validar"]:
-        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"])
-
-    with tab_videos:
-        st.subheader("📹 Validar Vídeos Pujats")
-
-        candidates = [
-            runtime_videos,
-            Path(__file__).resolve().parent / "videos",
-            Path.cwd() / "videos",
-        ]
-        base_dir = None
-        for c in candidates:
-            if c.exists():
-                base_dir = c
-                break
-        if base_dir is None:
-            base_dir = candidates[0]
-
-        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()
-
-        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")
-
-        candidates = [
-            runtime_videos,
-            Path(__file__).resolve().parent / "videos",
-            Path.cwd() / "videos",
-        ]
-        base_dir = None
-        for c in candidates:
-            if c.exists():
-                base_dir = c
-                break
-        if base_dir is None:
-            base_dir = candidates[0]
-
-        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
-        """
-    )
+    render_validation_page(compliance_client, runtime_videos, permissions, username)

pages/__init__.py

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

pages/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}")

pages/process_video.py

@@ -0,0 +1,198 @@
+"""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, falling back to ffmpeg when needed."""
+    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
+
+    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ó")

pages/statistics.py

@@ -0,0 +1,46 @@
+"""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,
+    )

pages/validation.py

@@ -0,0 +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 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
+        """
+    )