# mod/rad.py

import cfg
import inc.infos as infos
import inc.mpc as mpc
import mod.commun as commun

groups_radio = ("rad_group1.m3u",
                 "rad_group2.m3u",
                 "rad_group3.m3u")
# REC_RAW = "/m/music/rec/raw/"
# REC_RAW_REL = "rec/raw/"


def charger_les_stations():
    """ Copie les fichiers playlists dans /m/playlists """
    # https://www.geeksforgeeks.org/python-shutil-copyfile-method/
    # import os
    import shutil

    src_dir = "/opt/jk2019/conf/m_sur_clef_usb/playlists"
    dst_dir = "/m/playlists"

    # vérif clé usb montée
    if commun.m_is_mounted() == False:
        infos.m_g("ERR : /dev/sda1 n'est pas monté sur /m")
        infos.pdrNew("Problème, la clé u s b ne semble pas reconnue")
        return False

    # vérif dossier /m/playlists existe
    if not commun.dir_exists(dst_dir):
        commun.make_dir(dst_dir)
        infos.pdrNew("Dossier playliste absent, création en cours")
        commun.faire_pause(3)
    if not commun.dir_exists(dst_dir):
        infos.pdrNew("Problème lors de la création du dossier playliste")
        return False
    else:
        # infos.pdrNew("Dossier créé avec succès.")
        commun.faire_pause(3)

    global groups_radio
    # Copies, si nécessaire, des fichiers playlist dans dst_dir
    for i in (range(3)):
        f = groups_radio[i]
        source = src_dir + "/" + f
        destin = dst_dir + "/" + f
        # 1. comparer les deux fichiers s'ils existent
        with open(source, "r") as s1:
            contenu_s1 = s1.read()
        if commun.file_exists(destin):
            with open(destin, "r") as s2:
                contenu_s2 = s2.read()
        else:
            contenu_s2 = ""

        # 2. copier si contenus différents ou destin absent
        if not contenu_s1 == contenu_s2:
            shutil.copyfile(source, destin)
            infos.m_g("copie de {} vers {}".format(source, destin))


# def demarre_radio():
    # """ lance la radio et reprend """
    # infos.m_g("*** module Radio ***")
    # charger_les_stations()


def enregistrements_ecouter(aleatoire = ""):
    """ enregistrer la radio écoutée actuellement
        20200608 : abandon du module rec.py
        on écoute directement les enregistrements depuis la module radio
    """
    # 1. vider playlist
    mpc.clear()
    mpc.ferme_ton_clapet()
    # 2. charger dossier music/rec/raw
    # mpc.add("https://raw.githubusercontent.com/anars/blank-audio/master/5-seconds-of-silence.mp3")
    mpc.add(cfg.REC_RAW_REL)
    infos.pdrNew(["", "écoute de vos " + str(mpc.playlist_longueur()) + " enregistrements radio"])
    # 3. mettre en mode pas random
    if aleatoire == "aleatoire":
        mpc.random_on()
    else:
        mpc.random_off()
    # 3. démarre depuis le début
    # mpc.sub_proc("mpc -q del 1")
    infos.pdrNew(["", "Appuyez sur 88 pour effacer définitivement le morceau en cours"])
    mpc.play()
    # infos.pdrNew(["", "Appuyez sur 99 pour archiver le morceau en cours"])


def enregistrements_ecouter_alea():
    """ écouter les enregistrements dans désordre
    """
    enregistrements_ecouter_alea("aleatoire")


def enreg_suppr():
    """ supprime le fichier .mp3 enregistrement en cours
    """
    # 1. mpc del 0 pour supprimer de la playliste
    # 2. rm /m/music/rec/raw/fichier_en_cours.mp3
    # on ne peut pas supprimer un flux http !
    # mpc_file = http://radiofg.impek.com/fg
    # mpc.mpc_file() renvoie une string du type :
    # rec/raw/enregistrement_du_20200125_11h34m10s_180s_Deutschlandfunk.mp3

    # TODO : annoncer combien il reste d'enregistrements
    # TODO : possibilité renommer un fichier (1 = A, 2 = B, ...)
    del_file = " /m/music/" + mpc.mpc_file()
    infos.m_g("suppression du fichier " + del_file)
    mpc.sub_proc("rm " + del_file)          # supprime le fichier physiquement
    mpc.sub_proc("mpc -q del 0")            # supprime la chanson en cours de la playlist


def enregistrer_station(duree):
    """ enregistrer la radio écoutée actuellement """
    url = station_en_ecoute()

    if url.startswith("http"):
        nom_station = nom_usuel(url)
        # vérifier qu'on écoute bien une radio actuellement
        infos.m_g("on enregistre 3 minutes de la station [" + infos.color_text(nom_station) + "]")
        r = save_to_usb(url, nom_station, duree)
    else:
        infos.pdrNew("aucune radio en écoute actuellement")


def get_rad_group():
    """ renvoie le groupe de radios en cours """
    return infos.ini_get("rad_group", "1")


def get_rad_position():
    """ renvoie la position dans la playliste actuelle """
    group_en_cours = get_rad_group()
    return infos.ini_get("rad_position_dans_group_" + group_en_cours, "1")


def group1():
    """ lancer groupe radios 1 """
    group_n(1)


def group2():
    """ lancer groupe radios 2, musique """
    group_n(2)


def group3():
    """ lancer groupe radios 3, étrangères """
    group_n(3)


def group_n(n):
    """ lance un groupe de radios, ordonnées
        en reprenant la dernière station lue dans ce groupe,
        si elle a été mémorisée et si elle est valide
        sinon, on prend la première station du groupe
    """
    mpc.ferme_ton_clapet()
    grp = str(n)
    infos.ini_set("rad_group", grp)
    mpc.clear()
    mpc.random_off()
    mpc.load("rad_group" + grp)
    grpo = get_rad_position()
    # quand on écoute les fichiers enregistrés, le dernier morceau mémorisé
    # peut être hors limite
    if grpo <= mpc.playlist_longueur():
        mpc.play(get_rad_position())
    else:
        mpc.play()
    rad_infos_go()


def memo_stop_module():
    """ quitter module (touche 0) : mémoriser où on est """
    # on ne mémorise plus rien ici,
    # la mémo se fait dès qu'on lance une radio,
    # ou qu'on passe à la station suivante/précédente
    # càd dans ...
    pass


def menu_voc11():
    """ menu spécial rad """
    commun.menu_vocal("rad_special11", "radio")


def nom_usuel(url):
    """ renvoie le nom de la station en cours """
    # ALLRADIOS :
    # Deutschlandfunk         |http://st01.dlf.de/dlf/01/128/mp3/stream.mp3              |de|
    # Deutschlandfunk Kultur  |http://st02.dlf.de/dlf/02/128/mp3/stream.mp3              |de|
    # ...                     |http...

    # station en cours
    if url.startswith("http"):
        with open(cfg.ALL_RADIOS, "r") as fileIni:
            les_stations = fileIni.readlines()
        col_nom = 0
        col_url = 1
        retour = ""
        for ligne_station in les_stations:
            atome = ligne_station.split("|")
            if url == atome[col_url].strip():
                retour = atome[col_nom].strip()
                break
    else:
        infos.m_g("[nom_usuel()] url trouvée : " + url)
        retour = "ERR: url ne commence pas par http"

    return retour


def pausepub():
    """ pour éviter les pubs auto, supermarché, ... """
    infos.m_g("EN COURS, rad pausepub")


def pausepub2():
    """ pause pub 2 minutes """
    infos.m_g("EN COURS, rad pausepub 2mn")


def programmer_rec():
    """ programmer heure et durée précises enregistrement """
    infos.m_g("EN COURS rad, programmer_rec")


def prev_trk():
    """ station précédente """
    mpc.prev_trk()
    save_rad_position()
    rad_infos_go()


def next_trk():
    """ station suivante """
    mpc.next_trk()
    save_rad_position()
    rad_infos_go()


def rad_infos_go():
    """ informer à chaque ouverture d'une station """
    url = station_en_ecoute()
    nom_station = nom_usuel(url)
    if nom_station.startswith("ERR"):
        arr_msg = ["", "", "", ""]
        infos.pdrNew(arr_msg)
    else:
        arr_msg = ["", nom_station, nom_station, nom_station]
        infos.pdrNew(arr_msg)


def rad_fav1():
    """ enregistre 3 minutes la station en écoute """
    enregistrer_station("180")


def rad_fav2():
    """ enregistre 30 minutes la station en écoute """
    enregistrer_station("1800")


def rad_fav3():
    infos.m_g("Programmer un enregistrement")


def rad_fav_n():
    pass


def rad_nfo():  # infos fournies à définir
    pass


def rad_nfo1():
    """ prononcer le nom usuel de la radio en cours """
    msg = "vous écoutez " + nom_usuel(station_en_ecoute())
    infos.pdrNew(msg)


def rad_nfo2():
    """ vous écoutez la station 3 du groupe 1 """
    msg = "vous écoutez la station " + get_rad_position()
    msg += " du groupe " + get_rad_group()
    infos.pdrNew(msg)


def rad_nfo3():     # nombre de stations dans le groupe et leur nom, ou bien name of the radio station
    """ message long pour test de lecture dans un thread """
    # cf class Dire_dire() dans infos.py
    msg = "message long, nombre de stations dans le groupe et leur nom, "
    msg += "ou bien nom de la station en anglais"
    infos.pdrNew(msg)


def rebours():
    """ Programmer un arrêt de module """
    infos.m_g("Programmer un arrêt de la radio")


def rec_xxxx_sec():  # enregistrer avec paramètres (variables globales)
    pass


def records():
    """ voir les enregistrements passés et en cours """
    # global REC_RAW
    infos.m_g("ls -l " + cfg.REC_RAW)
    r = mpc.sub_proc("ls -l " + cfg.REC_RAW)
    print(r)
    # ~ infos.m_g("voir les enregistrements en cours ")


def reprendre():
    """ on reprend le groupe et la station quittés """
    # à chaque reprise, comparer les fichiers playlists dans /m/playlists
    # et les copies maîtres du dossier /opt/jk2019/conf/m_sur_clef_usb/playlists
    # les copier un par un si différent
    mpc.ferme_ton_clapet()
    msg = "lancement de la radio"
    infos.pdrNew(["", msg, msg, msg])

    # pause de 2s
    commun.faire_pause(3, True)
    infos.ini_set("py_current_module", "rad")
    infos.ini_set("mode_consultation", "off")

    if charger_les_stations() == False:
        infos.pdrNew("Problème au chargement des stations radio")
        return False
    group_en_cours = get_rad_group()

    # options de lecture
    # inutilisé pour l'instant (à l'avenir envisager mémoriser volume sonore par station ?)
    # 1|2|volume: 98%   repeat: off   random: off   single: off   consume: off
    # options_de_lecture = split_ligne[2]
    # commenter ci-dessous pour ne pas reprendre_directement la radio
    group_n(group_en_cours)


def save_rad_position():
    """ enregistre la position dans la playliste actuelle """
    # TODO : ne pas enregistrer la position quand on écoute les enregistrements
    group_en_cours = get_rad_group()
    infos.ini_set("rad_position_dans_group_" + str(group_en_cours), str(mpc.playlist_position()))


def save_to_usb(url, nom_station, duree):
    """ le shell enregistre flux webradio en direct pendant une durée
        déterminée """
    def horodater():
        """ renvoie chaîne du type """
        import datetime
        x = datetime.datetime.now()
        return x.strftime("%Y%m%d_%Hh%Mm%Ss")

    # local :
    # /home/pi/Documents/tmp/jk2020/save_to_usb.sh
    # infos.m_g("rad save_to_usb ({}, {}, {})".format(url, nom_station, duree))

    # vérif dossier enregistrements
    if not commun.dir_exists(cfg.REC_RAW):
        commun.make_dir(cfg.REC_RAW)
    if not commun.dir_exists(cfg.REC_RAW):
        infos.pdrNew("Problème lors de la création du dossier des enregistrements")
        commun.faire_pause(3)
        return False

    nom_sans_espace = nom_station.replace(" ", "_")
    # r_datetime = "2020-01-24_09h12mn07s"  # r_ signifie radical
    r_datetime = horodater() + "_"
    r_duree = duree + "s_"
    r_prefixe = "enregistrement_du_"
    radical_mp3 = r_prefixe + r_datetime + r_duree + nom_sans_espace

    import random
    nombre_unique = "rand" + str(random.randint(1000, 9999))

    # shell_file = cfg.REC_RAW + nom_sans_espace + "." + r_datetime + nombre_unique + ".sh"
    shell_file = "/tmp/" + nom_sans_espace + "." + r_datetime + nombre_unique + ".sh"
    with open(shell_file, "w") as sh_file:
        sh_file.write("cd /m/music/rec/raw" + "\n")
        sh_file.write("    mp3=" + radical_mp3 + "_EN_COURS.mp3" + "\n")
        sh_file.write("mp3fini=" + radical_mp3 + ".mp3" + "\n")
        sh_file.write("url=" + url + "\n")
        sh_file.write("pidfile=${mp3}.pid" + "\n")
        sh_file.write("" + "\n")
        sh_file.write("# enregistrement local avec mplayer" + "\n")

        nice_mplayer = "nice mplayer -quiet -dumpfile ${mp3} -dumpstream ${url}"
        sh_file.write("echo " + nice_mplayer + " ..." + "\n")
        sh_file.write(nice_mplayer + " >/dev/null 2>&1 &" + "\n")

        sh_file.write("" + "\n")
        sh_file.write("echo $! > ${pidfile}" + "\n")
        sh_file.write("sleep 180; kill $(cat ${pidfile})  # killer mplayer après durée enregistrement" + "\n")
        sh_file.write("rm ${pidfile}" + "\n")

        nice_eyed3 = "nice eyeD3 -t " + nom_sans_espace + " ${mp3}"
        sh_file.write("echo " + nice_eyed3 + "\n")
        sh_file.write(nice_eyed3 + " > /dev/null    # taguer id3" + "\n")

        sh_file.write("nice sudo chmod 777 ${mp3}" + "\n")
        sh_file.write("mv ${mp3} ${mp3fini}" + "\n")
        sh_file.write("nice rm " + shell_file + "\n")

    infos.m_g("rad save_to_usb : " + shell_file)
    infos.m_g("rad save_to_usb : " + radical_mp3 + ".mp3 va être créé")
    infos.m_g("taper *9 pour voir les enregistrements en cours")
    # mpc.sub_proc("cat " + shell_file)
    mpc.sub_proc("chmod +x " + shell_file)
    mpc.sub_proc_bg(shell_file)


def station_en_ecoute():
    """ renvoie l'url de la radio en écoute actuellement """
    # prévoir les toggle(), stop() ou playlist vides, ...
    url = mpc.sub_proc("mpc -f %file% | head -1")
    return url


def stop():
    """ arrête la lecture des radios """
    infos.m_g("rad, stop")
    mpc.stop()


def taches_courantes():  # aide module succincte
    pass


def toggle():
    """ bascule lecture des radios """
    infos.m_g("rad, toggle")
    mpc.toggle()


def trk_first():
    """ aller à la première station de la liste """
    if mpc.trk_first():
        save_rad_position()
        rad_infos_go()


def trk_last():
    """ aller à la dernière station de la liste """
    if mpc.trk_last():
        save_rad_position()
        rad_infos_go()


def verifier_playlists_radios():
    """ vérifie la présence des playlists dans /m/playlists """
    # utiliser charger_les_stations() si fichiers absents ou différents
    pass


if __name__ == "__main__":
    print("Bienvenue dans le module rad (webradios)")