asmodee_matrix/asmodee.py

# coding: utf8
import random
import re
import copy
import configparser
#import iolast
import signal
import sys
import pickle
import time
import threading
import json
from datetime import datetime,timedelta
import smtplib
import os
import requests
import html2text

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

from mall_handler import MAllHandler
from mend_handler import MEndHandler

# 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 = {} # horloges pbta
stats = {} # Statistiques sur les messages
quotes = {} # Citations
citations = {} #addquote
bieres = {} # Boissons a offrir
salons = {} # Boissons a offrir
welcome = {} # Messages d'accueil des salons
admins = [] # Admins du bot
modos = {} # Moderateurs des salons
modules = {} # Modules activés par salon
mails = {} # Liste de gens abonnés par mail au salon
liste_mod = [] # Modules disponibles
USERNAME = ""

malt = 0
msender = ""
mpass = ""
msmtp = ""
mport = ""

# Chargement des données persistantes
def horloge_read():
	global clock
	try:
		with open("horloge", "rb") as fichier:
			loader = pickle.Unpickler(fichier)
			clock = loader.load()
	except:
		clock = {}

def stats_read():
	global stats
	try:
		with open("stats", "rb") as fichier:
			loader = pickle.Unpickler(fichier)
			stats = loader.load()
	except:
		stats = {}

def quotes_read():
	global quotes
	try:
		with open("quotes", "rb") as fichier:
			loader = pickle.Unpickler(fichier)
			quotes = loader.load()
	except:
		quotes = {}

def citations_read():
	global citations
	try:
		with open("citations", "rb") as fichier:
			loader = pickle.Unpickler(fichier)
			citations = loader.load()
	except:
		citations = {}


def bieres_read():
	global bieres
	try:
		with open("bieres", "rb") as fichier:
			loader = pickle.Unpickler(fichier)
			bieres = loader.load()
	except:
		bieres = {}

def salons_read():
	global salons
	try:
		with open("salons", "rb") as fichier:
			loader = pickle.Unpickler(fichier)
			salons = loader.load()
	except:
		salons = {}

def welcome_read():
	global welcome
	try:
		with open("welcome", "rb") as fichier:
			loader = pickle.Unpickler(fichier)
			welcome = loader.load()
	except:
		welcome = {}

def modos_read():
	global modos
	try:
		with open("moderateurs", "rb") as fichier:
			loader = pickle.Unpickler(fichier)
			modos = loader.load()
	except:
		modos = {}

def modules_read():
	global modules
	try:
		with open("modules", "rb") as fichier:
			loader = pickle.Unpickler(fichier)
			modules = loader.load()
	except:
		modules = {}

def mails_read():
	global mails
	try:
		with open("mails", "rb") as fichier:
			loader = pickle.Unpickler(fichier)
			mails = loader.load()
	except:
		mails = {}


def save_obj(room=None, event=None):
	if ('horloge' in liste_mod):
		with open("horloge", "wb") as fichier:
			saver = pickle.Pickler(fichier)
			saver.dump(clock)
	if ('mails' in liste_mod):
		with open("mails", "wb") as fichier:
			saver = pickle.Pickler(fichier)
			saver.dump(mails)
	if ('stats' in liste_mod):
		with open("stats", "wb") as fichier:
			saver = pickle.Pickler(fichier)
			saver.dump(stats)
	if ('quote' in liste_mod):
		with open("quotes", "wb") as fichier:
			saver = pickle.Pickler(fichier)
			saver.dump(quotes)
		with open("citations", "wb") as fichier:
			saver = pickle.Pickler(fichier)
			saver.dump(citations)
	if ('biere' in liste_mod):
		with open("bieres", "wb") as fichier:
			saver = pickle.Pickler(fichier)
			saver.dump(bieres)
	if ('salon' in liste_mod):
		with open("salons", "wb") as fichier:
			saver = pickle.Pickler(fichier)
			saver.dump(salons)
	if ('welcome' in liste_mod):
		with open("welcome", "wb") as fichier:
			saver = pickle.Pickler(fichier)
			saver.dump(welcome)
	with open("moderateurs", "wb") as fichier:
		saver = pickle.Pickler(fichier)
		saver.dump(modos)
	with open("modules", "wb") as fichier:
		saver = pickle.Pickler(fichier)
		saver.dump(modules)

def signal_handler(signal, frame): # Sauvegarder les données persistantes avant sortie
	save_obj(None,None)
	sys.exit(0)

def not_myself(f):
	def handler(room, event):
		if event['sender'] == USERNAME:
			return
		f(room, event)
	return handler


class Userstats: #Pour garder des stats sur les users
	def __init__(self,room,user,nick):
		self.room = room
		self.user = user
		self.nick = nick.strip()
		self.date = 0
		self.mess = 0
		self.char = 0
		self.kapoue = 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,False]

	@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 msg(room,msg,sender,content=False):
	try:
		try:
			lmod = modos[room.room_id]
			if (sender not in admins and sender not in lmod):
				msg = msg.replace('@room', 'tout le monde')
		except:
			try:
				msg = msg.replace('@room', 'tout le monde')
			except:
				print(msg)
		if content:
			bot.client.api.send_message_event(room.room_id, 'm.room.message', msg, None, None)
		else:
			room.send_text(msg)
	except:
		room.send_text("Impossible d'envoyer le message")

def verifPMRoom(room, event): # Pour obtenir ou créer un salon pour les messages privés avec l'utilisateur
	global bot
	nick = ""
	try:
		nick = event['sender'].split("@")[1].split(":")[0]
	except:
		nick = getNick(room, event)
	client_id = ""
	client_host = ""
	try:
		client_id = bot.client.user_id.split("@")[1].split(":")[0]
	except:
		client_id = "asmodee"
	try:
		client_host = bot.client.user_id.split("@")[1].split(":")[1]
	except:
		client_host = "ombreport.info"
	alias = "#" + client_id + "_" + nick + ":" + client_host
	salon = None
	#salons = bot.client.rooms
	#print("\nalias = " + alias)
	#for cle, salon in salons.items():
	#	if alias in salon.aliases:
	#		print("trouvé : " + cle)
	#		print(salon.aliases)
	#		msg(salon,"gagné",event['sender'])
	#		return salon
	#	else:
	#		print(salon.aliases)
	#		print(salon.room_id)
	try:
		salon = bot.client.join_room(alias)
	except:
		#part = [bot.client.user_id,event['sender']]
		try:
			salon = bot.client.create_room()
			salon.set_room_topic("Informations d'Asmodée")
			salon.invite_user(event['sender'])
			salon.add_room_alias(alias)
			salon.update_aliases()
			#Il faudrait recharger le bot pour prendre en compte le nouveau salon dans les listener
			#Mais sans interrompre la requête
			#save()
			#main()
		except:
			print("Impossible de creer ou joindre " + alias)
			return None
	#msg(salon,"nouvelle conversation",event['sender'])
	# TODO vérifier la présence du sender dans la liste des membres de ce salon et réinviter si besoin
	try:
		salon.invite_user(event['sender'])
	except:
		print("il etait deja dedans, c'est sale")
	return salon

def getNick(room, event): # Obtenir le DisplayName à partir du mxid
	members = room.get_joined_members()
	nick = ""
	try:
		for user in members: 
			if user.user_id == event['sender']:
				nick = user.get_friendly_name()
				break
		if (len(nick) == 0):
			 nick = event['sender']
	except:
		try:
			nick = [user.get_friendly_name() for user in members if user.user_id == event['sender']][0]
		except:
			nick = event['sender']
	return(nick)

@not_myself
def card(room, event): # Tirer une carte du paquet sans la retirer
	global modules
	try:
		rmod = modules[room.room_id, 'card']
	except:
		modules[room.room_id, 'card'] = False
	if (modules[room.room_id, 'card']):
		reponse = cartes_base[random.randrange(0,len(cartes_base))]
		msg(room,reponse,event['sender'])

@not_myself
def carte(room, event): # Tirer une carte du paquet en la retirant ensuite
	global modules
	try:
		rmod = modules[room.room_id, 'carte']
	except:
		modules[room.room_id, 'carte'] = False
	if (modules[room.room_id, 'carte']):
		global cartes
		args = event['content']['body'].split()
		if (len(args) > 1):
			cartes=list(cartes_base)
			msg(room,"Le paquet est melange",event['sender'])
		else:
			if (len(cartes) < 1):
				cartes=list(cartes_base)
				msg(room,"Le paquet est melange",event['sender'])
			i = random.randrange(0,len(cartes))
			msg(room,cartes[i],event['sender'])
			cartes.pop(i)

@not_myself
def help(room, event): # Aide en message privé
	help_center(room,event,"help",True)
@not_myself
def aide(room, event): # Aide dans le salon
	help_center(room,event,"aide",False)
def help_center(room,event,name,private): # Aide sur les commandes disponibles
	args = event['content']['body'].split()
	args.pop(0)
	salon = room
	if (private):
		salon = verifPMRoom(room,event)
	if (len(args) > 0):
		if (re.search("roll", args[0])):
			msg(salon,":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- z : Star Zars, le premier de est explosif. Mais s'il sort un 1, on retire ce 1 et la plus grande valeur des autres des\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.",event['sender'])
		elif (re.search("sw", args[0])):
			msg(salon,"- :sw <options> <des> : Lance les des en mode Savage Worlds\nVerbose/Noadd/Explosif/Seuil 4/Niveau de reussite 4/Wild Die d6.",event['sender'])
		elif (re.search("dom", args[0])):
			msg(salon,"- :dom <options> <des> : Lance les dommages en mode Savage Worlds\nVerbose/Explosif/seuil 4/Niveau de reussite 4.",event['sender'])
		elif (re.search("owod", args[0])):
			msg(salon,"- :owod <options> <des> : Lance les des en mode Ancien Monde des Tenebres\nVerbose/Noadd/Difficulte 6/Relance les 10/Les 1 enleve un succes.",event['sender'])
		elif (re.search("wod", args[0])):
			msg(salon,"- :wod <options> <des> : Lance les des en mode Nouveau Monde des Tenebres\nVerbose/Noadd/Difficulte 8/Relance les 10.",event['sender'])
		elif (re.search("ars", args[0])):
			msg(salon,"- :ars <options> <des> : Lance les des en mode Ars Magicka : de de tension\nVerbose/Noadd/Sur un 1, on relance et on double.",event['sender'])
		elif (re.search("des", args[0])):
			msg(salon,"- :des <options> <des> : Lance des des de desastre\nVerbose/Noadd/Difficulte 10.",event['sender'])
		elif (re.search("star", args[0])):
			msg(salon,"- :star <options> <des> : Lance des des en mode star wars. Le premier de est explosif. Mais s'il sort un 1, on retire ce 1 et la plus grande valeur des autres des.",event['sender'])
		elif (re.search("carte", args[0])):
			msg(salon,"- !carte : Tire une carte et la retire du paquet\n- !carte m : remelange le paquet.",event['sender'])
		elif (re.search("card", args[0])):
			msg(salon,"- !card : tire une carte sans la retirer du paquet.",event['sender'])
		elif (re.search("liste", args[0])):
			msg(salon,"- !liste <options/de/la/liste> [Nombre d'elements souhaites] : retourne ce nombre d'elements de la liste.",event['sender'])
		elif (re.search("horloge", args[0])):
			msg(salon,"- !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.",event['sender'])
		elif (re.search("last", args[0])):
			msg(salon,"- !last : Date de son dernier post\n- !last <Personne> : Date du dernier post de la personne\n- !last inactifs <[+-]nombre de jours> <nombre max de message> : liste de personnes (en privé) ayant posté depuis + ou - le nombre de jours spécifiés et ayant au maximum le nombre de messages spécifiés.\n",event['sender'])
		elif (re.search("actif", args[0])):
			msg(salon,"- !actif : Nombre de ses messages et taille moyenne de ceux ci\n- !actif <Personne> : Nombre des messages de cette personne et taille moyenne de ceux ci\n",event['sender'])
		elif (re.search("quote", args[0])):
			msg(salon,"- !quote : Affiche une citation du salon au hasard\n- !quote <Personne> : Affiche une citation d'une personne du salon au hasard\n- !quote add <Personne>:<citation> : Enregistre une citation\n- !quote list [Personne] : Affiche les citation du salon ou d'une personne du salon en message privé\n- !quote list all : Affiche toutes les citations de tous les salons en message privé\n- !quote del <id> : Supprime la citation avec l'id spécifié",event['sender'])
		elif (re.search("biere", args[0])):
			msg(salon,"- !biere : Fournit une boisson du salon au hasard\n- !biere <Nom de breuvage> : Fournit une boisson spécifique du salon\n- !biere give <Personne>[:Nom du Breuvage] : Offre une boisson (spécifique en option) à la personne spécifiée\n- !biere add <Nom du breuvage>:<Phrase> : Enregistre une phrase pour ce breuvage\n- !biere list [Nom de Breuvage] : Affiche les phrases des breuvages du salon ou celles d'un breuvage spécifique du salon en message privé\n- !biere list all : Affiche toutes les citations de tous breuvages de tous les salons en message privé\n- !biere del <id> : Supprime la phrase avec l'id spécifié",event['sender'])
		elif (re.search("accueil", args[0])):
			msg(salon,"- !accueil <message> : Modifie le message d'accueil avec message. Il sera affiché à tout nouvel arrivant précédé de la mention 'Bienvenue sur le salon XXX, YYY.'",event['sender'])
		elif (re.search("kick", args[0])):
			msg(salon,"- !kick <@mxid> [@mxid] ... : kick les users listés",event['sender'])
		elif (re.search("titre", args[0])):
			msg(salon,"- !titre <url> : retourne le titre de la page",event['sender'])
		elif (re.search("mails", args[0]) or re.search("mail", args[0])):
			msg(salon,"- !mail add <email> : s'abonner aux messages du salon par mail.\n -!mail del <email> : se désabonner aux messages du salon par mail.",event['sender'])
		elif (re.search("modo", args[0])):
			msg(salon,"- !modo : Affiche la liste des modérateurs (ils peuvent gérer le message d'accueil, supprimer des citations ou des boissons, ajouter/retirer des modules, ajouter/retirer des modérateurs)\n- !modo add <mxid> : Ajoute une personne comme modérateur du salon\n- !modo del <mxid> : Retire une personne des modérateurs.",event['sender'])
		elif (re.search("module", args[0])):
			msg(salon,"- !module : Affiche la liste des modules actifs sur le salon ainsi que celle des modules disponibles\n- !module add <module> : Active un module sur le salon\n- !module del <module> : Désactive un module sur le salon.",event['sender'])
		elif (re.search("cristal", args[0])):
			msg(salon,"- !cristal : Réponds à une question posée commençant par Est-ce, Combien, Pourquoi, Quand, Comment, Où et se terminant par un point d'interrogation.",event['sender'])
		else:
			msg(salon,"A venir",event['sender'])
	else:
		rid = room.room_id
		message = "Commandes disponibles:"
		for cle,valeur in modules.items():
			if (cle[0] == rid and cle[1] == "card" and valeur):
				message += "\n- !card"
			if (cle[0] == rid and cle[1] == "carte" and valeur):
				message += "\n- !carte"
			if (cle[0] == rid and cle[1] == "liste" and valeur):
				message += "\n- !liste <options/de/la/liste> [Nombre d'elements souhaites]"
			if (cle[0] == rid and cle[1] == "horloge" and valeur):
				message += "\n- !horloge : gestion des horloges PBTA"
			if (cle[0] == rid and cle[1] == "stats" and valeur):
				message += "\n- !last : Date de dernier post\n- !actif : Nombre de message et taille moyenne de ceux ci"
			if (cle[0] == rid and cle[1] == "quote" and valeur):
				message += "\n- !quote : citations du salon"
			if (cle[0] == rid and cle[1] == "biere" and valeur):
				message += "\n- !biere : breuvages du salon"
			if (cle[0] == rid and cle[1] == "cristal" and valeur):
				message += "\n- !cristal : Posez une question à la boule de cristal"
			if (cle[0] == rid and cle[1] == "welcome" and valeur):
				message += "\n- !accueil <message> : Modifie le message d'accueil"
			if (cle[0] == rid and cle[1] == "kick" and valeur):
				message += "\n- !kick <@mxid> [@mxid] ... : kick les users listés"
			if (cle[0] == rid and cle[1] == "titre" and valeur):
				message += "\n- !titre <url> : retourne le titre de la page en paramètre si celle ci possède une balise titre"
			if (cle[0] == rid and cle[1] == "mails" and valeur):
				message += "\n- !mail : s'abonner aux messages du salon par mail."
			if (cle[0] == rid and cle[1] == "roll" and valeur):
				message += "\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- :star <options> <des>"
		message += "\n- !modo : Gère les modérateurs du salon\n- !module : Gère les modules actifs sur le salon\n\n- Pour plus de details, tapez !" + name + " <commande>\n\nRetrouvez Asmodee sur https://git.ombreport.info/nemesis/asmodee_matrix"
		msg(salon,message,event['sender'])

def roll(result,type,explosif,nb,f,noadd,ars,relance,mitige): # Lancement d'un dé
	# 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,z): # Lancement d'un groupe de dés
	y = 0
	total = 0
	allresult = []
	if (nb > 100):
		nb = 100
	tmp=(type and nb)
	if (tmp):
		jet += str(nb)+"d"+str(type)
		#print(jet)
		for i in range(nb):
			new = 0
			# Star Wars
			if (z == True and i == 0):
				result, res1, new = roll(result,type,True,nb,f,noadd,ars,relance,mitige)
				allresult.append(res1)
				if (res1 == 1):
					y = 1
			# Autre
			else:
				result, res1, new = roll(result,type,explosif,nb,f,noadd,ars,relance,mitige)
				allresult.append(res1)
			# Tant qu'il faut relancer
			while (new == 1):
				result, res1, new = roll(result,type,explosif,nb,f,noadd,ars,relance,mitige)
				allresult.append(res1)
	# Wild die de Savage Worlds
	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)
	# 1 au de joker de Star Wars
	if (y == 1):
		del allresult[-1]
		del allresult[0]
	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)

@not_myself
def entryPoint(room, event): # Analyse des commandes ":", point d'entrée pour les jets de dés
	global modules
	try:
		rmod = modules[room.room_id, 'roll']
	except:
		modules[room.room_id, 'roll'] = False
	if (modules[room.room_id, 'roll']):
		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,False]
			rollXPoint()
		elif (parser.eat(":dom",1)):
			parser.option = [True,False,True,0,0,0,4,4,False,0,0,False]
			rollXPoint()
		elif (parser.eat(":sw",1)):
			parser.option = [True,True,True,0,0,0,4,4,False,0,0,False]
			rollXPoint()
		elif (parser.eat(":ars",1)):
			parser.option = [False,True,True,0,0,0,0,0,True,0,0,False]
			rollXPoint()
		elif (parser.eat(":des",1)):
			parser.option = [False,True,True,0,10,0,0,0,False,0,0,False]
			rollXPoint()
		elif (parser.eat(":wod",1)):
			parser.option = [False,True,True,0,8,0,0,0,False,10,0,False]
			rollXPoint()
		elif (parser.eat(":adv",1)):
			parser.option = [False,True,False,0,5,0,0,0,False,0,0,False]
			rollXPoint()
		elif (parser.eat(":owod",1)):
			parser.option = [False,True,True,0,6,0,0,0,False,10,1,False]
			rollXPoint()
		elif (parser.eat(":star",1)):
			parser.option = [False,False,True,0,0,0,0,0,False,0,0,True]
			rollXPoint()
		elif (parser.eat(":fate",1)):
			text = text[5:] + " 4d3-8"
			parser = Parser(text,nick,room)
			parser.option = [False,False,False,0,0,0,0,0,False,0,0,False]
			rollXPoint()
		else:
			parser.arg["error"] = True

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


def rollOptionPoint(): # Parse des options
	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
		elif (parser.eat("[Zz]",1)):
			parser.option[11] = True
		elif (parser.eat("#[Zz]",1)):
			parser.option[11] = False
		else:
			break

def dupli(orig): # Duplication d'un parser
	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.option[11]]
	orig.room = salon
	nouv.room = salon
	return nouv

def rollXPoint(): # Parser le nombre de lancers de dés identiques
	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(): # Gérer les bloc du jet séparés par les + et -, afficher le résultat
	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,z = 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,z2 = parser.option
			parser.option = [exp,noa,ver,will,f,g,s,d,ars,r,m,z]
			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,z2)
			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,z2 = parser.option
					parser.option = [exp,noa,ver,will,f,g,s,d,ars,r,m,z]
					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,z2)
					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
		msg(parser.room,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, "dice")
	elif (not parser.arg.get("noerror",False)):
		msg(parser.room,"match = " + parser.mtch + "\nstr = " + parser.str, "dice")
		msg(parser.room,"Rien compris. Essayez '!help' pour obtenir de l'aide.", "dice")


def rollEntityPoint(): # Parser les séparateurs de bloc + et -
	global parser
	if (parser.eat("[-+]", 1)):
		if (parser.mtch == "-"):
			parser.arg["roll_sig"] = not parser.arg.get("roll_sig",True)
	rollOptionPoint()
	rollNbPoint()


def rollNbPoint(): # Parser le nombre de dés 
	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(): # Parser le mot clé identifiant un dé
	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(): # Parser le nombre de faces du dé
	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, content=False): # Afficher une réponse aléatoire dans la liste
	i = random.randrange(0,len(phrases))
	msg(room,phrases[i],"reponses",content)

@not_myself
def jdr(room, event):
	global modules
	try:
		rmod = modules[room.room_id, 'jdr']
	except:
		modules[room.room_id, 'jdr'] = False
	if (modules[room.room_id, 'jdr'] and not event['sender'] == bot.client.user_id):
		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)

@not_myself
def gens(room, event):
	global modules
	try:
		rmod = modules[room.room_id, 'gens']
	except:
		modules[room.room_id, 'gens'] = False
	if (modules[room.room_id, 'gens'] and not event['sender'] == bot.client.user_id):
		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...")
		phrases.append("J'adore quand, dans les films d'horreur, les gens appellent 'Y'a quelqu'un?'. Comme si " + nick + " allait répondre 'Oui, je suis dans la cuisine, vous voulez un sandwich?'")
		phrases.append("Les gens sont comme les pigeons. Tu les aides à s'envoler et, une fois en l'air, ils te chient dessus.")
		phrases.append("Les gens se divisent en 10 catégories, ceux qui comprennent le binaire et les autres.")
		phrases.append("Les grands esprits discutent des idées, les esprits moyens discutent des événements et les petits esprits discutent des gens.")
		phrases.append("Les jugements que les gens ont sur toi ne te définissent pas " + nick + ", ils les définissent eux.")
		phrases.append("Les gens sont comme des livres, certains trompent par leur couverture, d'autres comme " + nick + " surprennent par leur contenu.")
		phrases.append("L'ennui dans ce monde, c'est que les gens comme " + nick + " sont sûr d'eux, alors que les gens sensés sont pleins de doutes.")
		phrases.append("Parler à " + nick + ", c'est un peu comme se masturber avec une râpe à fromage. Beaucoup de souffrances pour peu de résultats.")
		phrases.append("Il y'a des gens comme " + nick + " qui arrivent à joindre l'inutile au désagréable.")
		phrases.append("Parfois, on voit des gens mauvais qui ne fument pas et des gens bons fumer.")
		phrases.append("Pour que le mal triomphe, il suffit que les gens de bien ne fassent rien.")
		phrases.append("Comme " + nick + ", gens rage!")
		reponses(room, phrases)

@not_myself
def va(room, event):
	global modules
	try:
		rmod = modules[room.room_id, 'va']
	except:
		modules[room.room_id, 'va'] = False
	if (modules[room.room_id, 'va'] and not event['sender'] == bot.client.user_id):
		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)

@not_myself
def hi_callback(room, event):
	global modules
	try:
		rmod = modules[room.room_id, 'salut']
	except:
		modules[room.room_id, 'salut'] = False
	if (modules[room.room_id, 'salut'] and not event['sender'] == bot.client.user_id):
		# 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)

@not_myself
def liste(room, event): # Afficher un élement aléatoire d'une liste fournie
	global modules
	try:
		rmod = modules[room.room_id, 'liste']
	except:
		modules[room.room_id, 'liste'] = False
	if (modules[room.room_id, 'liste']):
		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))
			msg(room,nick + " obtient :\n" + '\n'.join(res),event['sender'])
		else:
			msg(room,"Utilisation : !liste <options/de/la/liste> [nombre d elements]",event['sender'])

@not_myself
def cristal(room, event): # Affiche une réponse à une question posée
	global modules
	try:
		rmod = modules[room.room_id, 'cristal']
	except:
		modules[room.room_id, 'cristal'] = False
	if (modules[room.room_id, 'cristal']):
		nick = getNick(room,event)

		args = event['content']['body'].split()
		args.pop(0)
		if (len(args) < 2 or args[len(args)-1][-1] != '?'):
			msg(room,"Utilisation : !cristal <Quelle est votre question?>",event['sender'])
		else:
			args[len(args)-1] = args[len(args)-1][0:-1]
			conj = args[0]
			args.pop(0)
			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", "à"])))
			cle = max(args, key=len)
			print(cle)
			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! :) " + cle + " pfff...")
				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'imagines, retourne toi " + nick + "!")
				phrases.append("Dans vraiment longtemps, mais n'est pas mort ce qui à jamais dort...")
				phrases.append("Pile poil la durée que tu imaginais pour " + cle)
				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 pour " + cle)
				phrases.append("Là où les ennuis se concentrent, comme d'habitude pour " + nick)
				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 aff_hor(room, hor, valeur): # affichage des horloges
	if (int(valeur) == 0):
		msg(room,hor + " : " + chr(128320) + "\n", "horloge")
	elif (int(valeur) == 1):
		msg(room,hor + " : " + chr(128338) + "\n", "horloge")
	elif (int(valeur) == 2):
		msg(room,hor + " : " + chr(128341) + "\n", "horloge")
	elif (int(valeur) == 3):
		msg(room,hor + " : " + chr(128344) + "\n", "horloge")
	elif (int(valeur) == 4):
		msg(room,hor + " : " + chr(128345) + "\n", "horloge")
	elif (int(valeur) == 5):
		msg(room,hor + " : " + chr(128346) + "\n", "horloge")
	elif (int(valeur) == 6):
		msg(room,hor + " : " + chr(128347) + "\n", "horloge")
	else:
		msg(room,hor + " : " + str(valeur) + " \n", "horloge")

@not_myself
def horloge(room, event): # Gestion des horloges PBTA
	global modules
	try:
		rmod = modules[room.room_id, 'horloge']
	except:
		modules[room.room_id, 'horloge'] = False
	if (modules[room.room_id, 'horloge']):
		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):
					aff_hor(room, cle[1], valeur)
		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[len(args)-1][:1] == "+" or args[len(args)-1][:1] == "-")):
			nv = 0
			hor = ' '.join(args[0:-1])
			if ((room.room_id, hor) in clock):
				nv = clock[room.room_id, hor]
			val = 0
			if (args[len(args)-1][1:].isnumeric()):
				val = int(args[len(args)-1][1:])
			if (args[len(args)-1][:1] == "+"):
				nv = nv + val
				if (nv > 6):
					nv = 6
			else:
				nv = nv - val
				if (nv < 0):
					nv = 0
			clock[room.room_id, hor] = nv
			aff_hor(room, hor, nv)
		elif (len(args) >= 2 and args[0] == "del"):
			# Supprime une horloge
			args.pop(0)
			del clock[room.room_id, ' '.join(args)]
		else:
			msg(room,"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.",event['sender'])

@not_myself
def statistiques(room,event): # Enregistrement des statistiques
	global modules
	try:
		rmod = modules[room.room_id, 'stats']
	except:
		modules[room.room_id, 'stats'] = False
	if (modules[room.room_id, 'stats']):
		global stats
		nick = getNick(room,event)
		user = event['sender']
		usrstats1 = 0
		usrstats2 = 0

		if ('body' in event['content']):
			try:
				usrstats1 = stats[room.room_id,user]
			except:
				usrstats1 = Userstats(room.room_id,user,nick)
			try:
				usrstats2 = stats[room.room_id,nick]
			except:
				usrstats2 = Userstats(room.room_id,user,nick)

			# date de la phrase
			date = datetime.now()
			usrstats1.date = date
			usrstats2.date = date

			# recup nb phrases +1, 1 sinon
			if (usrstats1.mess >= usrstats2.mess):
				usrstats2.mess = usrstats1.mess + 1
				usrstats1.mess = usrstats2.mess
			else:
				usrstats1.mess = usrstats2.mess + 1
				usrstats2.mess = usrstats1.mess

			# recup nb lettres +lettres phrase, lettres phrases sinon
			if (usrstats1.char >= usrstats2.char):
				usrstats2.char = usrstats1.char + len(event['content']['body'])
				usrstats1.char = usrstats2.char
			else:
				usrstats1.char = usrstats2.char + len(event['content']['body'])
				usrstats2.char = usrstats1.char

			# si kapoue, recup nb kapoue +1, 1 sinon
			if (re.match(".*KAPOUE|.*[Kk]apoue", event['content']['body'])):
				if (usrstats1.kapoue >= usrstats2.kapoue):
					usrstats2.kapoue = usrstats1.kapoue + 1
					usrstats1.kapoue = usrstats2.kapoue
				else:
					usrstats1.kapoue = usrstats2.kapoue + 1
					usrstats2.kapoue = usrstats1.kapoue

			# insertion des objets
			stats[room.room_id,user] = usrstats1
			stats[room.room_id,nick] = usrstats2


@not_myself
def last(room,event): # Regarde la dernière fois que quelqu'un a écrit un message
	global modules
	try:
		rmod = modules[room.room_id, 'stats']
	except:
		modules[room.room_id, 'stats'] = False
	if (modules[room.room_id, 'stats']):
		global stats
		args = event['content']['body'].split()
		args.pop(0)
		pers = ""
		if (len(args) >= 1 and args[0] == "all"):
			max_sign = "+"
			max_duree = 0
			if (len(args) > 1):
				max_sign = args[1][0]
				max_duree = int(args[1][1:])
			ref_duree = datetime.now() - timedelta(days=max_duree)
			salon = verifPMRoom(room,event)
			all_usr = {}
			reponse = "Les gens ayant posté à " + max_sign + " de " + str(max_duree) + " jours :\n"
			for cle,valeur in stats.items():
				if (cle[0] == room.room_id):
					usrstats = stats[room.room_id,cle[1]]
					if ((usrstats.user in all_usr and all_usr[usrstats.user].date < usrstats.date) or not usrstats.user in all_usr):
						all_usr[usrstats.user] = usrstats
			for user,usrstats in all_usr.items():
				if ((max_sign == "+" and usrstats.date < ref_duree) or ((max_sign == "-" and usrstats.date > ref_duree))):
					reponse += "- " + usrstats.nick + "(" + user + ")" + " le " + usrstats.date.strftime("%Y-%m-%d %H:%M:%S") + "\n"
			msg(salon, reponse,event['sender'])
		elif (len(args) >= 1 and args[0] == "inactifs"):
			max_sign = "+"
			max_duree = 0
			max_mess = 0
			if (len(args) > 2):
				max_sign = args[1][0]
				max_duree = int(args[1][1:])
				max_mess = int(args[2])
			ref_duree = datetime.now() - timedelta(days=max_duree)
			salon = verifPMRoom(room,event)
			all_usr = {}
			reponse = "Les gens ayant posté à " + max_sign + " de " + str(max_duree) + " jours et n'ayant pas plus de " + str(max_mess) + " messages :\n"
			for cle,valeur in stats.items():
				if (cle[0] == room.room_id):
					usrstats = stats[room.room_id,cle[1]]
					if ((usrstats.user in all_usr and all_usr[usrstats.user].date < usrstats.date) or not usrstats.user in all_usr):
						all_usr[usrstats.user] = usrstats
			for user,usrstats in all_usr.items():
				if (((max_sign == "+" and usrstats.date < ref_duree) or ((max_sign == "-" and usrstats.date > ref_duree))) and usrstats.mess <= max_mess):
					reponse += "- " + usrstats.nick + "(" + user + ")" + " le " + usrstats.date.strftime("%Y-%m-%d %H:%M:%S") + "\n"
			msg(salon, reponse,event['sender'])
		else:
			if (len(args) == 0):
				pers = getNick(room,event)
			else:
				pers=" ".join(args)
			try:
				usrstats = stats[room.room_id,pers]
				msg(room,"J'ai vu " + usrstats.nick + " poster pour la derniere fois le " + usrstats.date.strftime("%Y-%m-%d %H:%M:%S"),event['sender'])
			except:
				msg(room,pers + " : Personne non reconnue",event['sender'])
				#for cle,valeur in stats.items():
				#	if (cle[0] == room.room_id):
				#		msg(room,cle[1] + "\n",event['sender'])


@not_myself
def actif(room,event): # Stats d'activité d'une personne
	global modules
	try:
		rmod = modules[room.room_id, 'stats']
	except:
		modules[room.room_id, 'stats'] = False
	if (modules[room.room_id, 'stats']):
		global stats
		args = event['content']['body'].split()
		args.pop(0)
		if (len(args) > 0 and args[0] == "list"):
			salon = verifPMRoom(room,event)
			room_act = []
			dupli_check = []
			for cle,valeur in stats.items():
				if (cle[0] == room.room_id):
					room_act.append(valeur)
			room_act.sort(key=lambda us: us.mess, reverse=True)
			reponse="Voici le tableau des plus gros posteurs!\n"
			for us in room_act:
				if us.user not in dupli_check:
					dupli_check.append(us.user)
					reponse = reponse + us.nick + " : " + str(us.mess) + "\n"
			msg(salon,reponse,event['sender'])
		else:
			pers = ""
			if (len(args) == 0):
				pers = getNick(room,event)
			else:
				pers=" ".join(args)
			try:
				usrstats = stats[room.room_id,pers]
				moy = "{:10.2f}".format(usrstats.char / usrstats.mess)
				msg(room,usrstats.nick + " a poste " + str(usrstats.mess) + " messages avec une moyenne de " + moy + " caracteres par message",event['sender'])
			except:
				msg(room,pers + " : Personne non reconnue\n",event['sender'])

@not_myself
def nb_kap(room,event):
	global modules
	try:
		rmod = modules[room.room_id, 'stats']
	except:
		modules[room.room_id, 'stats'] = False
	if (modules[room.room_id, 'stats']):
		global stats
		args = event['content']['body'].split()
		args.pop(0)
		pers = ""
		if (len(args) == 0):
			pers = getNick(room,event)
		else:
			pers=" ".join(args)
		try:
			usrstats = stats[room.room_id,pers]
			if (usrstats.kapoue < 10):
				msg(room,usrstats.nick + " a crié " + str(usrstats.kapoue) + " KAPOUE!",event['sender'])
			elif (usrstats.kapoue < 50):
				msg(room,usrstats.nick + " a crié " + str(usrstats.kapoue) + " KAPOUE! Pendez le!",event['sender'])
			elif (usrstats.kapoue < 150):
				msg(room,usrstats.nick + " a crié " + str(usrstats.kapoue) + " KAPOUE! Brûlez le vif!",event['sender'])
			else:
				msg(room,usrstats.nick + " a crié " + str(usrstats.kapoue) + " KAPOUE! Faites le manger par des fourmis! Pauvres bêtes...",event['sender'])
		except:
			msg(room,pers + " : Personne non reconnue\n",event['sender'])

@not_myself
def quote(room,event): # Gestion des citations
	global modules
	try:
		rmod = modules[room.room_id, 'quote']
	except:
		modules[room.room_id, 'quote'] = False
	if (modules[room.room_id, 'quote']):
		global quotes
		args = event['content']['body'].split()
		args.pop(0)
		famous = {}
		try:
			famous = quotes[room.room_id]
		except:
			famous = {}

		if (len(args) > 3 and args[0] == "add"):
			#ajoute une quote
			args.pop(0)
			submit = " ".join(args).split(":")
			if (len(submit) > 1):
				# Ajout de la citation
				nick = submit[0].strip()
				submit.pop(0)
				citation = ":".join(submit)
				tps = datetime.now().microsecond
				famous[nick,tps] = citation
				quotes[room.room_id] = famous
				msg(room,"Ajout de la citation de " + nick + ":" + citation,event['sender'])
			else:
				# message d'aide
				msg(room,"!quote add <nick>:<citation>",event['sender'])
		elif (len(args) > 0 and args[0] == "list"):
			# liste les quotes
			args.pop(0)
			salon = verifPMRoom(room,event)
			if (len(args) == 0):
				# Liste les quotes du salon
				reponse = "Voici les reponses du salon " + room.room_id + "\n"
				if (len(room.aliases) > 0):
					reponse = reponse + "(alias : " + room.aliases[0] + "\n"
				for cle,valeur in famous.items():
					reponse = reponse + cle[0] + " / " + str(cle[1]) + " : " + valeur + "\n"
					if (len(reponse) > 500):
						msg(salon,reponse,event['sender'])
						reponse = ""
				msg(salon,reponse,event['sender'])
			elif (args[0] == "all"):
				# toutes les quotes de tous les salons
				reponse = "Les citations de tous les salons : " + "\n"
				msg(salon,reponse,event['sender'])
				for rid,fame in quotes.items():
					reponse = "Voici les reponses du salon " + rid + "\n"
					for cle,valeur in fame.items():
						reponse = reponse + cle[0] + " / " + str(cle[1]) + " : " + valeur + "\n"
						if (len(reponse) > 500):
							msg(salon,reponse,event['sender'])
							reponse = ""
					msg(salon,reponse,event['sender'])
			else:
				# les quotes du pseudo spécifié
				nick = " ".join(args)
				reponse = "Voici les citations enregistrées de " + nick + "\n"
				for cle,valeur in famous.items():
					if (cle[0] == nick):
						reponse = reponse + cle[0] + " / " + str(cle[1]) + " : " + valeur + "\n"
				msg(salon,reponse,event['sender'])
		elif (len(args) > 1 and args[0] == "del"):
			salon = verifPMRoom(room,event)
			lmod = modos[room.room_id]
			if (event['sender'] in admins):
				id = args[1]
				reponse = "Voici la citation supprimée : \n"		
				for rid,fame in quotes.items():
					for cle,valeur in fame.items():
						if (str(cle[1]) == id):
							del fame[cle[0],cle[1]]
							reponse = reponse + rid + " / " + cle[0] + " / " + str(cle[1]) + " : " + valeur + "\n"
							break
				msg(salon,reponse,event['sender'])
			elif (event['sender'] in lmod):
				id = args[1]
				reponse = "Voici la citation supprimée : \n"
				rid = room.room_id		
				fame = quotes[rid]
				for cle,valeur in fame.items():
					if (str(cle[1]) == id):
						del fame[cle[0],cle[1]]
						reponse = reponse + rid + " / " + cle[0] + " / " + str(cle[1]) + " : " + valeur + "\n"
						break
				msg(salon,reponse,event['sender'])
			else:
				msg(salon,"Vous n'êtes pas autorisés à supprimer des citations.",event['sender'])
		elif (len(args) > 0):
			# cite une quote d'une personne precise
			nick = " ".join(args)
			phrases = []
			for cle,valeur in famous.items():
				if (cle[0] == nick):
					phrases.append(cle[0] + " : " + valeur)
			if (len(phrases) > 0 ):
				reponses(room,phrases)
			else:
				msg(room,"Je n'ai pas de citations pour " + nick,event['sender'])
		else:
			# cite une quote aleatoire
			phrases = []
			for cle,valeur in famous.items():
				phrases.append(cle[0] + " : " + valeur)
			if (len(phrases) > 0 ):
				reponses(room,phrases)
			else:
				msg(room,"Je n'ai pas de citations pour ce salon",event['sender'])

@not_myself
def salon(room,event): # Gestion des listes de salons recommandes
	global modules
	try:
		rmod = modules[room.room_id, 'salon']
	except:
		modules[room.room_id, 'salon'] = False
	if (modules[room.room_id, 'salon']):
		global salons
		args = event['content']['body'].split()
		args.pop(0)
		famous = {}
		try:
			famous = salons[room.room_id]
		except:
			famous = {}

		if (len(args) > 3 and args[0] == "add"):
			#ajoute un salon recommande
			ref = ""
			desc = ""
			args.pop(0)
			if (args[0] == "desc"):
				args.pop(0)
				ref = "desc"
				desc = " ".join(args)
			else:
				ref = args[0]
				args.pop(0)
				desc = " ".join(args)
			famous[ref] = desc
			salons[room.room_id] = famous
			msg(room,"Ajout du salon " + ref + " : " + desc,event['sender'])
		elif (len(args) > 1 and args[0] == "del"):
			salon = verifPMRoom(room,event)
			lmod = modos[room.room_id]
			if (event['sender'] in admins):
				id = args[1]
				reponse = "Voici le salon supprimé : \n"
				rid = room.room_id		
				fame = salons[rid]
				for cle,valeur in fame.items():
					if (str(cle) == id):
						del fame[cle]
						reponse = reponse + rid + " / " + cle + " : " + valeur + "\n"
						break
				msg(room,reponse,event['sender'])
			elif (event['sender'] in lmod):
				id = args[1]
				reponse = "Voici le salon supprimé : \n"
				rid = room.room_id		
				fame = salons[rid]
				for cle,valeur in fame.items():
					if (str(cle) == id):
						del fame[cle]
						reponse = reponse + rid + " / " + cle + " : " + valeur + "\n"
						break
				msg(room,reponse,event['sender'])
			else:
				msg(salon,"Vous n'êtes pas autorisés à supprimer des salons.",event['sender'])
		elif (len(args) > 0):
			# cite un salon precis
			ref = args[0]
			trouve = 0
			for cle,valeur in famous.items():
				if (cle == ref):
					msg(salon,cle + " : " + valeur,event['sender'])
					trouve = 1
					break
			if (trouve == 0):
				msg(room,"Je n'ai pas de salons nomme " + ref,event['sender'])
		else:
			# cite tous les salons
			reponse = ""
			trouve = 0
			if ("desc" in famous):
				reponse = reponse + famous["desc"] + "\n"
			for cle,valeur in famous.items():
				if (cle != "desc"):
					reponse = reponse + cle + " : " + valeur + "\n"
					trouve = 1
			if (trouve == 0):
				msg(room,"Je n'ai pas de salons recommandes pour ce salon",event['sender'])
			else:
				msg(room,reponse,event['sender'])

@not_myself
def addquote(room,event): # enregistrer les citations mode reponses matrix
	global modules
	try:
		rmod = modules[room.room_id, 'quote']
	except:
		modules[room.room_id, 'quote'] = False
	if (modules[room.room_id, 'quote']):
		global citations

		content = event['content']
		if len(json.dumps(content)) > 420:	
			# Enlève la commande de la citation
			try:
				content['body'] = content['body'].replace("\n!addquote", " ")
				content['body'] = content['body'].replace("\n!", "\n")
			except:
				print("\n\nerreur body " + json.dumps(content))
			try:
				content['formatted_body'] = content['formatted_body'].replace("<p>!addquote</p>\n", "")
				content['formatted_body'] = content['formatted_body'].replace("!addquote", "")
				content['formatted_body'] = content['formatted_body'].replace("<p>!", "<p>")
			except:
				print("\n\nerreur formatted_body " + json.dumps(content))

			# Récupération de l'auteur
			auteur = "Un nain connu"
			match = re.search(r"<(@\w+:\w+.\w+)>", content['body'])
			if match:
				auteur = match.group(1)

			# Id
			tps = datetime.now().microsecond

			# récupérations des citations du salon
			famous = {}
			try:
				famous = citations[room.room_id]
			except:
				famous = {}

			# enregistrement de la citation
			famous[auteur,tps] = content
			citations[room.room_id] = famous
			msg(room,"Ajout de la citation de " + auteur + ":",event['sender'])
			bot.client.api.send_message_event(room.room_id, 'm.room.message', content, None, None)

@not_myself
def showquote(room, event): # afficher les citations mode reponse matrix
	global modules
	try:
		rmod = modules[room.room_id, 'quote']
	except:
		modules[room.room_id, 'quote'] = False
	if (modules[room.room_id, 'quote']):
		args = event['content']['body'].split()
		args.pop(0)
		famous = {}
		try:
			famous = citations[room.room_id]
		except:
			famous = {}

		if (len(args) == 1):
			# cite une quote d'une personne precise
			nick = args[0]
			phrases = []
			for cle,valeur in famous.items():
				if (cle[0] == nick):
					phrases.append(valeur)
			if (len(phrases) > 0 ):
				reponses(room,phrases,True)
			else:
				msg(room,"Je n'ai pas de citations pour " + nick,event['sender'])
		else:
			# cite une quote aleatoire
			phrases = []
			for cle,valeur in famous.items():
				phrases.append(valeur)
			if (len(phrases) > 0 ):
				reponses(room,phrases,True)
			else:
				msg(room,"Je n'ai pas de citations pour ce salon",event['sender'])

@not_myself
def biere(room,event): # Gestion des boissons
	global modules
	try:
		rmod = modules[room.room_id, 'biere']
	except:
		modules[room.room_id, 'biere'] = False
	power = 0
	if (modules[room.room_id, 'biere']):
		lmod = modos[room.room_id]
		if (event['sender'] in admins or event['sender'] in lmod):
			power = 1
		global bieres
		args = event['content']['body'].split()
		args.pop(0)
		breuvages = {}
		give = False
		elu = ""
		envoyeur = getNick(room,event)

		try:
			breuvages = bieres[room.room_id]
		except:
			breuvages = {}

		if (len(args) > 1 and args[0] == "give"):
			give = True
			args.pop(0)
			submit = " ".join(args).split(":")
			elu = submit[0]
			if (power == 0):
				elu = elu.replace('@room', 'tout le monde')
			try:
				args = submit[1].split()
			except:
				args = ""
		if (len(args) > 2 and args[0] == "add"):
			#ajoute une biere
			args.pop(0)
			submit = " ".join(args).split(":")
			if (len(submit) > 1):
				# Ajout de la citation
				nick = submit[0].strip()
				nick = nick.replace('@room', 'tous')
				submit.pop(0)
				citation = ":".join(submit)
				citation = citation.replace('@room', 'tout le monde')
				tps = datetime.now().microsecond
				breuvages[nick,tps] = citation
				bieres[room.room_id] = breuvages
				msg(room,"Ajout du breuvage " + nick + ":" + citation,event['sender'])
			else:
				# message d'aide
				msg(room,"!biere add <nick>:<citation>",event['sender'])
		elif (len(args) > 0 and args[0] == "list"):
			# liste les quotes
			args.pop(0)
			salon = verifPMRoom(room,event)
			if (len(args) == 0):
				# Liste les breuvages du salon
				reponse = "Voici les reponses du salon " + room.room_id + "\n"
				if (len(room.aliases) > 0):
					reponse = reponse + "(alias : " + room.aliases[0] + "\n"
				for cle,valeur in breuvages.items():
					reponse = reponse + cle[0] + " / " + str(cle[1]) + " : " + valeur + "\n"
					if (len(reponse) > 500):
						msg(salon,reponse,event['sender'])
						reponse = ""
				msg(salon,reponse,event['sender'])
			elif (args[0] == "all"):
				# tous les breuvages de tous les salons
				reponse = "Les breuvages de tous les salons : " + "\n"
				msg(salon,reponse,event['sender'])
				for rid,fame in bieres.items():
					reponse = "Voici les reponses du salon " + rid + "\n"
					for cle,valeur in fame.items():
						reponse = reponse + cle[0] + " / " + str(cle[1]) + " : " + valeur + "\n"
						if (len(reponse) > 500):
							msg(salon,reponse,event['sender'])
							reponse = ""
					msg(salon,reponse,event['sender'])
			else:
				# les breuvages du pseudo spécifié
				nick = " ".join(args)
				reponse = "Voici les reponses du breuvage " + nick + "\n"
				for cle,valeur in breuvages.items():
					if (cle[0] == nick):
						reponse = reponse + cle[0] + " / " + str(cle[1]) + " : " + valeur + "\n"
				msg(salon,reponse,event['sender'])
		elif (len(args) > 1 and args[0] == "del"):
			salon = verifPMRoom(room,event)
			lmod = modos[room.room_id]
			if (event['sender'] in admins):
				id = args[1]
				reponse = "Voici le breuvage supprimé : \n"		
				for rid,fame in bieres.items():
					for cle,valeur in fame.items():
						if (str(cle[1]) == id):
							del fame[cle[0],cle[1]]
							reponse = reponse + rid + " / " + cle[0] + " / " + str(cle[1]) + " : " + valeur + "\n"
							break
				msg(salon,reponse,event['sender'])
			elif (event['sender'] in lmod):
				id = args[1]
				reponse = "Voici le breuvage supprimé : \n"
				rid = room.room_id		
				fame = bieres[rid]
				for cle,valeur in fame.items():
					if (str(cle[1]) == id):
						del fame[cle[0],cle[1]]
						reponse = reponse + rid + " / " + cle[0] + " / " + str(cle[1]) + " : " + valeur + "\n"
						break
				msg(salon,reponse,event['sender'])
			else:
				msg(salon,"Vous n'êtes pas autorisés à supprimer des breuvages.",event['sender'])
		elif (len(args) > 0):
			# cite une reponse d'un breuvage precis
			nick = " ".join(args)
			phrases = []
			for cle,valeur in breuvages.items():
				if (cle[0] == nick):
					if (give):
						phrases.append(valeur + " pour " + elu + " de la part de " + envoyeur)
					else:
						phrases.append(valeur + " pour " + envoyeur)
			if (len(phrases) > 0 ):
				reponses(room,phrases)	
			else:
				msg(room,"Je n'ai pas de " + nick + " en stock!",event['sender'])
		else:
			# cite une réponse d'un breuvage aleatoire
			phrases = []
			for cle,valeur in breuvages.items():
				if (give):
					phrases.append(valeur + " pour " + elu + " de la part de " + envoyeur)
				else:
					phrases.append(valeur + " pour " + envoyeur)
			if (len(phrases) > 0 ):
				reponses(room,phrases)
			else:
				msg(room,"Je n'ai pas de breuvages pour ce salon",event['sender'])

@not_myself
def boissons(room,event): # Gestion des alias de boissons
	global modules
	try:
		rmod = modules[room.room_id, 'biere']
	except:
		modules[room.room_id, 'biere'] = False
	if (modules[room.room_id, 'biere']):
		boisson = ""
		elu = ""

		args = event['content']['body'].split()
		try:
			boisson = args[0][1:]
		except:
			boisson = ""
		args.pop(0)

		if (len(args) > 0):
			elu = " ".join(args)

		if (len(elu) > 0 and len(boisson) > 0):
			event['content']['body'] = "!biere give " + elu + ":" + boisson
		elif (len(elu) > 0):
			event['content']['body'] = "!biere give " + elu
		elif (len(boisson) > 0):
			event['content']['body'] = "!biere " + boisson
		else:
			event['content']['body'] = "!biere"

		biere(room,event)

@not_myself
def accueil(room,event): # Mettre un message d'accueil
	global modules
	try:
		rmod = modules[room.room_id, 'welcome']
	except:
		modules[room.room_id, 'welcome'] = False
	if (modules[room.room_id, 'welcome']):
		lmod = modos[room.room_id]
		if (event['sender'] in admins or event['sender'] in lmod):
			global welcome
			args = event['content']['body'].split()
			args.pop(0)
			reponse = " ".join(args)
			if (len(args) > 0):
				welcome[room.room_id] = reponse
				msg(room,"Le message d'accueil est désormais : " + reponse,event['sender'])

		else:
			msg(salon,"Vous n'êtes pas autorisés à modifier le message d'accueil.",event['sender'])

def bienvenue(event): # Affichage d'un message d'accueil aux nouveaux venus
	room_id = event['room_id']
	room = bot.client.rooms[room_id]
	global modules
	try:
		rmod = modules[room.room_id, 'welcome']
	except:
		modules[room.room_id, 'welcome'] = False
	if (modules[room.room_id, 'welcome'] and not event['sender'] == bot.client.user_id):
		membership = event['content']['membership']
		prev_member = event.get('unsigned',{}).get('prev_content',{}).get('membership', None)
		nick = getNick(room,event)
		if room.name:
			alias = room.name
		elif room.canonical_alias:
			alias = room.canonical_alias 
		elif room.aliases:
			alias = room.aliases[0] 
		else:
			alias = ""
		reponse = ""
		try:
		#if (len(welcome[room.room_id]) > 0):
			reponse = welcome[room.room_id]
		except:
			reponse = ""
		if (membership == "join" and prev_member != "join"):
			msg(room,"Bienvenue sur " + alias + ", " + nick + ". " + reponse,event['sender'])

@not_myself
def addmails(room,event): # Abonnements mail aux messages
	try:
		rmod = modules[room.room_id, 'mails']
	except:
		modules[room.room_id, 'mails'] = False
	if (modules[room.room_id, 'mails']):
		lmails = []
		try:
			lmails = mails[room.room_id]
		except:
			lmails = []
		if (event['sender'] in admins or event['sender'] in lmod or event['sender'] == bot.client.user_id):
			args = event['content']['body'].split()
			args.pop(0)
			if (len(args) > 1 and args[0] == "add"):
				args.pop(0)
				mail = args[0]
				if (not mail in lmails):
					lmails.append(mail)
					mails[room.room_id] = lmails
					msg(room,mail + " recevra des mails.",event['sender'])
				else:
					msg(room,mail + " reçoit déjà des mails.",event['sender'])
			elif (len(args) > 1 and args[0] == "del"):
				args.pop(0)
				mail = args[0]
				if (mail in lmails):
					place = lmails.index(mail)
					del lmails[place]
					mails[room.room_id] = lmails
					msg(room,mail + " ne recevra plus de mails.",event['sender'])
				else:
					msg(room,mail + " ne reçoit pas de mails.",event['sender'])
			else:
				msg(room,"\n".join(lmails),event['sender'])
		else:
			msg(salon,"Vous n'êtes pas autorisés à définir les réceptions de mails pour ce salon.",event['sender'])

@not_myself
def envoi_mail(room,event): # envoi des messages aux abonnés par mail
	global modules
	try:
		rmod = modules[room.room_id, 'mails']
	except:
		modules[room.room_id, 'mails'] = False
	if (modules[room.room_id, 'mails']):
		lmails = []
		try:
			lmails = mails[room.room_id]
		except:
			lmails = []
		sender = event['sender']
		try:
			body = event['content']['body']
		except:
			body = ""
		for mail in lmails:
			if (malt == "1"):
				os.system('echo ' + body + ' | mailx -s ' + sender + ' -r ' + msender + ' ' + mail)
			else:
				serveur = smtplib.SMTP(msmtp, mport)
				serveur.starttls()
				serveur.login(msender, mpass)
				message = sender + " : " + body
				serveur.sendmail(msender, mail, message)
				serveur.quit()

@not_myself
def modo(room,event): # Definition d'un moderateur
	global modos
	lmod = []
	try:
		lmod = modos[room.room_id]
	except:
		lmod = []
	if (event['sender'] in admins or event['sender'] in lmod or event['sender'] == bot.client.user_id):	
		args = event['content']['body'].split()
		args.pop(0)
		if (len(args) > 1 and args[0] == "add"):
			args.pop(0)
			candidat = " ".join(args)
			if (not candidat in lmod):
				lmod.append(candidat)
				modos[room.room_id] = lmod
				msg(room,candidat + " devient moderateur.",event['sender'])
			else:
				msg(room,candidat + " est déjà moderateur.",event['sender'])
		elif (len(args) > 1 and args[0] == "del"):
			args.pop(0)
			candidat = " ".join(args)
			if (candidat in lmod):
				place = lmod.index(candidat)
				del lmod[place]
				modos[room.room_id] = lmod
				msg(room,candidat + " n'est plus moderateur.",event['sender'])
			else:
				msg(room,candidat + " n'est pas moderateur.",event['sender'])
		else:
			msg(room,"\n".join(lmod),event['sender'])
	else:
		msg(salon,"Vous n'êtes pas autorisés à définir les modérateurs.",event['sender'])

@not_myself
def module(room,event): # Definition des modules d'un salon
	lmod = []
	try:
		lmod = modos[room.room_id]
	except:
		lmod = []
	if (event['sender'] in admins or event['sender'] in lmod or event['sender'] == bot.client.user_id):
		global modules
		args = event['content']['body'].split()
		args.pop(0)
		if (len(args) == 2 and args[0] == "add"):
			args.pop(0)
			rmod = args[0]
			if (rmod in liste_mod):
				modules[room.room_id, rmod] = True
				msg(room,"Module : " + rmod + " activé.",event['sender'])
			else:
				msg(room,"Module : " + rmod + " inconnu.",event['sender'])
				#print(liste_mod)
		elif (len(args) == 2 and args[0] == "del"):
			args.pop(0)
			rmod = args[0]
			if (rmod in liste_mod):
				modules[room.room_id, rmod] = False
				msg(room,"Module : " + rmod + " désactivé.",event['sender'])
			else:
				msg(room,"Module : " + rmod + " inconnu.",event['sender'])
		else:
			# Lister les modules actifs du salon
			rmod = ""
			for cle,valeur in modules.items():
				if (cle[0] == room.room_id and valeur == True):
					rmod = rmod + cle[1] + ", "
			if (len(rmod) > 1):
				rmod = rmod[:-2]
			msg(room,"Modules actuels : " + rmod,event['sender'])
			# Lister les modules disponibles
			dmod = ""			
			for val in liste_mod:
				dmod = dmod + val + ", "
			if (len(dmod) > 1):
				dmod = dmod[:-2]
			msg(room,"Modules disponibles : " + dmod,event['sender'])
	else:
		msg(room,"Vous n'êtes pas autorisés à définir les modules du salon.",event['sender'])


def invitations(room_id, state): # Reponse aux invitations
	try:
		global bot
		bot.client.join_room(room_id)
		global modules
		if ('welcome' in liste_mod):
			modules[room_id, 'welcome'] = True
		if ('roll' in liste_mod):
			modules[room_id, 'roll'] = True
		if ('quote' in liste_mod):
			modules[room_id, 'quote'] = True
		if ('liste' in liste_mod):
			modules[room_id, 'liste'] = True
		global modos
		if (modos.get(room_id,True) or len(modos[room_id]) == 0):
			sender = state['events'][0]['sender']
			modos[room_id] = [sender]
	except:
		print("Impossible de rejoindre ce salon")
	time.sleep(2)
	del bot
	save_obj()
	main()

def kick(room, event): # kick une liste de membres
	global modules
	try:
		rmod = modules[room.room_id, 'kick']
	except:
		modules[room.room_id, 'kick'] = False
	if (modules[room.room_id, 'kick']):
		lmod = []
		try:
			lmod = modos[room.room_id]
		except:
			lmod = []
		if (event['sender'] in admins or event['sender'] in lmod or event['sender'] == bot.client.user_id):
			args = event['content']['body'].split()
			args.pop(0)
			while (len(args) > 0):
				try:
					bot.client.api.kick_user(room.room_id, args[0], reason="")
				except:
					msg(room, "Vous ne pouvez pas expulser args[0]",event['sender'])
				args.pop(0)
		else:
			msg(room,"Vous n'êtes pas autorisés à kicker des membres de ce salon.",event['sender'])
			
			
def titre(room, event): # cherche le titre d'une page
	global modules
	try:
		rmod = modules[room.room_id, 'titre']
	except:
		modules[room.room_id, 'titre'] = False
	if (modules[room.room_id, 'titre']):
		args = event['content']['body'].split()
		args.pop(0)
		try:
			url=args[0]
			if (re.search(r"^.*://",url) is None):
				url = "http://" + url
			r = requests.get(url)
			res = re.search(r"<title>(.*)</title>",r.text)
			if (res is not None):
				msg(room,html2text.html2text(str(re.sub("</?title>", "", res.group()))),event['sender'])
			else:
				msg(room,"Titre non trouvé",event['sender'])
			if (re.search(r"http[s]?://(www\.)?youtube\.",url) is not None and modules[room.room_id, 'invidious'] is False and not event['sender'] == bot.client.user_id):
				res = re.sub(r"^.*\?v=(\w+).*$", r"\1", url, 0, re.MULTILINE)
				msg(room,str("https://invidious.fdn.fr/watch?v=" + res),event['sender'])
		except:
			msg(room,"URL invalide",event['sender'])
			

def invidious(room, event): # convertit un lien youtube en lien invidious
	global modules
	try:
		rmod = modules[room.room_id, 'invidious']
	except:
		modules[room.room_id, 'invidious'] = False
	if (modules[room.room_id, 'invidious'] and not event['sender'] == bot.client.user_id):
		url = event['content']['body']
		try:
			res = re.sub(r"^.*\?v=(\w+).*$", r"\1", url, 0, re.MULTILINE)
			msg(room,str("Une alternative pour cette video : https://invidious.fdn.fr/watch?v=" + res),event['sender'])
		except:
			msg(room,"URL invalide",event['sender'])


def main():
	global USERNAME
	config = configparser.ConfigParser()
	config.read('asmodee.ini')
	USERNAME = ""  # Bot's username
	PASSWORD = ""  # Bot's password
	SERVER = ""  # Matrix server URL
	mods = ["roll", "quote", "biere", "stats", "liste", "horloge", "carte", "card", "cristal", "welcome", "salut", "jdr", "gens", "va", "salon", "kick", "mails", "titre", "invidious"]
	global admins
	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
		admins = config['AUTH']['admin'].split(",")  # Admins du bot @admin1:host.tld,@admin2:host.tld,...
	else:
		print("Probleme de lecture de configuration asmodee.ini")

	global liste_mod
	if ('MOD' in config):
		try:
			liste_mod = config['MOD']['liste'].split(',') # Liste des modules
		except:
			liste_mod = mods
	else:
		liste_mod = mods
	
	global malt
	global msender
	global mpass
	global msmtp
	global mport
	if ('MAIL' in config):
		try:
			malt = config['MAIL']['malt']
			msender = config['MAIL']['msender']
			mpass = config['MAIL']['mpass']
			msmtp = config['MAIL']['msmtp']
			mport = config['MAIL']['mport']
		except:
			malt = 0
			msender = ""
			mpass = ""
			msmtp = ""
			mport = ""
	
	# Create an instance of the MatrixBotAPI
	global bot
	bot = MatrixBotAPI(USERNAME, PASSWORD, SERVER)

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

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

	# Add a regex handler waiting for the dice commands and aliases
	if ('roll' in liste_mod):
		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
	if ('card' in liste_mod):
		card_handler = MCommandHandler("card", card)
		bot.add_handler(card_handler)
	if ('carte' in liste_mod):
		carte_handler = MCommandHandler("carte", carte)
		bot.add_handler(carte_handler)
	
	# Un élément d'une liste
	if ('liste' in liste_mod):
		liste_handler = MCommandHandler("liste", liste)
		bot.add_handler(liste_handler)
	
	# Boule de cristal
	if ('cristal' in liste_mod):
		cristal_handler = MCommandHandler("cristal", cristal)
		bot.add_handler(cristal_handler)
	
	if (threading.current_thread().__class__.__name__ == '_MainThread'):
		print("main thread")
		signal.signal(signal.SIGINT, signal_handler)

	# horloges
	if ('horloge' in liste_mod):
		horloge_read()	
		horloge_handler = MCommandHandler("horloge", horloge)
		bot.add_handler(horloge_handler)
	
	# stats
	if ('stats' in liste_mod):
		stats_read()
		stats_handler = MAllHandler(statistiques)
		bot.add_handler(stats_handler)
		last_handler = MCommandHandler("last", last)
		bot.add_handler(last_handler)
		actif_handler = MCommandHandler("actif", actif)
		bot.add_handler(actif_handler)
		nb_kap_handler = MCommandHandler("nb_kap", nb_kap)
		bot.add_handler(nb_kap_handler)
	
	# quotes
	if ('quote' in liste_mod):
		quotes_read()
		quote_handler = MCommandHandler("quote", quote)
		bot.add_handler(quote_handler)
		citations_read()
		addquote_handler = MEndHandler("!addquote", addquote)
		bot.add_handler(addquote_handler)
		showquote_handler = MCommandHandler("showquote", showquote)
		bot.add_handler(showquote_handler)

	# bieres
	if ('biere' in liste_mod):
		bieres_read()
		biere_handler = MCommandHandler("biere", biere)
		bot.add_handler(biere_handler)
		boisson_handler = MCommandHandler("", boissons, '%')
		bot.add_handler(boisson_handler)	

	# salons
	if ('salon' in liste_mod):
		salons_read()
		salon_handler = MCommandHandler("salon", salon)
		bot.add_handler(salon_handler)

	# Accueil
	if ('welcome' in liste_mod):
		welcome_read()
		welcome_handler = MCommandHandler("accueil", accueil)
		bot.add_handler(welcome_handler)
		bot.client.add_listener(bienvenue, event_type="m.room.member")

	# Kick
	if ('kick' in liste_mod):
		kick_handler = MCommandHandler("kick", kick)
		bot.add_handler(kick_handler)

	# Mails
	if ('mails' in liste_mod):
		mails_read()
		mails_handler = MCommandHandler("mail", addmails)
		bot.add_handler(mails_handler)
		envoi_mail_handler = MAllHandler(envoi_mail)
		bot.add_handler(envoi_mail_handler)
	# Titre
	if ('titre' in liste_mod):
		titre_handler = MCommandHandler("titre", titre)
		bot.add_handler(titre_handler)
	
	# Invidious
	if ('invidious' in liste_mod):
		invidious_handler = MRegexHandler("http[s]?://(www\.)?youtube\.", invidious)
		bot.add_handler(invidious_handler)
		
	# Definition des moderateurs
	modos_read()
	modos_handler = MCommandHandler("modo", modo)
	bot.add_handler(modos_handler)

	# Definition des modules
	modules_read()
	modules_handler = MCommandHandler("module", module)
	bot.add_handler(modules_handler)

	# sauvegarde
	save_handler = MCommandHandler("save", save_obj)
	bot.add_handler(save_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()
		time.sleep(5)


if __name__ == "__main__":
	main()