import streamlit as st
from dotenv import load_dotenv
load_dotenv()
import os 
import google.generativeai as genai
import os
from googletrans import Translator
# import google.generativeai as genai  # Commentez cette ligne si inutile pour text-to-speech
from PIL import Image
from gtts import gTTS  # Bibliothèque pour la synthèse vocale
import google.generativeai as genai 
import requests
import base64
import io
import pandas as pd



st.set_page_config(layout="wide")
st.sidebar.image('logo.png',width=300)
st.set_option('deprecation.showPyplotGlobalUse', False)
def main():
    
    menu =['Chatbot','Text-to-speech','Zero-shot-image-classification','Image-to-text']
    choice = st.sidebar.selectbox('Select Menu',menu)

    if choice == 'Chatbot':
        genai.configure(api_key=os.getenv('GOOGLE_API_KEY'))

        model=genai.GenerativeModel('gemini-pro')
        chat= model.start_chat(history=[])
        st.title('Chatbot Intelligent')
        st.write("<hr>", unsafe_allow_html=True)
        def get_gemini_response(question):
            response=chat.send_message(question,stream=True)
            return response

        # Initialize chat history
        if "messages" not in st.session_state:
            st.session_state.messages = []

        # Display chat messages from history on app rerun
        for message in st.session_state.messages:
            with st.chat_message(message["role"]):
                st.markdown(message["content"])

        # React to user input
        if prompt := st.chat_input("Quoi de neuf?"):
            # Display user message in chat message container
            st.chat_message("user").markdown(prompt)
            # Add user message to chat history
            st.session_state.messages.append({"role": "user", "content": prompt})

            response = get_gemini_response(prompt)
            # Display assistant response in chat message container
            with st.chat_message("assistant"):
                for chunk in response:
                    st.write(chunk.text)
                #st.markdown(response)
            # Add assistant response to chat history
                st.session_state.messages.append({"role": "assistant", "content":chunk.text })

      
    if choice == 'Text-to-speech': 
        genai.configure(api_key=os.getenv('GOOGLE_API_KEY'))

        st.header('Transformez votre Texte en Espagnol avec Audio')
        st.write("<hr>", unsafe_allow_html=True)
        def get_text_to_speech(texte):
            # Traduction du texte en espagnol
            texte_espagnol = traduire_texte(texte)

            # Configuration de la langue et de la vitesse (optionnel)
            tts = gTTS(text=texte_espagnol, lang='es', slow=False)

            # Enregistrement du fichier audio
            tts.save("output.mp3")

            # Lire le fichier audio dans Streamlit (nécessite des bibliothèques supplémentaires)
            st.audio("output.mp3")


        def traduire_texte(texte):
            traducteur = Translator()
            traduction = traducteur.translate(texte, dest="es")
            return traduction.text

        # CSS personnalisé pour le bouton avec un fond vert
        custom_css = """
            <style>
                .stButton>button {
                    background-color: green;
                    color: white;
                    padding: 10px 30px; /* Ajuster la hauteur et la largeur du bouton */
                    font-size: 16px; /* Ajuster la taille de la police du texte */
                    border: 2px solid green; /* Ajouter une bordure verte */
                    border-radius: 5px; /* Ajouter des coins arrondis à la bordure */
                    margin-left: auto; /* Positionner le bouton à droite */
                    margin-right: 0; /* Positionner le bouton à droite */
                }

                /* Style pour le survol du bouton */
                .stButton>button:hover {
                    background-color: white;
                    color: green;
                    border: 2px solid green; /* Ajouter une bordure verte */
                    border-radius: 5px; /* Ajouter des coins arrondis à la bordure */
                }
            </style>
        """
      

    

        # Affichage du CSS personnalisé
        st.markdown(custom_css, unsafe_allow_html=True)

        def input_text_setup():
            text = st.text_area("Entrez le texte à convertir en parole :", height=200,placeholder="Veuillez entre votre text a traduire...")
            submit_button = st.button("Soumettre")  # Ajout du bouton de soumission
            return text, submit_button

        # Section pour la conversion text-to-speech
        # Afficher le champ de texte et le bouton de soumission
        text_to_convert, submit_button = input_text_setup()

        if submit_button:
            if text_to_convert:
                texte_traduit = traduire_texte(text_to_convert)
                st.success("Texte converti en parole espagnole avec sucess.")
                get_text_to_speech(texte_traduit)
                # Section pour l'analyse d'images (peut rester commentée si non utilisée)
            else:
                st.warning("Veuillez entrer du texte avant de soumettre.")

    if choice == 'Zero-shot-image-classification':
        st.title("CLIP Image Classification")
        

        API_URL = "https://api-inference.huggingface.co/models/openai/clip-vit-large-patch14"
        hugging_face_token = os.getenv('API_TOKEN')
        def query(data):
            img_bytes = io.BytesIO(data["image_bytes"])
            payload = {
                "parameters": data["parameters"],
                "inputs": base64.b64encode(img_bytes.read()).decode("utf-8")
            }
            headers = {"Authorization": f"Bearer {hugging_face_token}"}
            response = requests.post(API_URL, headers=headers, json=payload)
            return response.json()
        custom_css = """
            <style>
                .stButton>button {
                    background-color: green;
                    color: white;
                    padding: 10px 30px; /* Ajuster la hauteur et la largeur du bouton */
                    font-size: 16px; /* Ajuster la taille de la police du texte */
                    border: 2px solid green; /* Ajouter une bordure verte */
                    border-radius: 5px; /* Ajouter des coins arrondis à la bordure */
                    margin-left: auto; /* Positionner le bouton à droite */
                    margin-right: 0; /* Positionner le bouton à droite */
                }

                /* Stylisation des étiquettes prédites */
                .st-emotion-cache-cnbvxy {
                    margin-top: 20px;/* Marge supérieure */
                    font-size: 100px !important; /* Taille de la police */
                }
                /* Style pour chaque étiquette prédite */
                .predicted-label {
                    color: green; /* Texte vert */
                    margin-bottom: 5px; /* Marge inférieure */
                }

                /* Style pour le survol du bouton */
                .stButton>button:hover {
                    background-color: white;
                    color: green;
                    border: 2px solid green; /* Ajouter une bordure verte */
                    border-radius: 5px; /* Ajouter des coins arrondis à la bordure */
                }
            </style>
        """
        # Affichage du CSS personnalisé
        st.markdown(custom_css, unsafe_allow_html=True)
        uploaded_image = st.file_uploader("Upload Image", type=["jpg", "jpeg", "png"])
        if uploaded_image is not None:
            st.image(uploaded_image, caption="Uploaded Image", use_column_width=True)
            st.title("Entre les Labels (obligatoire)")
            candidate_labels = st.text_input("Entrez les étiquettes séparées par des virgules",placeholder='Veullez entrer les classes separé par des virgules. ex: chat, chien, souris ...')
            parameters = {"candidate_labels": candidate_labels.split(",")}
            
            
            if st.button("Classifier"):
                if candidate_labels.strip() == "":
                    st.warning("Veuillez entrer au moins une étiquette. Au-delà de deux étiquettes, veuillez vous assurer de les séparer par des virgules et des espaces.")
                else:
                    parameters = {"candidate_labels": candidate_labels.split(",")}
                    result = query({"image_bytes": uploaded_image.read(), "parameters": parameters})
                    if result:
                        # Début du tableau
                        st.title("Predicted Labels:")
                        # Création d'une liste pour stocker les labels et scores
                        labels = []
                        scores = []
                        for prediction in result:
                            label = prediction["label"]
                            score = prediction["score"]
                            labels.append(label)
                            scores.append(score)
                        # Création d'un DataFrame avec les labels et les scores
                        df = pd.DataFrame({
                            'Label': labels,
                            'Score': scores,
                        })
                        # Affichage du DataFrame avec une largeur ajustée
                        st.dataframe(df, width=600)
                    else:
                        st.write("No labels predicted.")

    if choice == 'Image-to-text':
        genai.configure(api_key=os.getenv('GOOGLE_API_KEY'))
         
        custom_css = """
            <style>
                .stButton>button {
                    background-color: green;
                    color: white;
                    padding: 10px 30px; /* Ajuster la hauteur et la largeur du bouton */
                    font-size: 16px; /* Ajuster la taille de la police du texte */
                    border: 2px solid green; /* Ajouter une bordure verte */
                    border-radius: 5px; /* Ajouter des coins arrondis à la bordure */
                    margin-left: auto; /* Positionner le bouton à droite */
                    margin-right: 0; /* Positionner le bouton à droite */
                }


                /* Style pour le survol du bouton */
                .stButton>button:hover {
                    background-color: white;
                    color: green;
                    border: 2px solid green; /* Ajouter une bordure verte */
                    border-radius: 5px; /* Ajouter des coins arrondis à la bordure */
                }
            </style>
        """
        st.markdown(custom_css, unsafe_allow_html=True)
        def get_gemini_response(input_prompt,image):
            model=genai.GenerativeModel('gemini-pro-vision')
            response = model.generate_content([input_prompt,image[0]])
            return response.text
        def input_image_setup(uploaded_file):
            if uploaded_file is not None:
                bytes_data = uploaded_file.getvalue()
                image_parts = [{'mime_type':uploaded_file.type,
                                'data':bytes_data}]
                return image_parts
            else:
                raise FileNotFoundError('No File Uploaded')

        st.header('Description d une image')
        st.write("<hr>", unsafe_allow_html=True)
        uploaded_file = st.file_uploader('Choose an image.',type=['jpg','jpeg','png'])
        if uploaded_file is not None:
            image=Image.open(uploaded_file)
            st.image(image,caption="uploaded_file",use_column_width=True)
        st.write("<hr>", unsafe_allow_html=True)
        submit=st.button('Decrire')
        input_prompt="""
        Decrire l'image
        """
        if submit:
            if uploaded_file is not None:
                image_data = input_image_setup(uploaded_file)
                response = get_gemini_response(input_prompt,image_data)
                st.subheader('La description de l\'image est : ')
                st.markdown(
                f"<div style='font-size: 18px; border-radius: 10px; border: 2px solid #777777;; padding: 20px; line-height: 1.7;'>{response}</div>", 
                unsafe_allow_html=True )
            else:
                st.error("Veuillez entrer une image en entrée")


if __name__ == '__main__':
    main()

#https://huggingface.co/spaces/DJONG-WANG/projet_tutore