#coding: utf-8

import re
from os import getenv
#from typing import Any
#from typing import Dict
#from typing import IO
from typing import List
from typing import Optional
from typing import Tuple
from typing import Union
from core.files import load_ui_language
from core.files import read_file
from core.demorrha import DemorrhaAssistant
from var_app import GlobalSystemPrompts
import streamlit as st
from openai import OpenAI

from dotenv import load_dotenv
# Charger les variables d'environnement depuis le fichier .env
load_dotenv()

class uiLang:
    # Dictionary to store translations
    translations = load_ui_language()

translations=uiLang.translations

client = OpenAI(api_key=getenv("OPENAI_API_KEY"))

def get_translation(key: str) -> str:
    """
    Obtient la traduction pour une clé donnée basée sur la langue d'interface sélectionnée.
    """
    lang = st.session_state.get('interface_language', 'English')
    return translations.get(lang, {}).get(key, key)


def process_message(
    message: str,
    operation_prompt_: Optional[str] = "",
    system_prompt_: Optional[str] = ""
):
    """
    Traite les messages des utilisateurs et génère une réponse.

    Args:
        message (str): Le message d'entrée de l'utilisateur.
        operation_prompt (str, optional): Prompt supplémentaire pour l'opération. Par défaut "".
        tts_enabled (bool, optional): Si la synthèse vocale est activée. Par défaut False.

    """
    demorrha = DemorrhaAssistant()
    demorrha.load_assistant("Demorrha")
    demorrha.set_payload(f"{message}", f"{operation_prompt_}")

    st.session_state["full_response"] = "" 
    try:
        response_generator = demorrha.use_assistant()
        for response in response_generator:
            st.session_state.full_response = response
            yield st.session_state.full_response 
        
        # Utiliser regex pour supprimer les trois premiers et derniers guillemets doubles
        st.session_state.full_response = re.sub(r'^"{3}|"{3}$', '', st.session_state.full_response.strip())
        st.session_state.messages = [] 
        yield st.session_state.full_response
    except Exception as e:
        st.error(f"Une erreur s'est produite lors de la génération de la réponse : {e}")
        return ""    

# Function to configure the translation mode
def set_translation_mode(from_lang: str, dest_lang: str) -> Tuple[str, str]:
    """
    Configure les prompts globaux pour le mode de traduction.

    Args:
        from_lang (str): La langue source.
        dest_lang (str): La langue de destination.

    Returns:
        Tuple[str, str]: Un tuple contenant le prompt système et le prompt d'opération.
    """
    system_prompt_ = GlobalSystemPrompts.linguascribe()
    operation_prompt_ = f"Translate({from_lang} to {dest_lang})"
    return system_prompt_, operation_prompt_

def init_process_mode(
        from_lang: str,
        to_lang: str,
        process_mode: Optional[ Union[str, List[str]]] = "translator"
) -> Tuple[str, str]:
    """
    Initialise le mode de traitement pour la traduction si nécessaire.

    Returns:
        Tuple[str, str]: Un tuple contenant le prompt système et le prompt d'opération.
    """
    # from  (e.g.: st.session_state.language_detected)
    # dest  (e.g.: st.session_state.target_language)
    if "translator" in process_mode:
        system_prompt, operation_prompt = set_translation_mode(
            from_lang=f"{from_lang}",
            dest_lang=f"{to_lang}"
        )
        return system_prompt, operation_prompt
    return "", ""