# coding: utf8
import random
import re
import copy
import configparser
import io
import signal
import sys
import pickle
import time

from matrix_bot_api.matrix_bot_api import MatrixBotAPI
from matrix_bot_api.mregex_handler import MRegexHandler
from matrix_bot_api.mcommand_handler import MCommandHandler
from matrix_client.client import MatrixClient

# Version initiale par Philippe Depriester et Clement Gauche

cartes_base = ["As de carreau", "2 de carreau", "3 de carreau", "4 de carreau", "5 de carreau", "6 de carreau", \
"7 de carreau", "8 de carreau", "9 de carreau", "10 de carreau", "Valet de carreau", "Dame de carreau", \
"Roi de carreau", "As de coeur", "2 de coeur", "3 de coeur", "4 de coeur", "5 de coeur", "6 de coeur", \
"7 de coeur", "8 de coeur", "9 de coeur", "10 de coeur", "Valet de coeur", "Dame de coeur", "Roi de coeur", \
"As de pique", "2 de pique", "3 de pique", "4 de pique", "5 de pique", "6 de pique", "7 de pique", "8 de pique", \
"9 de pique", "10 de pique", "Valet de pique", "Dame de pique", "Roi de pique", "As de trefle", "2 de trefle", \
"3 de trefle", "4 de trefle", "5 de trefle", "6 de trefle", "7 de trefle", "8 de trefle", "9 de trefle", \
"10 de trefle", "Valet de trefle", "Dame de trefle", "Roi de trefle", "Joker rouge", "Joker noir"]
cartes=list(cartes_base)
bot = None
clock = {}

def horloge_read():
    global clock
    try:
        with open("horloge", "rb") as fichier:
            loader = pickle.Unpickler(fichier)
            clock = loader.load()
    except:
        clock = {}
	
def signal_handler(signal, frame):
    with open("horloge", "wb") as fichier:
        saver = pickle.Pickler(fichier)
        saver.dump(clock)
    sys.exit(0)


class Parser: #Pour parser la ligne de commande
    def __init__(self, str, nick, room):
        self._str = str.strip()
        self._nick = nick
        self._old = ""
        self._mtch = ""
        self._room = room
        self._arg = {}
        self._option = [False,False,False,0,0,0,0,0,False,0,0]

    @property
    def str(self):
        return self._str

    @str.setter
    def str(self, str):
        self._str = str

    @property
    def nick(self):
        return self._nick

    @nick.setter
    def nick(self, nick):
        self._nick = nick

    @property
    def old(self):
        return self._old

    @old.setter
    def old(self, old):
        self._old = old

    @property
    def mtch(self):
        return self._mtch

    @mtch.setter
    def mtch(self, mtch):
        self._mtch = mtch

    @property
    def room(self):
        return self._room

    @room.setter
    def room(self, room):
        self._room = room

    @property
    def arg(self):
        return self._arg

    @arg.setter
    def arg(self, arg):
        self._arg = arg

    @property
    def option(self):
        return self._option

    @option.setter
    def option(self, option):
        self._option = option

    def space(self):
        if (re.match("^\s", self._str) or re.match("^$", self._str)):
            return True
        else:
            return False

    def restaure(self):
        self._str += self._mtch
        self._old

    def eat(self,mtch,opt):
        pattern=r"^(\s*)(" + mtch + r")(.*)"
        if (re.match(pattern,self._str)):
            if (opt == 1):
                self._mtch = re.sub(pattern,r"\2",self._str)
                self._old += re.sub(pattern,r"\1\2",self._str)
                self._str = re.sub(pattern,r"\3",self._str)
            return True
        return False

def getNick(room, event):
    members = room.get_joined_members()
    nick = ""
    try:
        #nick = members[event['sender']]['displayname']
        nick = [user.get_friendly_name() for user in members if user.user_id == event['sender']][0]
    except:
        nick = "Voisin du dessus"
    return(nick)
        
def card(room, event):
    room.send_text(cartes_base[random.randrange(0,len(cartes_base))])

def carte(room, event):
    global cartes
    args = event['content']['body'].split()
    if (len(args) > 1):
        cartes=list(cartes_base)
        room.send_text("Le paquet est melange")
    else:
        if (len(cartes) < 1):
            cartes=list(cartes_base)
            room.send_text("Le paquet est melange")
        i = random.randrange(0,len(cartes))
        room.send_text(cartes[i])
        cartes.pop(i)

def help(room, event):
    args = event['content']['body'].split()
    args.pop(0)
    if (len(args) > 0):
        if (re.search("roll", args[0])):
            room.send_text(":roll <options> <des> (+-modifs ou des)\n\n- exemple :roll vr4g3 6d6 - \#g\#r3d6 +2 x3 : lance avec les details 6d6 en relancant les des avec un resultat de 4+ et en gardant les trois meilleurs, puis en retranchant 3d6 sans relancer les 4+ et en gardant tout, enfin ajouter 2. L'operation sera executee trois fois.\n\n- v : details (verbose) du jet\n- n : no add, chaque de est traite separement\n- e : explosif, si un de fait le maximum, on le relance et on additionne\n- f<nb> : difficulte a atteindre par de avec option n\n- g<nb> : nombre de des conserves\n- r<nb> : relance si le de a obtenu au moins ce nombre\n- m<nb> : Enleve un succes si ce nombre ou moins est atteint\n- s<nb/nb> : seuil a atteindre et niveaux de reussites\n- w<nb> : lance un wild die avec les autres.")
        elif (re.search("sw", args[0])):
            room.send_text("- :sw <options> <des> : Lance les des en mode Savage Worlds\nVerbose/Noadd/Explosif/Seuil 4/Niveau de reussite 4/Wild Die d6.")
        elif (re.search("dom", args[0])):
            room.send_text("- :dom <options> <des> : Lance les dommages en mode Savage Worlds\nVerbose/Explosif/seuil 4/Niveau de reussite 4.")
        elif (re.search("owod", args[0])):
            room.send_text("- :owod <options> <des> : Lance les des en mode Ancien Monde des Tenebres\nVerbose/Noadd/Difficulte 6/Relance les 10/Les 1 enleve un succes.")
        elif (re.search("wod", args[0])):
            room.send_text("- :wod <options> <des> : Lance les des en mode Nouveau Monde des Tenebres\nVerbose/Noadd/Difficulte 8/Relance les 10.")
        elif (re.search("ars", args[0])):
            room.send_text("- :ars <options> <des> : Lance les des en mode Ars Magicka : de de tension\nVerbose/Noadd/Sur un 1, on relance et on double.")
        elif (re.search("des", args[0])):
            room.send_text("- :des <options> <des> : Lance des des de desastre\nVerbose/Noadd/Difficulte 10.")
        elif (re.search("carte", args[0])):
            room.send_text("- !carte : Tire une carte et la retire du paquet\n- !carte m : remelange le paquet.")
        elif (re.search("card", args[0])):
            room.send_text("- !card : tire une carte sans la retirer du paquet.")
        elif (re.search("liste", args[0])):
            room.send_text("- !liste <options/de/la/liste> [Nombre d'elements souhaites] : retourne ce nombre d'elements de la liste.")
        elif (re.search("horloge", args[0])):
            room.send_text("- !horloge : Affiche les horloges\n- !horloge <Nom de l'horloge> <niveau> : Crée ou modifie une horloge en lui mettant un niveau (normalement de 0 à 6)\n- !horloge del <Nom de l'horloge> : Supprime cette horloge.")
        else:
            room.send_text("A venir")
    else:
        room.send_text("Commandes disponibles:\n- !card\n- !carte\n- !liste <options/de/la/liste> [Nombre d'elements souhaites]\n- !horloge : gestion des horloges PBTA\n- :roll <options> <des>\n- :sw <options> <des>\n- :dom <options> <des>\n- :wod <options> <des>\n- :owod <options> <des>\n- :ars <options> <des>\n- :des <options> <des>\n\n- Pour plus de details, tapez !help <commande>\n\nRetrouvez Asmodee sur https://git.ombreport.info/nemesis/asmodee_matrix")

def roll(result,type,explosif,nb,f,noadd,ars,relance,mitige):
    # verif type et contenu params?
    roll = 0
    new = 0
    moins = 0
    if (ars):
        roll = 1
        if (type > 1):
            tmp = 1
            while (ars and tmp == 1):
                roll *= 2
                tmp = random.randrange(1,type+1)
            roll = ((roll//2)*tmp)
    else:
        tmp = random.randrange(1,type+1)
        roll += int(tmp)
        #print("roll " + str(roll))
        while (explosif and tmp == type):
            tmp = random.randrange(1,type+1)
            roll += int(tmp)
    if (relance != 0 and relance != 1 and relance <= roll):
        new = 1
    if (mitige != 0 and mitige >= roll):
        moins = 1
    result += (' ' if nb>0 else '') + str(roll)
    if (f != 0 and roll < f):
        roll = 0
    elif (f != 0 and roll >= f and noadd):
        tmp = int(roll//type)
        roll = tmp + ((roll - tmp*type) >= 1 if f else 0)
    roll -= moins
    #print("fin roll " + str(result) + " " + str(roll) + " " + str(new))
    return (result,roll,new)

def rolls(result,jet,type,nb,explosif,noadd,wild,f,g,ars,relance,mitige):
    total = 0
    allresult = []
    if (nb > 10000):
        nb = 10000
    tmp=(type and nb)
    if (tmp):
        jet += str(nb)+"d"+str(type)
        #print(jet)
        for _ in range(nb):
            new = 0
            result, res1, new = roll(result,type,explosif,nb,f,noadd,ars,relance,mitige)
            allresult.append(res1)
            while (new == 1):
                result, res1, new = roll(result,type,explosif,nb,f,noadd,ars,relance,mitige)
                allresult.append(res1)
    if (wild != 0):
        jet += "w" + str(wild)
        result, res1, new = roll(result,wild,wild!=1,nb if nb else 0,f,noadd,ars,relance,mitige)
        allresult.append(res1)
        result += 'w'
    #print(allresult)
    allresult.sort(reverse=True)
    for i in range((len(allresult)) if (g == 0 and ((f != 0 and noadd) or not noadd)) else (0 if (noadd and f == 0) else g)):
        if (g == 0 or len(allresult) >= g):
            total += allresult[i] if allresult[i] else 0
    if (noadd and f == 0):
        total += max(allresult)
    #print("total : " + str(total))
    jet += (("g" + str(g)) if g != 0 else "#g") if g != parser.option[5] else (("g" + str(g)) if g != 0 else "")
    jet += (("f" + str(f)) if f != 0 else "#f") if f != parser.option[4] else (("f" + str(f)) if f != 0 else "")
    jet += (("r" + str(relance)) if relance != 0 else "#r") if relance != parser.option[9] else (("r" + str(relance)) if relance != 0 else "")
    jet += (("m" + str(mitige)) if mitige != 0 else "#m") if mitige != parser.option[9] else (("m" + str(mitige)) if mitige != 0 else "")
    if (tmp):
        jet += ("e" if explosif == True else "#e") if explosif != parser.option[0] else ""
        jet += ("n" if noadd == True else "#n") if noadd != parser.option[1] else ""
        jet += ("a" if ars == True else "#a") if ars != parser.option[8] else ""
    print("fin rolls : " + str(result) + "|" + str(total) + "|" + str(jet))
    return (result,total,jet)

def entryPoint(room, event):
    global parser
    text = event['content']['body']
    nick = getNick(room,event)
    parser = Parser(text,nick,room)

    print(text)
    if (parser.eat(":roll",1)):
        parser.option = [False,False,False,0,0,0,0,0,False,0,0]
        rollXPoint()
    elif (parser.eat(":dom",1)):
        parser.option = [True,False,True,0,0,0,4,4,False,0,0]
        rollXPoint()
    elif (parser.eat(":sw",1)):
        parser.option = [True,True,True,0,0,0,4,4,False,0,0]
        rollXPoint()
    elif (parser.eat(":ars",1)):
        parser.option = [False,True,True,0,0,0,0,0,True,0,0]
        rollXPoint()
    elif (parser.eat(":des",1)):
        parser.option = [False,True,True,0,10,0,0,0,False,0,0]
        rollXPoint()
    elif (parser.eat(":wod",1)):
        parser.option = [False,True,True,0,8,0,0,0,False,10,0]
        rollXPoint()
    elif (parser.eat(":owod",1)):
        parser.option = [False,True,True,0,6,0,0,0,False,10,1]
        rollXPoint()
    else:
        parser.arg["error"] = True

    if (not parser.arg.get("error",None) and not parser.eat("$",0)):
        parser.arg["noerror"] = True
        room.send_text("Je n'ai pas compris " + text)


def rollOptionPoint():
    global parser
    while (True):
        if (parser.eat("[Ee]",1)):
            parser.option[0] = True
        elif (parser.eat("#[Ee]",1)):
            parser.option[0] = False
        elif (parser.eat("[Nn]",1)):
            parser.option[1] = True
        elif (parser.eat("#[Nn]",1)):
            parser.option[1] = False
        elif (parser.eat("[Vv]",1)):
            parser.option[2] = True
        elif (parser.eat("#[Vv]",1)):
            parser.option[2] = False
        elif (parser.eat("[Ww]",1)):
            if (parser.space()):
                parser.option[3] = 6
            elif (parser.eat(r"\d+",1)):
                parser.option[3] = int(parser.mtch)
            else:
                parser.option[3] = 6
        elif (parser.eat("#[Ww]",1)):
            parser.option[3] = 0
        elif (parser.eat("[Ff]",1)):
            if (parser.space()):
                parser.option[4] = 6
            elif (parser.eat(r"\d+",1)):
                parser.option[4] = int(parser.mtch)
            else:
                parser.option[4] = 6
        elif (parser.eat("#[Ff]",1)):
            parser.option[4] = 0
        elif (parser.eat("[Gg]",1)):
            if (parser.space()):
                parser.option[5] = 6
            elif (parser.eat(r"\d+",1)):
                parser.option[5] = int(parser.mtch)
            else:
                parser.option[5] = 6
        elif (parser.eat("#[Gg]",1)):
            parser.option[5] = 0
        elif (parser.eat("[Ss]",1)):
            if (parser.space()):
                parser.option[6] = 4
            elif (parser.eat(r"\d+",1)):
                parser.option[6] = int(parser.mtch)
            else:
                parser.option[6] = 4
            if (parser.eat("[/]",1)):
                if (parser.space()):
                    parser.option[7] = 4
                elif (parser.eat(r"\d+",1)):
                    parser.option[7] = int(parser.mtch)
                else:
                    parser.option[7] = 4
            else:
                parser.option[7] = 4
        elif (parser.eat("#[Ss]",1)):
            parser.option[6] = 0
            parser.option[7] = 0
        elif (parser.eat("[Aa]",1)):
            parser.option[8] = True
        elif (parser.eat("#[Aa]",1)):
            parser.option[8] = False
        elif (parser.eat("[Rr]",1)):
            if (parser.space()):
                parser.option[9] = 10
            elif (parser.eat(r"\d+",1)):
                parser.option[9] = int(parser.mtch)
            else:
                parser.option[9] = 10
        elif (parser.eat("#[Rr]",1)):
            parser.option[9] = 0
        elif (parser.eat("[Mm]",1)):
            if (parser.space()):
                parser.option[10] = 1
            elif (parser.eat(r"\d+",1)):
                parser.option[10] = int(parser.mtch)
            else:
                parser.option[10] = 1
        elif (parser.eat("#[Mm]",1)):
            parser.option[10] = 0
        else:
            break

def dupli(orig):
    salon = orig.room
    orig.room = None
    nouv = copy.deepcopy(orig)
    nouv.option = [orig.option[0],orig.option[1],orig.option[2],orig.option[3],orig.option[4],orig.option[5],orig.option[6],orig.option[7],orig.option[8],orig.option[9],orig.option[10]]
    orig.room = salon
    nouv.room = salon
    return nouv

def rollXPoint():
    global parser
    rollPlusMoinsPoint()
    if (parser.eat("[xX]",1)):
        if (parser.eat(r"\d+",1)):
            tmp = dupli(parser)
            str = parser.arg["jet"]
            xtime = int(parser.mtch)-1
            xtime = xtime if (xtime < 11) else 10
            for _ in range(xtime):
                parser = dupli(parser)
                parser.str = str
                print (parser.str)
                rollPlusMoinsPoint()
            parser = tmp
        else:
            parser.arg["error"] = True


def rollPlusMoinsPoint():
    global parser
    parser.arg["roll_sig"] = True
    parser.arg["error"] = None
    result = ""
    res1 = ""
    res2 = ""
    jet = ""
    rollOptionPoint()
    #print(parser.option)
    exp,noa,ver,will,f,g,s,d,ars,r,m = parser.option
    rollEntityPoint()
    #print("de " + str(parser.arg.get("roll_nb",None)) + "|" + str(parser.arg.get("roll_typ",None)))
    if (not parser.arg["error"]):
        if (not parser.arg.get("roll_sig",True)):
            jet += "-"
            result += "-"
        if (parser.arg.get("roll_typ",None) or parser.arg.get("roll_wil",None)):
            result += "("
            exp2,noa2,ver2,will2,f2,g2,s2,d2,ars2,r2,m2 = parser.option
            parser.option = [exp,noa,ver,will,f,g,s,d,ars,r,m]
            result, res1, jet = rolls(result,jet,parser.arg.get("roll_typ",None),parser.arg.get("roll_nb",None),exp2,noa2,will2,f2,g2,ars2,r2,m2)
            result += " = " + str(res1) + ")"
        else:
            jet += str(parser.arg.get("roll_nb",None))
            result += str(parser.arg.get("roll_nb",None))
            res1 = parser.arg["roll_nb"]
        #print("prem " + result + " " +str(res1))
        if (not parser.arg.get("roll_sig",True)):
            res1 = -res1
        while (parser.eat("[+-]",1)):
            parser.arg["roll_sig"] = True
            if (parser.mtch == "-"):
                parser.arg["roll_sig"] = not parser.arg.get("roll_sig",True)
            rollEntityPoint()
            if (not parser.arg.get("error",None)):
                jet += " +" if parser.arg.get("roll_sig",True) else " -"
                result += " + " if parser.arg.get("roll_sig",True) else " - "
                if (parser.arg.get("roll_typ",None) or parser.arg.get("roll_wil",None)):
                    result += "("
                    exp2,noa2,ver2,will2,f2,g2,s2,d2,ars2,r2,m2 = parser.option
                    parser.option = [exp,noa,ver,will,f,g,s,d,ars,r,m]
                    result, res2, jet = rolls(result,jet,parser.arg.get("roll_typ",None),parser.arg.get("roll_nb",None),exp2,noa2,will2,f2,g2,ars2,r2,m2)
                    result += " = " + str(res2) + ")"
                else:
                    jet += str(parser.arg.get("roll_nb",None))
                    result += str(parser.arg.get("roll_nb",None))
                    res2 = parser.arg.get("roll_nb",None)
                res1 += res2 if parser.arg.get("roll_sig",None) else -res2
    #print("deux " + result + " " +str(res1))
    if (res1):
        if (ver):
            result = jet + " = (" + result + ") = " + str(res1)
        else:
            result = jet + " = " + str(res1)
        if (d <= 0):
            d=1
        tmp = (res1 - s) // d + 1
        result += ("/" + ("0" if (tmp < 0) else str(tmp))) if (s != 0) else ""
        parser.arg["jet"] = jet
        parser.room.send_text(parser.nick + " rolls " + ("e" if exp else "") + ("n" if noa else "") + ("v" if ver else "") + ("a" if ars else "") + ("s"+str(s)+"/"+str(d) if (s != 0) else "") + (" " if (exp or noa or ver or s != 0) else "") + result)
    elif (not parser.arg.get("noerror",False)):
        parser.room.send_text("match = " + parser.mtch + "\nstr = " + parser.str)
        parser.room.send_text("Rien compris. Essayez '!help' pour obtenir de l'aide.")


def rollEntityPoint():
    global parser
    if (parser.eat("[-+]", 1)):
        if (parser.mtch == "-"):
            parser.arg["roll_sig"] = not parser.arg.get("roll_sig",True)
    rollOptionPoint()
    rollNbPoint()


def rollNbPoint():
    global parser
    parser.arg["roll_nb"] = None
    if (parser.eat(r"\d+",1)):
        parser.arg["roll_nb"] = int(parser.mtch)
    #print("nb " + str(parser.arg.get("roll_nb",1)))
    rollDPoint()


def rollDPoint():
    global parser
    if (parser.eat("[dD]",1)):
        if (not parser.arg.get("roll_nb",False)):
            parser.arg["roll_nb"] = 1
        parser.arg["roll_bon"] = 0
        rollTypePoint()
    elif (parser.arg.get("roll_nb",False)):
        parser.arg["roll_typ"] = None
    else:
        parser.arg["error"] = True


def rollTypePoint():
    global parser
    if (parser.space()):
        parser.arg["roll_typ"] = 6
    elif (parser.eat(r"\d+",1)):
        parser.arg["roll_typ"] = int(parser.mtch)
        if (parser.mtch == "1"):
            parser.option[0] = False
    else:
        parser.arg["roll_typ"] = 6
    rollOptionPoint()
    if (not parser.arg.get("roll_nb",False)):
        parser.arg["error"] = True


def reponses(room, phrases):
    i = random.randrange(0,len(phrases))
    room.send_text(phrases[i])

def jdr(room, event):
    nick = getNick(room,event)
    phrases = []
    phrases.append("Rock & Role baby!")
    phrases.append("De toute maniere " + nick + ", les gens ont perdu la foi dans le rolisme.")
    phrases.append("Bon, c'est quand la prochaine partie " + nick + "?")
    reponses(room, phrases)

def gens(room, event):
    nick = getNick(room,event)
    phrases = []
    phrases.append("L'enfer c'est les autres.")
    phrases.append("Bah " + nick + ", les gens c'est pratique pour jouer aux osselets. Bon faut juste trouver ou mettre la chair ensuite.")
    phrases.append("Franchement " + nick + ", les gens c'est comme les films X. Plus il y'en a, plus ca part en couilles...")
    reponses(room, phrases)

def va(room, event):
    nick = getNick(room,event)
    phrases = []
    phrases.append("Moi ca va si jamais quelqu'un se pose la question...")
    phrases.append("Quand l'appetit va, tout va " + nick +"!")
    phrases.append("Attention a " + nick + ", la suite est 'not safe for depression'")
    reponses(room, phrases)

def maman(room, event):
    nick = getNick(room,event)
    phrases = []
    phrases.append("On avait dit 'Pas les mamans'!")
    phrases.append("Oh, c'est pas la mere a boire " + nick + "}!")
    phrases.append("C'est pas l'homme qui prend la mere, c'est la mere qui prend l'homme...")
    reponses(room, phrases)

def hi_callback(room, event):
    # Somebody said hi, let's say Hi back
    nick = getNick(room,event)
    phrases = []
    phrases.append("Salutations " + nick + "!")
    phrases.append("Chalut " + nick + " :)")
    phrases.append("Hello " + nick +"!")
    phrases.append("Oh non, et voilà de nouveau " + nick + "...")
    reponses(room, phrases)

def echo_callback(room, event):
    args = event['content']['body'].split()
    args.pop(0)

    # Echo what they said back
    room.send_text(' '.join(args))

def liste(room, event):
    res = []
    nick = getNick(room,event)
    
    args = event['content']['body'].split()
    args.pop(0)
    try:
        nb = int(args[len(args)-1])
        args.pop(len(args)-1)
    except:
        nb = 1
    args = ' '.join(args)
    list = args.split('/')
    if (nb <= len(list)):
        for i in range(nb):
            id = random.randrange(0,len(list))
            res.append(list.pop(id))
        room.send_text(nick + " obtient :\n" + '\n'.join(res))
    else:
        room.send_text("Utilisation : !liste <options/de/la/liste> [nombre d elements]")

def cristal(room, event):
    nick = getNick(room,event)
    
    args = event['content']['body'].split()
    args.pop(0)
    if (len(args) < 2 or args[len(args)-1][-1] != '?'):
        room.send_text("Utilisation : !cristal <Quel est votre question?>")
    else:
        args[len(args)-1] = args[len(args)-1][0:-1]
        args = list(set(args).difference(set(["Dans", "Jusque", "le", "la", "les", "de", "des", "un", "une", "est", "sont", "serait", "seraient", "était", "étaient", "sera", "seront", "ont", "aurait", "auraient", "aura", "auront", "a", "à"])))
        conj = args[0]
        args.pop(0)
        cle = max(args, key=len)
        if (conj == "Est-ce" or conj == "est-ce"):
            # traitement Oui/non
            phrases = []
            phrases.append("Evidemment " + nick + ", qu'est ce que tu croyais?")
            phrases.append("Non " + nick + ", malheurement non.")
            phrases.append("Oui " + nick +", et quelque chose d'encore pire ensuite pour " + cle + "!")
            phrases.append("Je ne sais pas si je dois te le dire au risque de te faire de la peine, " + nick + "...")
            reponses(room, phrases)
        elif (conj == "Combien" or conj == "combien"):
            # traitement quantité
            phrases = []
            phrases.append("Enormement " + nick + "!")
            phrases.append("Quasiment aucun " + nick + " :)")
            phrases.append("Peu comparé à l'immensité, mais au niveau de " + nick +", forcément...")
            phrases.append("J'en vois des dizaines, des centaines et par un prompt renfort ils furent 500 en arrivant au port!")
            reponses(room, phrases)
        elif (conj == "Pourquoi" or conj == "pourquoi"):
            # traitement raison
            phrases = []
            phrases.append("Parce que la vie est injuste " + nick + "!")
            phrases.append("A cause del'orgueil, " + nick + ", la mère de tous les vices.")
            phrases.append("Pour la richesse, pour le pouvoir, pour le pouvoir qu'apporte la richesse.")
            phrases.append("A cause d'une démence aussi soudaine que passagère.")
            reponses(room, phrases)
        elif (conj == "Comment" or conj == "comment"):
            # traitement methode
            phrases = []
            phrases.append("Discrètement, sournoisement, vicieusement " + nick + "!")
            phrases.append("Avec panache! :)")
            phrases.append("Avec un trombone et un élastique, comme McGuy" + nick +"!")
            phrases.append("Avec une aide des plus innattendues.")
            reponses(room, phrases)
        elif (conj == "Quand" or conj == "quand"):
            # traitement temps
            phrases = []
            phrases.append("Plus vite que tu ne l'imagine, retourne toi " + nick + "!")
            phrases.append("Dans vraiment de temps, mais n'est pas mort ce qui à jamais dort...")
            phrases.append("Pile poil la durée que tu imaginais.")
            phrases.append("Dans plus lontemps que tu ne le pensais, mais tous les intervenants ont une bonne excuse. Leur collègue de droite a merdé.")
            reponses(room, phrases)
        elif (conj == "Où" or conj == "où"):
            # traitement lieu
            phrases = []
            phrases.append("Dans la ville voisine")
            phrases.append("A l'extérieur")
            phrases.append("Au dernier endroit où on y penserait")
            phrases.append("Là où les ennuis se concentrent, comme d'habitude")
            reponses(room, phrases)
        else:
            # reponse generique
            phrases = []
            phrases.append("Toujours en mouvement le futur est. Toujours sans lunettes flou je vois.")
            phrases.append("La boule de cristal est momentanément indisponible, veuillez réitérer votre divination ultérieurement.")
            phrases.append("Une ombre plane sur ton âme, ses crocs approchent.")
            phrases.append("Tu portes quelque chose de sombre, je refuse de me laisser souiller.")
            reponses(room, phrases)

def horloge(room, event):
    global clock
    nick = getNick(room,event)
    
    args = event['content']['body'].split()
    args.pop(0)
    if (len(args) == 0):
        # Liste des horloges du salon
        for cle,valeur in clock.items():
            if (cle[0] == room.room_id):
                if (int(valeur) == 0):
                    room.send_text(cle[1] + " : " + chr(128320) + "\n")
                elif (int(valeur) == 1):
                    room.send_text(cle[1] + " : " + chr(128338) + "\n")
                elif (int(valeur) == 2):
                    room.send_text(cle[1] + " : " + chr(128341) + "\n")
                elif (int(valeur) == 3):
                    room.send_text(cle[1] + " : " + chr(128344) + "\n")
                elif (int(valeur) == 4):
                    room.send_text(cle[1] + " : " + chr(128345) + "\n")
                elif (int(valeur) == 5):
                    room.send_text(cle[1] + " : " + chr(128346) + "\n")
                elif (int(valeur) == 6):
                    room.send_text(cle[1] + " : " + chr(128347) + "\n")
                else:
                    room.send_text(cle[1] + " : " + str(valeur) + " \n")
    elif (len(args) >= 2 and args[len(args)-1].isnumeric()):
        # Place le niveau de l'horloge entre 0 et 6
        nv = int(args[len(args)-1])
        clock[room.room_id, ' '.join(args[0:-1])] = nv
    elif (len(args) >= 2 and args[0] == "del"):
        # Supprime une horloge
        args.pop(0)
        del clock[room.room_id, ' '.join(args)]
    else:
        room.send_text("Utilisation : \n- !horloge : Affiche les horloges. \n- !horloge <nom> <niveau> : Place ou crée l'horloge au niveau spécifié.\n- !horloge del <nom> : Supprime l'horloge.")
        
def invitations(room_id, state):
    global bot
    try:
        global bot
        bot.client.join_room(room_id)
        time.sleep(2)
        del bot
        main()
    except:
        print("Impossible de rejoindre ce salon")

def main():
    config = configparser.ConfigParser()
    config.read('asmodee.ini')
    USERNAME = ""  # Bot's username
    PASSWORD = ""  # Bot's password
    SERVER = ""  # Matrix server URL

    if ('AUTH' in config):
        USERNAME = config['AUTH']['username']  # Bot's username
        PASSWORD = config['AUTH']['password']  # Bot's password
        SERVER = config['AUTH']['server']  # Matrix server URL
    else:
        print("Probleme de lecture de configuration asmodee.ini")

    # Create an instance of the MatrixBotAPI
    global bot
    bot = MatrixBotAPI(USERNAME, PASSWORD, SERVER)

    # Aide
    help_handler = MCommandHandler("help", help)
    bot.add_handler(help_handler)

    # Add a regex handler waiting for keywords and answers
    #hi_handler = MRegexHandler("[Ss]alut|[Cc]halut|'lut|[Cc]oucou|[Bb]onjour|[Hh]ello", hi_callback)
    #bot.add_handler(hi_handler)
    #jdr_handler = MRegexHandler("[Jj]dr|[Rr]pg", jdr)
    #bot.add_handler(jdr_handler)
    #gens_handler = MRegexHandler("[Gg]ens", gens)
    #bot.add_handler(gens_handler)
    #maman_handler = MRegexHandler("[Mm]aman|[Mm]ere", maman)
    #bot.add_handler(maman_handler)
    #va_handler = MRegexHandler("ca va|vas]", va)
    #bot.add_handler(va_handler)

    # Add a regex handler waiting for the dice commands and aliases
    entry_handler = MCommandHandler("", entryPoint, ':')
    bot.add_handler(entry_handler)

    # Cartes !card tire une carte d'un paquet plein !carte tire une carte qui disparait du paquet
    card_handler = MCommandHandler("card", card)
    bot.add_handler(card_handler)

    carte_handler = MCommandHandler("carte", carte)
    bot.add_handler(carte_handler)
    
    # Un élément d'une liste
    liste_handler = MCommandHandler("liste", liste)
    bot.add_handler(liste_handler)
    
    # Boule de cristal
    cristal_handler = MCommandHandler("cristal", cristal)
    bot.add_handler(cristal_handler)

    # horloges
    horloge_read()
    signal.signal(signal.SIGINT, signal_handler)
    horloge_handler = MCommandHandler("horloge", horloge)
    bot.add_handler(horloge_handler)
    
    # Invitations
    bot.client.add_invite_listener(invitations)

    # Start polling
    bot.start_polling()

    # Infinitely read stdin to stall main thread while the bot runs in other threads
    while True:
        input()


if __name__ == "__main__":
    main()