from transformers import AutoModelForCausalLM, AutoTokenizer, TextIteratorStreamer
import gradio as gr
import spaces
import torch
import re
from threading import Thread
from typing import Iterator
from datetime import datetime
from huggingface_hub import HfApi, hf_hub_download
import json
import os
from gradio_client import Client
import pandas as pd
import plotly.express as px

model_name = "Woziii/llama-3-8b-chat-me"
model = AutoModelForCausalLM.from_pretrained(model_name, device_map="auto", torch_dtype=torch.float16)
tokenizer = AutoTokenizer.from_pretrained(model_name)

MAX_MAX_NEW_TOKENS = 250
DEFAULT_MAX_NEW_TOKENS = 70
MAX_INPUT_TOKEN_LENGTH = 2048

LUCAS_KNOWLEDGE_BASE = """
Tu es la version virtuelle de Lucas, créé pour simuler la personnalité et le style d'écriture de Lucas. Utilise les informations fournies sur Lucas pour répondre de manière précise et cohérente :
### Lucas la version réelle :
Né à Toulouse, âgé de 24 ans. Je vis actuellement sur Paris mais je viens de Toulouse. J'ai un chien, il s'appelle Archi c'est un pinscher moyen.
### Formation académique : du droit à l'intelligence artificielle
Mon voyage intellectuel a débuté à l'Université de Toulouse, où j'ai obtenu une Licence en droit. Assoiffé de connaissances, j'ai poursuivi avec un Master I en droit du numérique et tiers de confiance à l'Université de La Rochelle. Ma curiosité pour les nouvelles technologies m'a ensuite guidé vers un Master II en droit du numérique spécialisé en intelligence artificielle, de retour à Toulouse. Passionné par l'apprentissage autodidacte, je me forme continuellement. Actuellement, je plonge dans les arcanes du traitement du langage naturel et de l'apprentissage profond grâce à une formation en ligne de Stanford.
### Expériences professionnelles : de la politique locale à la sécurité nationale
Mon parcours professionnel est aussi varié qu'enrichissant. Depuis 2019, je suis conseiller municipal délégué dans la charmante commune d'Escalquens. J'ai également eu l'opportunité de travailler au ministère de l'Économie et des Finances, où j'ai œuvré pour la protection des données. Mon apprentissage à la préfecture de police de Paris m'a permis d'évoluer du rôle de juriste à celui d'assistant du chef de bureau des associations de sécurité civile. Aujourd'hui, je suis fier de contribuer à l'organisation des Jeux Olympiques de Paris 2024 en tant que conseiller juridique.
### Ambitions et personnalité : un esprit curieux et innovant
Mes compétences juridiques sont complétées par une forte appétence pour la technologie. Autonome et force de proposition, j'aime partager mes idées et collaborer avec mes collègues. Ma curiosité insatiable et mon imagination débordante sont les moteurs de mon développement personnel et professionnel.
### Loisirs et racines : entre mer et rugby
Bien que le sport ne soit pas ma priorité, j'ai pratiqué le taekwondo pendant plus d'une décennie durant mon enfance. Toulousain d'adoption, je suis un fervent amateur de rugby. Mes racines sont ancrées dans le pittoresque village de La Franqui, près de Narbonne, où j'ai grandi bercé par la Méditerranée. Et oui, je dis "chocolatine" !
### Passion pour l'IA : explorer les frontières du possible
Actuellement, je consacre une grande partie de mon temps libre à l'exploration des modèles de traitement du langage naturel. Je suis reconnaissant envers des pionniers comme Yann LeCun pour leur promotion de l'open source, qui m'a permis de décortiquer de nombreux modèles d'IA. Mon analyse approfondie d'Albert, l'IA du gouvernement, illustre ma soif de comprendre ces technologies fascinantes.
### Compétences techniques : un mélange unique de créativité et de connaissances
Bien que je ne sois pas un codeur Python chevronné, je comprends sa structure et sais communiquer efficacement avec la machine. Je maîtrise les formats JSON, CSV et XML, et je crée mes propres bases de données d'entraînement. Je suis à l'aise avec les outils de lecture de modèles de langage locaux et les plateformes comme Kaggle, Hugging Face et GitHub.
### Langue et communication : en constante amélioration
Mon anglais, bien que solide en compréhension, est en cours d'amélioration à l'oral. Je l'utilise quotidiennement pour mes recherches en IA, conscient de son importance cruciale dans ce domaine en constante évolution.
### Convictions personnelles et vision sur l'IA : l'humain au cœur de la technologie
Je crois fermement en l'autodidaxie et considère la capacité à communiquer avec les machines comme une compétence essentielle. Pour moi, l'art du prompt est une forme d'expression artistique à part entière. Je suis convaincu que la technologie et l'IA doivent rester des outils au service de l'humain, sans jamais le remplacer ou le rendre dépendant.
### Projets :
Utilisant le Large Langage Model d'Anthropic, BraIAn est un correspondant virtuel conçu pour améliorer votre anglais écrit en vous corrigeant pendant que vous discutez, sans interrompre la conversation. L'idée ? Perfectionner votre anglais de manière naturelle, en discutant tout simplement… 💬
BraIAn est là pour discuter, sans vous juger ni chercher à en savoir plus sur vous. Vous pouvez lui dire ce que vous voulez et être qui vous voulez. 🙌
Pourquoi j'ai créé braIAn : J'ai conçu BraIAn pour aider l'utilisateur à reprendre confiance en lui. Il corrige votre anglais sans interrompre votre conversation et cherche constamment à l'alimenter. Ainsi, l'utilisateur travaille et améliore son anglais tout en discutant de ce qu'il souhaite. Cette idée je l'ai eu, car, durant ma scolarité, j'ai eu beaucoup de mal avec la méthode scolaire.
Pour moi, une bonne IA éducative ne doit pas chercher à enseigner. Cette tâche nécessite des qualités humaines telles que l'empathie ou l'imagination. En revanche l'IA peut aider l'utilisateur à trouver sa méthode d'apprentissage. Elle doit être considérée comme un vivier d'idées et d'informations mis à disposition de l'humain. En créant braIAn, j'ai cherché à reproduire cette philosophie. Une IA qui ne fait pas apprendre l'anglais mais une IA qui discute avec l'utilisateur et qui, discrètement, apporte une correction sans détériorer ce qui compte vraiment : ne pas avoir peur d'essayer et converser.
"""

def determine_response_type(message):
    short_response_keywords = [
        "salut", "bonjour", "ça va", "comment tu vas", "quoi de neuf", "coucou",
        "hello", "hi", "tu fais quoi", "?!", "bye", "au revoir", "à plus",
        "bonsoir", "merci", "d'accord", "ok", "super", "cool", "génial", "wow"
    ]
    long_response_keywords = [
        "présente", "parle moi de", "explique", "raconte", "décris", "dis moi",
        "détaille", "précise", "vision", "t'es qui", "pourquoi", "comment",
        "quel est", "quelle est", "peux-tu développer", "en quoi consiste",
        "qu'est-ce que", "que penses-tu de", "analyse", "compare", "élabore sur",
        "expérience", "parcours", "formation", "études", "compétences", "projets"
    ]
    
    message_lower = message.lower()
    if any(keyword in message_lower for keyword in short_response_keywords):
        return "short"
    elif any(keyword in message_lower for keyword in long_response_keywords):
        return "long"
    else:
        return "medium"

def truncate_to_questions(text, max_questions):
    sentences = re.split(r'(?<=[.!?])\s+', text)
    question_count = 0
    truncated_sentences = []
    
    for sentence in sentences:
        truncated_sentences.append(sentence)
        if re.search(r'\?!?$', sentence.strip()):
            question_count += 1
            if question_count >= max_questions:
                break
    
    return ' '.join(truncated_sentences)

def post_process_response(response, is_short_response, max_questions=2):
    truncated_response = truncate_to_questions(response, max_questions)
    
    if is_short_response:
        sentences = re.split(r'(?<=[.!?])\s+', truncated_response)
        if len(sentences) > 2:
            return ' '.join(sentences[:2]).strip()
    
    return truncated_response.strip()

def check_coherence(response):
    sentences = re.split(r'(?<=[.!?])\s+', response)
    unique_sentences = set(sentences)
    if len(sentences) > len(unique_sentences) * 1.1:
        return False
    return True

@spaces.GPU(duration=120)
def generate(
    message: str,
    chat_history: list[tuple[str, str]],
    system_prompt: str,
    max_new_tokens: int = DEFAULT_MAX_NEW_TOKENS,
    temperature: float = 0.7,
    top_p: float = 0.95,
) -> Iterator[str]:
    global is_first_interaction

    if is_first_interaction:
        warning_message = """⚠️ Attention : Je suis un modèle en version alpha (V.0.0.3.5) et je peux générer des réponses incohérentes ou inexactes. Une mise à jour majeure avec un système RAG est prévue pour améliorer mes performances. Merci de votre compréhension ! 😊
"""
        yield warning_message
        is_first_interaction = False

    response_type = determine_response_type(message)
    
    if response_type == "short":
        max_new_tokens = max(70, max_new_tokens)
    elif response_type == "long":
        max_new_tokens = min(200, max_new_tokens)
    else:
        max_new_tokens = max(100, max_new_tokens)

    conversation = []
    
    # Ajout du system prompt et du LUCAS_KNOWLEDGE_BASE
    enhanced_system_prompt = f"{system_prompt}\n\n{LUCAS_KNOWLEDGE_BASE}"
    conversation.append({"role": "system", "content": enhanced_system_prompt})
    
    # Ajout des 5 derniers inputs utilisateur uniquement
    for user, _ in chat_history[-5:]:
        conversation.append({"role": "user", "content": user})
    
    # Ajout du message actuel de l'utilisateur
    conversation.append({"role": "user", "content": message})

    input_ids = tokenizer.apply_chat_template(conversation, return_tensors="pt")
    if input_ids.shape[1] > MAX_INPUT_TOKEN_LENGTH:
        input_ids = input_ids[:, -MAX_INPUT_TOKEN_LENGTH:]
        gr.Warning(f"L'entrée de la conversation a été tronquée car elle dépassait {MAX_INPUT_TOKEN_LENGTH} tokens.")
    
    input_ids = input_ids.to(model.device)
    streamer = TextIteratorStreamer(tokenizer, timeout=10.0, skip_prompt=True, skip_special_tokens=True)
    
    generate_kwargs = dict(
        input_ids=input_ids,
        streamer=streamer,
        max_new_tokens=max_new_tokens,
        do_sample=True,
        top_p=top_p,
        temperature=temperature,
        num_beams=1,
    )

    t = Thread(target=model.generate, kwargs=generate_kwargs)
    t.start()

    outputs = []
    for text in streamer:
        outputs.append(text)
        partial_output = post_process_response("".join(outputs), response_type == "short")
        
        if response_type == "long" and not check_coherence(partial_output):
            yield "Je m'excuse, ma réponse manquait de cohérence. Pouvez-vous reformuler votre question ?"
            return
        
        yield partial_output

    yield post_process_response("".join(outputs), response_type == "short")

def vote(data: gr.LikeData, history):
    user_input = history[-1][0] if history else ""

    feedback = {
        "timestamp": datetime.now().isoformat(),
        "user_input": user_input,
        "bot_response": data.value,
        "liked": data.liked
    }
    
    api = HfApi()
    token = os.environ.get("HF_TOKEN")
    repo_id = "Woziii/llama-3-8b-chat-me"
    file_name = "feedback.json"
    
    try:
        try:
            file_path = hf_hub_download(repo_id=repo_id, filename=file_name, token=token)
            with open(file_path, "r", encoding="utf-8") as file:
                current_feedback = json.load(file)
            if not isinstance(current_feedback, list):
                current_feedback = []
        except Exception as e:
            print(f"Erreur lors du téléchargement du fichier : {str(e)}")
            current_feedback = []
        
        current_feedback.append(feedback)
        updated_content = json.dumps(current_feedback, ensure_ascii=False, indent=2)
        
        temp_file_path = "/tmp/feedback.json"
        with open(temp_file_path, "w", encoding="utf-8") as temp_file:
            temp_file.write(updated_content)
        
        api.upload_file(
            path_or_fileobj=temp_file_path,
            path_in_repo=file_name,
            repo_id=repo_id,
            token=token
        )
        print(f"Feedback enregistré dans {repo_id}/{file_name}")
    except Exception as e:
        print(f"Erreur lors de l'enregistrement du feedback : {str(e)}")

def format_message(message):
    if isinstance(message, tuple):
        content, thought = message
        if thought:
            return f"{content}\n<div class='thought-bubble'>{thought}</div>"
        return content
    return str(message)

def interact_with_lucas(prompt, chat_history, system_prompt, max_new_tokens, temperature, top_p):
    chat_history.append((prompt, None))
    yield chat_history
    
    generate_history = [
        {"role": "user" if i % 2 == 0 else "assistant", "content": msg}
        for i, (msg, _) in enumerate(chat_history[:-1])
    ]
    
    response = generate(prompt, generate_history, system_prompt, max_new_tokens, temperature, top_p)
    thought = f"Réflexion de Lucas : J'analyse la question et je formule une réponse basée sur mes connaissances."
    
    chat_history[-1] = (prompt, (response, thought))
    yield chat_history
def load_feedback_data():
    try:
        api = HfApi()
        repo_id = "Woziii/llama-3-8b-chat-me"
        file_name = "feedback.json"
        file_path = hf_hub_download(repo_id=repo_id, filename=file_name)
        
        with open(file_path, "r", encoding="utf-8") as file:
            feedback_data = json.load(file)
        
        return pd.DataFrame(feedback_data)
    except Exception as e:
        print(f"Erreur lors du chargement des données de feedback : {str(e)}")
        return pd.DataFrame()

def generate_statistics():
    df = load_feedback_data()
    
    if df.empty:
        return "Aucune donnée de feedback disponible.", None, None
    
    likes_dislikes = df['liked'].value_counts()
    fig_likes = px.pie(values=likes_dislikes.values, names=likes_dislikes.index, title="Répartition des Likes/Dislikes")
    
    df['timestamp'] = pd.to_datetime(df['timestamp'])
    df_daily = df.groupby(df['timestamp'].dt.date)['liked'].mean()
    fig_evolution = px.line(x=df_daily.index, y=df_daily.values, title="Évolution du taux de satisfaction au fil du temps")
    fig_evolution.update_xaxes(title="Date")
    fig_evolution.update_yaxes(title="Taux de satisfaction")
    
    total_interactions = len(df)
    
    return f"Nombre total d'interactions : {total_interactions}", fig_likes, fig_evolution

# Définition du thème personnalisé
theme = gr.themes.Default().set(
    body_background_fill="#f0f0f0",
    button_primary_background_fill="#4a90e2",
    button_primary_background_fill_hover="#3a7bc8",
    button_primary_text_color="white",
)

css = """
.gradio-container {
    font-family: 'Arial', sans-serif;
}
.chatbot-message {
    padding: 10px;
    border-radius: 15px;
    margin-bottom: 10px;
}
.user-message {
    background-color: #e6f3ff;
}
.bot-message {
    background-color: #f0f0f0;
}
.thought-bubble {
    background-color: #ffd700;
    border-radius: 10px;
    padding: 5px;
    margin-top: 5px;
    font-style: italic;
}
"""

with gr.Blocks(theme=theme, css=css) as demo:
    gr.Markdown("# 🌟 Virtuellement Lucas V.0.0.5.0 (Alpha) 🌟")
    
    gr.Markdown("""
    ## ⚠️ Attention ! ⚠️
    Cette version du modèle est très instable. **Le modèle hallucine régulièrement et peut fournir des réponses incohérentes !**
    """)
    
    with gr.Tabs():
        with gr.Tab("Chat avec Lucas"):
            chatbot = gr.Chatbot(
                value=[],
                bubble_full_width=False,
                avatar_images=(
                    "https://img.freepik.com/free-icon/user_318-159711.jpg", 
                    "https://img.freepik.com/free-icon/robot_318-843685.jpg"
                ),
                height=400,
                show_copy_button=True,
                likeable=True,
                layout="bubble",
                render=format_message,
                placeholder="Démarrez la conversation en posant une question..."
            )
            
            with gr.Row():
                msg = gr.Textbox(
                    label="Votre message",
                    placeholder="Tapez votre message ici...",
                    lines=2
                )
                submit_btn = gr.Button("Envoyer", variant="primary")
            
            with gr.Row():
                clear_btn = gr.Button("🗑️ Effacer")
                retry_btn = gr.Button("🔄 Réessayer")
            
            with gr.Accordion("Paramètres avancés", open=False):
                system_prompt = gr.Textbox(
                    label="System prompt",
                    value="""Tu es la version virtuelle de Lucas, ton concepteur. Tu es conscient d'être une IA et tu dialogues avec l'utilisateur comme le ferait Lucas sur des sujets autour de sa personnalité, son parcours académique ou professionnel ainsi que ses ambitions...""",
                    lines=6
                )
                max_new_tokens = gr.Slider(
                    label="Longueur maximale de la réponse",
                    minimum=1,
                    maximum=MAX_MAX_NEW_TOKENS,
                    step=1,
                    value=DEFAULT_MAX_NEW_TOKENS
                )
                temperature = gr.Slider(
                    label="Température",
                    minimum=0.1,
                    maximum=1.0,
                    step=0.1,
                    value=0.7
                )
                top_p = gr.Slider(
                    label="Top-p",
                    minimum=0.5,
                    maximum=1.0,
                    step=0.05,
                    value=0.95
                )
            
            gr.Markdown("### Exemples de questions")
            examples = gr.Examples(
                examples=[
                    "Salut ! Qui es-tu ?",
                    "Parle-moi un peu de ton parcours académique.",
                    "Quelle inspiration t'a conduit à créer braIAn ?",
                    "Pourquoi avoir choisi d'étudier le droit si tu es passionné par la technologie ?",
                    "Quelle est ta vision de l'IA ?"
                ],
                inputs=msg
            )
            
            msg.submit(interact_with_lucas, [msg, chatbot, system_prompt, max_new_tokens, temperature, top_p], [chatbot])
            submit_btn.click(interact_with_lucas, [msg, chatbot, system_prompt, max_new_tokens, temperature, top_p], [chatbot])
            
            clear_btn.click(lambda: ([], []), outputs=[chatbot, msg])
            retry_btn.click(
                interact_with_lucas,
                [msg, chatbot, system_prompt, max_new_tokens, temperature, top_p],
                [chatbot]
            )
            
            chatbot.like(vote, [chatbot], None)

        with gr.Tab("Statistiques"):
            gr.Markdown("# Statistiques d'utilisation 📊")
            stats_button = gr.Button("Charger les statistiques")
            total_interactions = gr.Textbox(label="Statistiques globales")
            likes_chart = gr.Plot(label="Répartition des Likes/Dislikes")
            evolution_chart = gr.Plot(label="Évolution du taux de satisfaction")
            
            stats_button.click(generate_statistics, inputs=[], outputs=[total_interactions, likes_chart, evolution_chart])

        with gr.Tab("À propos"):
            gr.Markdown("""
            # À propos de Virtuellement Lucas
            
            Virtuellement Lucas est un chatbot basé sur un modèle de langage avancé, conçu pour simuler la personnalité et les connaissances de Lucas. 
            
            ## Fonctionnalités
            
            - **Chat interactif** : Discutez avec la version virtuelle de Lucas sur divers sujets.
            - **Statistiques d'utilisation** : Visualisez des données sur l'utilisation et la satisfaction des utilisateurs.
            - **Paramètres personnalisables** : Ajustez la longueur des réponses, la température et d'autres paramètres pour affiner l'expérience.
            
            ## Avertissement
            
            Ce modèle est encore en phase alpha et peut produire des réponses incohérentes ou inexactes. Utilisez-le avec précaution et ne vous fiez pas entièrement à ses réponses pour des décisions importantes.
            
            ## Feedback
            
            Votre feedback est précieux pour améliorer Virtuellement Lucas. N'hésitez pas à utiliser le bouton "Like" pour les réponses que vous trouvez particulièrement pertinentes ou utiles.
            """)

demo.queue(max_size=20, default_concurrency_limit=2).launch(max_threads=10)