#!/usr/bin/env python3
#coding:utf-8

from openai import OpenAI
from os import getenv
from typing import Optional
from typing import Union
from typing import Any
import re
import json
import datetime


SUPPORTED_LANGUAGES=[
    "Afrikaans", "Arabic", "Armenian", "Azerbaijani", "Belarusian", "Bosnian", "Bulgarian", "Catalan", "Chinese", "Croatian", "Czech", "Danish", "Dutch", "English", "Estonian", "Finnish", "French", "Galician", "German", "Greek", "Hebrew", "Hindi", "Hungarian", "Icelandic", "Indonesian", "Italian", "Japanese", "Kannada", "Kazakh", "Korean", "Latvian", "Lithuanian", "Macedonian", "Malay", "Marathi", "Maori", "Nepali", "Norwegian", "Persian", "Polish", "Portuguese", "Romanian", "Russian", "Serbian", "Slovak", "Slovenian", "Spanish", "Swahili", "Swedish", "Tagalog", "Tamil", "Thai", "Turkish", "Ukrainian", "Urdu", "Vietnamese", "Welsh"
]

SUPPORTED_LANGUAGES_FR_ = [
    "Afrikaans", "Arabe", "Arménien", "Azéri", "Biélorusse", "Bosniaque", "Bulgare", "Catalan", "Chinois", "Croate", "Tchèque", "Danois", "Néerlandais", "Anglais", "Estonien", "Finnois", "Français", "Galicien", "Allemand", "Grec", "Hébreu", "Hindi", "Hongrois", "Islandais", "Indonésien", "Italien", "Japonais", "Kannada", "Kazakh", "Coréen", "Letton", "Lituanien", "Macédonien", "Malais", "Marathi", "Maori", "Népalais", "Norvégien", "Persan", "Polonais", "Portugais", "Roumain", "Russe", "Serbe", "Slovaque", "Slovène", "Espagnol", "Swahili", "Suédois", "Tagalog", "Tamoul", "Thaï", "Turc", "Ukrainien", "Ourdou", "Vietnamien", "Gallois"
]


LANG__ = [ "English" ]

traductions_ui_dict = {
    "French": {
        "titre": "DEMORRHA APP - version 1",
        "entrez_message": "Entrez votre message ici:",
        "enregistrez_message": "Transcription audio :",
        "cliquez_enregistrer": "Capture Audio",
        "cliquez_arreter": "Arrêter",
        "cliquez_pause": "Pause",
        "langue_detectee": "Langue détectée : {}",
        "transcription": "Transcription : {}",
        "sidebar_titre": "DEMORRHA APP - v1",
        "a_propos": "À propos",
        "info_app": "Cette application utilise Streamlit et l'API d'OpenAI pour créer un chat interactif avec des modèles de langages avancés dans le but de fournir un outil permettant la communication entre les êtres humains.\nCet outil a pour objectif de montrer la voie dans un acte saint de la volonté de son auteur : \nAbattre les barrières linguistiques entre les hommes.",
        "selection_langue": "Sélection de la langue",
        "langues_destination": "Choisissez les langues de destination",
        "placeholder_langues": "Sélectionnez une à quatre langue(s)",
        "parametres_tts": "Paramètres Text-To-Speech",
        "choix_voix_tts": "Choisissez la voix de la synthese vocale",
        "activer_tts_texte": "Activer Text-To-Speech pour les entrées textuelles",
        "activer_tts_audio": "Activer Text-To-Speech pour les entrées audio",
        "erreur_fichier_non_trouve": "Erreur : Le fichier '{}' n'a pas été trouvé.",
        "erreur_lecture_fichier": "Une erreur s'est produite lors de la lecture du fichier : {}",
        "langue_interface": "Langue de l'interface",
        "choix_langue_interface": "Choisissez la langue de l'interface",
        "envoyer": "Envoyer",
        "effacer": "Effacer",
        "historique_conversation": "Historique de la conversation",
        "effacer_historique": "Effacer l'historique",
        "erreur_api": "Une erreur s'est produite lors de l'appel à l'API : {}",
        "erreur_traitement": "Une erreur s'est produite lors du traitement de votre message : {}",
        "erreur_tts": "Une erreur s'est produite lors de la génération du texte en parole : {}",
        "chargement": "Chargement en cours...",
        "aucun_message": "Aucun message pour le moment. Commencez la conversation !",
        "telecharger_audio": "Télécharger l'audio",
        "lecture_auto_tts": "Lecture audio automatique de la synthese vocale",
        "traitement_en_cours": "Traitement en cours...",
        "traitement_termine": "Traitement terminé !",
        "traduction_en_cours": "Traduction en cours...",
        "erreur_traduction": "Une erreur s'est produite lors de la traduction de votre message : {}",
        "traduction_terminee": "Traduction terminée !",
        "synthese_vocale_en_cours": "Synthèse vocale en cours...",
        "erreur_synthese_vocale": "Une erreur s'est produite lors de la synthèse vocale : {}",
        "synthese_vocale_terminee": "Synthèse vocale terminée !",
        "concatenation_audio_en_cours": "Concaténation audio en cours...",
        "erreur_concatenation_audio": "Une erreur s'est produite lors de la concaténation audio : {}",
        "concatenation_audio_terminee": "Concaténation audio terminée !",
        "transcription_audio_en_cours": "Transcription audio en cours...",
        "erreur_transcription_audio": "Une erreur s'est produite lors de la transcription audio : {}",
        "transcription_audio_terminee": "Transcription audio terminée !",
        "detection_langue_en_cours": "Détection de la langue en cours...",
        "erreur_detection_langue": "Une erreur s'est produite lors de la détection de la langue : {}",
        "detection_langue_terminee": "Détection de la langue terminée !",
        "transcription_audio": "Transcription audio : {}",
    	"confirmer" : "Confirmer",
	"Annuler" : "Annuler",
	"selection_de_la_langue": "Sélection de la langue",
	"choix_selection_langue": "Choisissez la langue de l'interface"
    }
}


def read_json_file(file_path: str) -> dict:
    with open(file_path, "r") as json_file:
        data = json.load(json_file)# hey copilot what is the type of data ? : dict
    return data

def write_json_file(file_path: str, data: Union[str, bytes, dict]) -> None:
    try:
        if type(data) == str:
            data = data.encode("utf-8")
        if type(data) == dict:
            data = json.dumps(data, indent=4, ensure_ascii=False, sort_keys=False).encode("utf-8")
        with open(file_path, "wb") as json_file:
            json_file.write(data)
            json_file.close()
    except Exception as e:
        raise e

def get_prompt_translation_ui_text(base_lang: str, 
                                    target_lang: str) -> str:
    prompt_ = "\n".join([
        f"Je souhaite que vous agissiez en tant que traducteur linguistique, correcteur d'orthographe et améliorateur.",
        f"Je vous donne un texte en {base_lang} et je vous demande de le traduire en {target_lang}. Puis répondez dans une version corrigée et améliorée de mon texte, dans la langue de destination.",
        f"Je souhaite que vous remplaciez mes mots et phrases par des termes et expressions les plus appropriés dans la langue de destination. Conservez le même sens, mais corrigez les fautes.",
        f"Je vous demande de ne répondre que par les corrections et améliorations, sans ajouter d'explications.",
        f"Lorsque je soumets un texte à traiter, je procéderai de la manière suivante pour délimiter le début et la fin du ou des blocs de texte que tu devras traiter : j'utiliserai trois caractères de guillemets doubles pour délimiter le début d'un bloc de texte à traiter ; j'utiliserai trois caractères de guillemets doubles pour délimiter la fin d'un bloc de texte à traiter. Le texte sera compris entre ces délimitations, que ce soit par format ou par taille du texte dans un bloc à traiter. Si mon texte est sur une seule ligne, il est possible que je place également les délimiteurs de début et de fin sur la même ligne.",
        f"Il est impératif que tu respectes le format d'origine au mieux ; donc, à moins qu'il soit absolument nécessaire de corriger le formatage, respecte au mieux ce détail. (Par exemple, tout en une ligne ou sur plusieurs... tu respectes le formatage d'origine. Par contre, tu peux, par exemple, corriger les espaces, tabulations et autres éléments superflus.)"
    ])
    return prompt_

def get_openai_connected_client():
    openai_client = OpenAI(api_key=getenv("OPENAI_API_KEY"))
    return openai_client

def create_chat_completion(client, 
                            system_prompt,
                            user_input,
                            model="gpt-4o-mini",
                            temperature=0.01,):
    response = client.chat.completions.create(
        model=f"{model}",
        temperature=temperature,
        messages=[
            {
                "role": "system",
                "content": f"{system_prompt}"
            },
            {
                "role": "user",
                "content": f"{user_input}"
            }
        ]
    )
    return response.choices[0].message.content

def remove_response_separator(response_text:str) -> str:
    # Utiliser un regex pour retirer les trois premières et dernières doubles quotes
    return re.sub(r'^"{3}|"{3}$', '', response_text.strip())


def translate_ui_template_string(file_path: str, 
                                 base_ui_lang: str, 
                                 target_ui_lang: str) -> str:
    openai_client = get_openai_connected_client()
    PROMPT_ = get_prompt_translation_ui_text(base_ui_lang, target_ui_lang)
    ui_lang_dict = read_json_file(file_path)
    traductions_ui_dict[target_ui_lang] = {}
    for key, text_ui in ui_lang_dict[base_ui_lang].items():
        operation_prompt = f"Translate(\'{base_ui_lang}\' to \'{target_ui_lang}\')"
        traduction_text_ui = remove_response_separator(
            create_chat_completion(
                openai_client, 
                PROMPT_, 
                f'{operation_prompt} :\n\"\"\"\n{text_ui}\n\"\"\"'
            )
        ).strip()
        traductions_ui_dict[target_ui_lang][key] = traduction_text_ui
    return json.dumps(traductions_ui_dict, indent=4, ensure_ascii=False, sort_keys=False)


def generate_ui_lang_support(
    base_ui_lang: Optional[str]   = "Français", 
    target_ui_lang: Optional[Union[str, list]] = SUPPORTED_LANGUAGES_FR_) -> str:
    
    global traductions_ui_dict
    # check if `base_ui_lang` is in `SUPPORTED_LANGUAGES`, if not raise an error
    #if base_ui_lang not in SUPPORTED_LANGUAGES:
    #    raise ValueError(f"La langue de l'interface {base_ui_lang} n'est pas supportée. Les langues supportées sont : {SUPPORTED_LANGUAGES}")

    # check if `target_ui_lang` is a list, if is a list, check if `base_ui_lang` is in the list, if true remove it from the list
    if list == type(target_ui_lang):
        if base_ui_lang in target_ui_lang:
            target_ui_lang.remove(base_ui_lang)
    elif str == type(target_ui_lang):
        if base_ui_lang == target_ui_lang:
            # raise an error if `base_ui_lang` is the same as `target_ui_lang`
            raise ValueError(f"La langue de l'interface {base_ui_lang} est la même que la langue de destination {target_ui_lang}. Veuillez choisir une autre langue de destination.")

    openai_client = get_openai_connected_client()
    
    cnt=0
    for to_lang in target_ui_lang:
        cnt += 1
        # print a progression message:  f"[{cnt}/{len(target_ui_lang)}] Translating UI text to {to_lang}..."
        # Colors like an hacker terminal, because it's cool !
        # {cnt} and {len(target_ui_lang)} are the current and total number of languages to translate , respectively in yellow FG and green FG.
        # '[' ']' are white FG 
        # {to_lang} is the language to translate in cyan FG
        # "Translating UI text to" is in light green FG
        print(f"\033[93m[{cnt}/{len(target_ui_lang)}]\033[0m \033[92mTranslating UI text to \033[0m\033[96m{to_lang}...\033[0m")
        PROMPT_ = get_prompt_translation_ui_text(base_ui_lang, to_lang)
        traductions_ui_dict[to_lang] = {}
        it_cnt=0
        for key, text_ui in traductions_ui_dict[base_ui_lang].items():
            it_cnt += 1
            # print a progression message:  f"  [{it_cnt}/{len(traductions_ui_dict[base_ui_lang].keys())}] + Translating UI text value of key '{key}'..."
            # Colors like an hacker terminal, because it's cool !
            # {it_cnt} and {len(traductions_ui_dict[base_ui_lang].keys())} are the current and total number of UI text values to translate , respectively in yellow FG and green FG.
            # '[' ']' are white FG
            # {key} is the key of the UI text value to translate in cyan FG
            # "Translating UI text value of key" is in light green FG
            print(f"  \033[93m[{it_cnt}/{len(traductions_ui_dict[base_ui_lang].keys())}]\033[0m \033[92mTranslating UI text value of key \033[0m\033[96m'{key}'...\033[0m")
            operation_prompt = f"Translate(\'{base_ui_lang}\' to \'{to_lang}\')"
            traduction_text_ui = remove_response_separator(
                create_chat_completion(
                    openai_client, 
                    PROMPT_, 
                    f'{operation_prompt} :\n\"\"\"\n{text_ui}\n\"\"\"'
                )
            ).strip()
            traductions_ui_dict[to_lang][key] = traduction_text_ui
        
    return json.dumps(traductions_ui_dict, indent=4, ensure_ascii=False, sort_keys=False)

def init_template_base_lang(file_path: str, 
                            base_ui_lang_dict: Optional[dict] = traductions_ui_dict) -> None:
    base_ui_lang = json.dumps(base_ui_lang_dict, indent=4, ensure_ascii=False, sort_keys=False).encode("utf-8")
    with open(f"/tmp/{file_path}.json", "wb") as json_file:
        json_file.write(base_ui_lang)
        json_file.close()

def read_template_base_lang(file_path: str) -> str:
    with open(f"/tmp/{file_path}.json", "rb") as json_file:
        bytes_data = json_file.read() 
        data = bytes_data.decode("utf-8")
    return data


if __name__ == "__main__":
    #init_template_base_lang("ui_lang_support_base_template", traductions_ui_dict)

    JSON_UI_LANG_SUPPORT = generate_ui_lang_support(
            base_ui_lang="French", 
            target_ui_lang=SUPPORTED_LANGUAGES
    )

    # encoding , fr_FR.UTF-8
    if type(JSON_UI_LANG_SUPPORT) == str:
        JSON_UI_LANG_SUPPORT = JSON_UI_LANG_SUPPORT.encode("utf-8")
    
    # timestamp string format : "MM-DD-YYYY_HH-MM-SS"
    timestamp = datetime.datetime.now().strftime("%m-%d-%Y_%H-%M-%S")
    with open(f"ui_lang_support_{timestamp}.json", "wb") as output_file:
        output_file.write(JSON_UI_LANG_SUPPORT)
        output_file.close()

    # print GREEN FG : "Success and Done !" message
    print("\033[92mSuccess and Done !\033[0m")
    exit(0)