import streamlit as st
import requests
import re

# --- Configuration regex pour le token Hugging Face ---
TOKEN_REGEX = r"^hf_[a-zA-Z0-9]{32,}$"

def is_token_valid(token):
    return re.match(TOKEN_REGEX, token) is not None, token


# --- Page de login ---
def login():
    st.title("🔐 Authentification par Token Hugging Face")

    token = st.text_input("Entrez votre token Hugging Face", type="password")

    if st.button("Se connecter"):
        if is_token_valid(token):
            st.session_state["auth"] = True
            st.session_state["token"] = token
            st.success("Connexion réussie ✅")
            st.rerun()
        else:
            st.error("Token Hugging Face invalide ❌")

# --- Application principale ---
def run_app():
    st.set_page_config(page_title="nlp", layout="wide")
    st.title("CC NATURAL LANGUAGE PROCESSING")
    st.markdown("Une application d'IA qui vous permet d'effectuer les taches comme la traduction, la generation de text et \n la generation de l'audio a partir d'un texte saisir par l'utilisateur, testez les en navigant sur les boutons ci-dessous.")
    
    image_path = "keyce_logo.jpeg" 

    # Affichage dans la sidebar
    st.sidebar.image(image_path, caption="Keyce informatique et intelligence artificielle", use_container_width=True)

    # --- Variables dynamiques avec token utilisateur ---
    token = st.session_state["token"]
    headers = {"Authorization": f"Bearer {token}"}


    # client = InferenceClient(
    #     provider="fireworks-ai",
    #     api_key=headers,
    # )

    TTS_API_URL = "https://api-inference.huggingface.co/models/facebook/mms-tts-fra"
    API_URL_HELSINKI = "https://api-inference.huggingface.co/models/Helsinki-NLP/opus-mt-de-es"

    # --- Fonctions ---
    def generer_audio(api_url, texte):
        payload = {"inputs": texte}
        response = requests.post(api_url, headers=headers, json=payload)
        if response.status_code == 200:
            return response.content
        else:
            return None

    def traduire_libretranslate(texte, source="de", cible="es"):
        url = "https://libretranslate.de/translate"
        payload = {
            "q": texte,
            "source": source,
            "target": cible,
            "format": "text"
        }
        headers_local = {
            "Content-Type": "application/json"
        }
        try:
            response = requests.post(url, json=payload, headers=headers_local, timeout=10)
            response.raise_for_status()
            return response.json()
        except requests.exceptions.ConnectTimeout:
            return {"error": "Connexion à l'API expirée."}
        except requests.exceptions.RequestException as e:
            return {"error": str(e)}

    def generer_texte_deepseek(prompt):
        try:
            response = client.chat.completions.create(
                model="deepseek-ai/DeepSeek-R1",
                messages=[{"role": "user", "content": prompt}],
                max_tokens=512,
            )
            # Accéder au texte généré dans la structure de réponse
            # generated_text = response
            return response.choices[0].message
        except Exception as e:
            st.error(f"Erreur lors de la génération du texte : {e}")
            return None
    
    import re

    def nettoyer_reponse(text):
        # Supprimer tout ce qui est entre <think>...</think>, y compris les balises
        cleaned = re.sub(r"<think>.*?</think>", "", text, flags=re.DOTALL)
        return cleaned.strip()


    # --- Interface principale avec tabs ---
    tab1, tab2, tab3 = st.tabs(["Modèle texte to audio 🔊", "Modèle de traduction 🌐 `Allemand -> Espagnole`", "Modèle de génération de texte 📝 `Avec deepSeek`"])

    with tab1:
        st.subheader("Modèle Text-to-Audio")
        texte_fr = st.text_area("Entrez votre texte en français :", key="texte_fr")
        if st.button("Lire audio"):
            if not texte_fr.strip():
                st.warning("Veuillez entrer un texte.")
            else:
                audio_fr = generer_audio(TTS_API_URL, texte_fr)
                if audio_fr:
                    st.audio(audio_fr, format="audio/wav")
                else:
                    st.error("Erreur lors de la génération audio.")

    with tab2:
        st.subheader("Modèle de traduction")
        texte_to_tr = st.text_area("Entrez votre texte à traduire :", key="texte_to_tr")

        if st.button("Traduire"):
            if not texte_to_tr.strip():
                st.warning("Veuillez entrer un texte à traduire.")
            else:
                with st.spinner("Traduction en cours..."):
                    from huggingface_hub import InferenceClient

                    client2 = InferenceClient(
                        provider="hf-inference",
                        api_key=token,
                    )

                    result = client2.translation(
                        text= texte_to_tr,
                        src_lang= 'de_DE',
                        tgt_lang='es_XX',
                        model="facebook/mbart-large-50-many-to-many-mmt",
                    )

                    if "error" in result:
                        st.error(result['error'])
                    else:
                        translated_text = result["translation_text"]
                        st.success("Traduction espagnole :")
                        st.write(f"📝 {translated_text}")

    with tab3:
        st.subheader("Modèle de Générateur de texte (DeepSeek) 📝")

        prompt = st.text_area("Entrez votre prompt :", key="prompt")

        if st.button("Générer", key="gen"):
            if prompt.strip():
                with st.spinner("Génération..."):
                    try:
                        from huggingface_hub import InferenceClient
                        client = InferenceClient(
                            provider="fireworks-ai",
                            api_key=token,
                        )

                        completion = client.chat.completions.create(
                            model="deepseek-ai/DeepSeek-R1",
                            messages=[
                                {
                                    "role": "user",
                                    "content": prompt
                                }
                            ],
                            max_tokens=512,
                        )

                        output = nettoyer_reponse(completion.choices[0].message.content)

                        st.success("Texte généré :")
                        st.write(output)
                    except Exception as e:
                        st.error(f"Erreur : {e}")
            else:
                st.warning("Veuillez entrer un prompt.")

    st.markdown("---")
    st.sidebar.markdown("---")
    st.sidebar.markdown(" ")
    st.sidebar.markdown(" ")
    st.sidebar.text("Cliquez sur ce bouton pour vous deconnecter")
    if st.sidebar.button("Se déconnecter"):
        st.session_state.clear()
        st.rerun()


# --- Lancement logique ---
if "auth" not in st.session_state:
    st.session_state["auth"] = False

if not st.session_state["auth"]:
    login()
else:
    run_app()