# inc/infos.py

import cfg
import inc.chaines as chaines
from threading import Thread

LOC_LG_FRANCAIS = "francais"    # doit être égal au LG_FRANCAIS de cfg.py

# init_module():
# dossier de travail, ... """
# peut-être à déplacer plus haut, carrément dans jukebox.py
import subprocess
cmd = "[ -d /m/music/pico2wave ] || mkdir /m/music/pico2wave"
ps = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)


def change_lang():
    """ change la langue globalement """
    arr_msg = [ "", "1 francais, 2 anglais, 3 allemand, 0 annuler"]
    pdrNew(arr_msg)
    new_language = input("")
    langages = {
        "1": "fr-FR",
        "2": "en-GB",
        "3": "de-DE"
    }
    # voir aussi Python switch case - JournalDev, https://www.journaldev.com/15642/python-switch-case
    if new_language in langages.keys():
        ini_set("py_pico_lang", langages.get(new_language))


def color_text(s):
    """ colorer/surligner du texte en fonction du module en cours """
    couleurs = {
        "juk": "31",
        "aba": "32", "abk": "33", "abw": "34",
        "rad": "35", "rec": "36", "zik": "37"
    }
    curr_mod = ini_get("py_current_module")
    if curr_mod in couleurs.keys():
        code_couleur = couleurs.get(curr_mod)
        return '\x1b[0;' + code_couleur + ';40m' + s + '\x1b[0m'
    else:
        return s


def color_text_table():
    """ prints table of formatted text format options """
    # https://stackoverflow.com/questions/287871/how-to-print-colored-text-in-terminal-in-python
    for style in range(8):
        for fg in range(30,38):
            s1 = ''
            for bg in range(40,48):
                format = ';'.join([str(style), str(fg), str(bg)])
                s1 += '\x1b[%sm %s \x1b[0m' % (format, format)
            print(s1)
        print('\n')

##############################################
#                class Dire                  #
##############################################
from threading import Thread
class Dire(Thread):
    """ Thread chargé de prononcer, en arrière-plan,
        les messages les uns après les autres.
        Un message peut être interrompu pendant sa lecture,
        le suivant, s'il existe, doit alors débuter juste après
    """
    # thread à lancer dès le démarrage du module jukebox
    def __init__(self):
        # ~ print("Lancement du thread Dire ...")
        Thread.__init__(self)
        # TODO
        # contrôler que le dossier est bien présent pour lancer le thread

    def run(self):
        """Code à exécuter pendant l'exécution du thread."""
        import inc.mpc as mpc
        import mod.commun as commun
        import inc.infos as infos
        while True:
            # rechercher les fichiers à prononcer toutes les secondes
            commun.faire_pause(1)
            cmd = "ls -1 {}/*txt 2> /dev/null".format(cfg.DIRE_FILE_ATTENTE)
            str_liste_textes = mpc.sub_proc(cmd)

            # si fichiers à prononcer présents
            if len(str_liste_textes) > 10:
                list_prononcer = str_liste_textes.split("\n")
                n_prononcer = 0
                # afficher tous les .txt présents
                for nom_fichier in list_prononcer:
                    n_prononcer += 1
                    masque = "DEBUG prononcer en attente, {} sur {} {}"
                    msg = masque.format(n_prononcer, len(list_prononcer), nom_fichier)
                    log(msg)

                # prononcer seulement le premier fichier de list_prononcer
                fichier_prononcer = list_prononcer[0]
                with open(fichier_prononcer, "r") as fp:
                    texte = fp.read().strip()
                wav = cfg.WAV_WAV

                # inscrire dans le fichier qch comme :
                # de-DE|sagen sie etwas hier bitte
                # fr-FR|les chaussettes de l'archiduchesse sont-elles  sèches, oui archi sèches
                # ...
                langue_texte = texte.split("|")
                if len(langue_texte) == 2:
                    langue_langue = langue_texte[0]
                    texte = langue_texte[1]
                else:
                    langue_langue = cfg.LG_FRANCAIS

                langue_pico = "fr-FR"   # par défaut
                if langue_langue == cfg.LG_FRANCAIS:
                    langue_pico = "fr-FR"
                elif langue_langue == cfg.LG_ANGLAIS:
                    langue_pico = "en-GB"
                elif langue_langue == cfg.LG_ALLEMAND:
                    langue_pico = "de-DE"

                # créer fichier wave tts
                # langue_pico et texte ne doivent pas être entourés de guillemets
                cmd = 'pico2wave -l ' + langue_pico + ' -w ' + wav + ' "' + texte + '"'
                log(cmd)
                mpc.sub_proc(cmd)

                # jouer wav
                if mpc.is_playing():
                    mpc.pause()
                    cmd = "aplay -q " + wav
                    log(cmd)
                    mpc.sub_proc(cmd)
                    mpc.toggle()
                else:
                    cmd = "aplay -q " + wav
                    log(cmd)
                    mpc.sub_proc(cmd)

                # supprimer fichier texte
                cmd = "rm " + fichier_prononcer
                log(cmd)
                mpc.sub_proc(cmd)


            # on quitte le thread
            if file_exists("/m/quitter_dire"):
                infos.m_g("*** fin thread Dire")
                cmd = "rm {}/*txt".format(cfg.DIRE_FILE_ATTENTE)
                mpc.sub_proc(cmd)
                cmd = "rm /m/quitter_dire"
                mpc.sub_proc(cmd)
                break


DEV_lancer_thread = True
if DEV_lancer_thread == True:
    thread_dire = Dire()
    # Lancement des threads
    thread_dire.start()


def dis_sh(texte, pauses = None, langue = LOC_LG_FRANCAIS):
    """ crée un nouveau fichier à prononcer pour Dire
        dans le dossier cfg.DIRE_FILE_ATTENTE
        le fichier devra arriver en dernière position
        d'une commande ls -1 .../*txt | sort
        solution : utiliser un horodatage
    """
    # test avec multithreading pour pouvoir interrompre dès qu'une touche est tapée
    from datetime import datetime
    now = datetime.now()
    date_fichier = now.strftime("%H%M%S.%f")  # 121940.948000
    fichier = cfg.DIRE_FILE_ATTENTE + "/" + date_fichier + ".txt"
    log("dis_sh crée le fichier " + fichier)
    with open(fichier, "w") as fp:
        fp.write(langue + '|' + texte)


def file_exists(fichier):
    """ teste existence d'un fichier/dossier """
    from os import path
    return path.isfile(fichier)


def heure_actu():
    """ renvoie heure au format HH:MM:SS """
    # https://stackoverflow.com/questions/415511/how-to-get-the-current-time-in-python
    from time import localtime, strftime
    # return strftime("%Y-%m-%d %H:%M:%S", localtime())
    return strftime("%H:%M:%S", localtime())


def ini_file_get(ini_file, var_ini, default):
    """ retourne la valeur de var_ini dans le fichier ini_file
        les lignes de données sont du type :
        variable=valeur
    """
    if file_exists(ini_file) == False:
        return default

    with open(ini_file, "r") as fileIni:
        les_lignes = fileIni.readlines()
    for ligne in les_lignes:
        if ligne.startswith(var_ini + "="):
            valeur = ligne.split("=")[1].strip()
            if valeur != "":
                return valeur
    return default


def ini_get(var_ini, default = None):
    """ renvoie la valeur de var_ini dans cfg.CONFIG_INI """
    rrr = ini_file_get(cfg.CONFIG_INI, var_ini, default)
    # ~ print("rrr {} = {}".format(var_ini, rrr))
    return rrr


def ini_file_set(ini_file, var_ini, valeur):
    """ enregistre la valeur de la variable donnée
        dans ini_file
        met à jour une variable existante,
        ou crée la ligne pour cette variable
        les lignes sont du type :
        variable=valeur
        ex :
        biblio_actuelle=cle_usb
    """
    if file_exists(ini_file) == True:
        var_ini_found = False
        # stocker toutes les lignes dans les_lignes[]
        with open(ini_file, "r") as fileIni:
            les_lignes = fileIni.readlines()
        new_lignes = []
        for ligne in les_lignes:
            if ligne.startswith(var_ini + "="):
                var_ini_found = True
                new_lignes.append(var_ini + "=" + str(valeur))
            else:
                new_lignes.append(ligne)
        if not var_ini_found:
            new_lignes.append(var_ini + "=" + str(valeur))

        # tout réenregistrer dans le fichier ini
        # (même si valeur inchangée)
        with open(ini_file, "w") as fileIni:
            for ligne in new_lignes:
                if ligne.endswith("\n"):
                    fileIni.write(ligne)
                else:
                    fileIni.write(ligne + "\n")
    else:
        with open(ini_file, "w") as fileIni:
            fileIni.write(str(var_ini) + "=" + str(valeur))


def ini_set(var_ini, valeur):
    """ enregistre la valeur de la variable donnée
        dans cfg.CONFIG_INI """
    ini_file_set(cfg.CONFIG_INI, var_ini, valeur)


def jour_heure_actu():
    """ date/heure du type 2020-01-22 12:37:55 """
    from time import localtime, strftime
    return strftime("%Y-%m-%d %H:%M:%S", localtime())


def m_g(ligne):
    """ affiche des informations pour voyants et développeur """
    # ex :
    # 11:45:15 [rad] (voc2) rad_infos_go (), vous écoutez France Inter
    # 15:05:02 [juk] (voc0) Raspberry Pi 3 Model B Rev 1.2, 948M, gpu=76M
    module_couleur = ini_get("py_current_module", "juk")
    module_couleur = color_text(module_couleur)
    print("{} [{}{}] {}".format(heure_actu(), module_couleur, niveau_aide_voc(), ligne))


def g_m(ligne):
    """ affiche des informations pour voyants et développeur, mode debug """
    # ex :
    # 11:45:15 [rad] (voc2) rad_infos_go (), vous écoutez France Inter
    # 15:05:02 [juk] (voc0) Raspberry Pi 3 Model B Rev 1.2, 948M, gpu=76M
    module_couleur = ini_get("py_current_module", "juk")
    module_couleur = color_text(module_couleur)
    # ~ print("{} [{}] (voc{}) {}".format(heure_actu(), module_couleur, niveau_aide_voc(), ligne))


def log(text):
    """ journaliser les actions dans fichiers log
    """
    pass


def niveau_aide_voc():
    """ renvoie niveau aide sonore """
    return int(ini_get("py_niv_aide_voc", cfg.NIV_AIDE_VOC_DEFAULT))


def pdrNew(txt, langue = LOC_LG_FRANCAIS):
    """ prononce le texte en fonction du niveau d'aide actuel
        txt contient le texte des 4 niveaux
        S'il n'y a que deux éléments,
        on prononce le premier texte pour les niveaux 0 et 1,
        on prononce le second pour les niveaux 2 et 3

        txt : string, ou list de string à 2 ou 4 éléments,
    """
    # devra remplacer les fonctions pdr_...
    if isinstance(txt, str):
        arr_new = [ txt, txt, txt, txt ]
    elif isinstance(txt, list):
        if len(txt) == 2:
            arr_new = [ txt[0], txt[0], txt[1], txt[1] ]
        else:
            arr_new = list(txt)
    un_texte = arr_new[niveau_aide_voc()]
    if un_texte == "":
        m_g("(muet) " + arr_new[1]) # on suppose que arr_new[1] est non vide
    else:
        pdr_always(un_texte, langue)


def pdr_always(texte, langue = LOC_LG_FRANCAIS):
    """ toujours prononcer le texte """
    # à remplacer par pdr_0123()
    import inc.mpc
    m_g(texte)
    if inc.mpc.is_playing():
        dis_sh(texte, "pauses", langue)
    else:
        dis_sh(texte, "", langue)