app.py

# app.py
# ─────────────────────────────────────────────────────────────────────────────
# Interface Streamlit minimaliste pour piloter VideoProcessor
# MVP : URL YouTube OU fichier local → lancer → logs + progression → résultat
# Lancement : python desktop.py (fenêtre native pywebview)
# ─────────────────────────────────────────────────────────────────────────────
from __future__ import annotations

import asyncio
import tempfile
from pathlib import Path

import streamlit as st
from dotenv import load_dotenv

from video_processor import VideoProcessor

# Charge les secrets locaux (.env) — ex. ANTHROPIC_API_KEY pour la sélection LLM
load_dotenv(Path(__file__).resolve().parent / ".env")

_STATE_DEFAULTS = {
    "logs": [],
    "progress": 0.0,
    "output_video": None,
    "clips": [],
    "clips_meta": [],
    "title": "",
    "author": "",
    "description_tiktok": "",
    "hashtags_str": "",
    "error": None,
}


# ─────────────────────────────────────────────────────────────────────────────
# État
# ─────────────────────────────────────────────────────────────────────────────
def init_state() -> None:
    """Initialise l'état Streamlit au premier run."""
    for k, v in _STATE_DEFAULTS.items():
        if k not in st.session_state:
            st.session_state[k] = v


def reset_state() -> None:
    for k, v in _STATE_DEFAULTS.items():
        st.session_state[k] = v


# ─────────────────────────────────────────────────────────────────────────────
# Exécution du pipeline
# ─────────────────────────────────────────────────────────────────────────────
def run_pipeline(source: str, log_box, progress_bar, status_box) -> None:
    """
    Exécute le pipeline asynchrone de VideoProcessor.

    Les phases lourdes tournent dans des threads workers (asyncio.to_thread) :
    les callbacks ne font que muter des structures Python (thread-safe), et
    une boucle de rafraîchissement dans le thread principal (qui possède le
    contexte Streamlit) pousse logs + progression vers l'UI en direct.
    """
    logs: list[str] = []
    progress = {"value": 0.0}

    def log_cb(msg: str) -> None:
        logs.append(str(msg))

    def prog_cb(p: float) -> None:
        progress["value"] = max(0.0, min(1.0, float(p)))

    def done_cb(path: str) -> None:
        pass  # l'état final est lu directement sur l'objet après process()

    vp = VideoProcessor(log_cb, prog_cb, done_cb)

    def refresh_ui() -> None:
        progress_bar.progress(progress["value"])
        if logs:
            # Étape en cours = dernière ligne "titre" (les sous-étapes sont indentées)
            step = next((l for l in reversed(logs) if not l.startswith(" ")), logs[-1])
            status_box.markdown(f"**{step}**")
            log_box.code("\n".join(logs[-500:]), language="bash")

    async def runner() -> None:
        task = asyncio.create_task(vp.process(source))
        while not task.done():
            refresh_ui()
            await asyncio.sleep(0.3)
        await task
        refresh_ui()

    asyncio.run(runner())

    # Récupérer l'état final de manière déterministe
    st.session_state.logs = logs
    st.session_state.progress = progress["value"]
    st.session_state.output_video = vp.output_video
    st.session_state.clips = vp.clips or []
    st.session_state.clips_meta = vp.clips_meta or []
    st.session_state.title = vp.title or ""
    st.session_state.author = vp.author or ""
    st.session_state.description_tiktok = vp.description_tiktok or ""
    st.session_state.hashtags_str = " ".join(vp.hashtag[:10])
    st.session_state.error = vp.error


# ─────────────────────────────────────────────────────────────────────────────
# UI
# ─────────────────────────────────────────────────────────────────────────────
def render_header() -> None:
    st.set_page_config(page_title="TikTok Clip Generator", page_icon="🎬", layout="centered")
    st.markdown(
        """
        <style>
        .block-container { max-width: 840px; }
        </style>
        """,
        unsafe_allow_html=True,
    )
    st.title("🎬 TikTok Clip Generator")
    st.caption("Entrer un lien YouTube **ou** choisir un fichier local, puis lancer le traitement.")


def render_input_section() -> str | None:
    with st.container(border=True):
        mode = st.radio("Source", ["Lien YouTube", "Fichier local"], horizontal=True, index=0)
        if mode == "Lien YouTube":
            url = st.text_input("Lien YouTube", placeholder="https://www.youtube.com/watch?v=…")
            return url.strip() if url else None
        else:
            up = st.file_uploader("Fichier vidéo (mp4/mov/mkv)", type=["mp4", "mov", "mkv"])
            if up is None:
                return None
            # Sauvegarder en fichier temporaire (passage chemin → backend)
            tmp = tempfile.NamedTemporaryFile(delete=False, suffix=Path(up.name).suffix)
            tmp.write(up.read())
            tmp.flush()
            return tmp.name


def render_controls_and_run(source: str | None, log_box, progress_bar, status_box) -> None:
    cols = st.columns([1, 1, 2])
    run_clicked = cols[0].button("🚀 Lancer", use_container_width=True, disabled=not bool(source))
    reset_clicked = cols[1].button("♻️ Réinitialiser", use_container_width=True)

    if reset_clicked:
        reset_state()
        st.success("État réinitialisé.")
        st.stop()

    if run_clicked and source:
        reset_state()
        status_box.markdown("**🚀 Démarrage du montage…**")
        with st.spinner("Montage en cours…"):
            run_pipeline(source, log_box, progress_bar, status_box)

        if st.session_state.output_video:
            st.success("Traitement terminé ✅")
        elif st.session_state.error:
            st.error(f"Échec du traitement : {st.session_state.error}")
        else:
            st.error("Le traitement s'est terminé sans vidéo de sortie. Consulte les logs.")


def render_progress_and_logs(progress_bar, log_box) -> None:
    # Afficher état courant (utile si on rafraîchit ou si logs existent déjà)
    progress_bar.progress(st.session_state.progress)
    if st.session_state.logs:
        log_box.code("\n".join(st.session_state.logs[-500:]), language="bash")


def render_results() -> None:
    if not st.session_state.output_video:
        return

    st.subheader("🎞️ Résultat")
    if Path(st.session_state.output_video).exists():
        st.video(st.session_state.output_video)  # Aperçu du mp4 final (optionnel)
    else:
        st.warning("Le fichier vidéo final n'est plus accessible (probablement nettoyé du répertoire temporaire). Chemin :")
        st.code(st.session_state.output_video or "", language="bash")

    st.markdown("**Chemin vidéo finale :**")
    st.code(st.session_state.output_video, language="bash")

    if st.session_state.clips_meta:
        st.markdown("**Clips générés :**")
        for i, meta in enumerate(st.session_state.clips_meta, start=1):
            score = meta.get("virality_score")
            label = f"🎬 Clip {i} — {meta['hook']}"
            if score is not None:
                label += f"  ·  🔥 {score}/100"
            with st.expander(label):
                st.code(meta["path"], language="bash")
                st.text_area("Description", value=meta["description"], height=80, key=f"clip_desc_{i}")
                st.text_area("Hashtags", value=" ".join(meta["hashtags"]), height=68, key=f"clip_tags_{i}")
    elif st.session_state.clips:
        st.markdown("**Clips générés :**")
        for p in st.session_state.clips:
            st.code(p, language="bash")

    # Zone “copier/coller” pour titre & hashtags
    st.subheader("📝 Métadonnées prêtes à copier")
    col1, col2 = st.columns(2)
    with col1:
        st.text_input("Titre", value=st.session_state.title or "", help="Titre original")
        st.text_input("Auteur", value=st.session_state.author or "", help="Auteur")
    with col2:
        st.text_area("Description TikTok", value=st.session_state.description_tiktok or "", height=90)
        st.text_area("Hashtags", value=st.session_state.hashtags_str or "", height=90)


# ─────────────────────────────────────────────────────────────────────────────
# Entrée principale
# ─────────────────────────────────────────────────────────────────────────────
def main() -> None:
    init_state()
    render_header()

    # Placeholders réutilisables (pour mises à jour live pendant le traitement)
    status_box = st.empty()
    progress_bar = st.empty()
    log_box = st.empty()

    # Saisie source
    source = render_input_section()

    # Contrôles + exécution
    render_controls_and_run(source, log_box, progress_bar, status_box)

    # Rappels d'état & logs
    render_progress_and_logs(progress_bar, log_box)

    # Résultats
    render_results()


if __name__ == "__main__":
    main()