C'est cool d'être daemonizable

[bots/themis.git] / themis.py

#!/usr/bin/python
# -*- coding:utf8 -*-
# Codé par 20-100 (commencé le 21/06/12)

# Un bot IRC pour kicker à tour de bras de #déprime

import threading
import random
import time
import socket, ssl, json
import pickle
import re
import os
import signal
import sys

# Oui, j'ai recodé ma version d'irclib pour pouvoir rattrapper les SIGHUP
sys.path.insert(0, "/home/vincent/scripts/python-myirclib")
import irclib
import ircbot

import sys
config_debug_stdout=True
if "--quiet" in sys.argv:
    config_debug_stdout=False

config_irc_password="YouMustObeyGaétan"
config_irc_pseudo="Themis"
config_chanlist=["#déprime"]
config_stay_channels=["#déprime"]
config_quiet_channels=[]
config_logfile_template="themis.%s.log"
def get_config_logfile(serveur):
    serveurs={"acoeur.crans.org":"acoeur","irc.crans.org":"crans"}
    return config_logfile_template%(serveurs[serveur])
config_overops=["[20-100]","Gaetan"]
config_ops=[]
config_report_bugs_to=["[20-100]"]

# config UTF8-fail
config_utf8_fail = [u"Ton encodage me déprime…"]
config_utf8_trigger = True
# config "tu m'traites ?"
config_insultes=[u"conna(rd|sse)",u"pute",u"con(|ne)",u"enf(oiré|lure)",
u"sal(op(|e(|rie)|ard)|aud)",u"p(e|')tite bite",u"imbécile",u"idiot",u"stupid(|e)",u"débile",u"crétin",
u"pétasse",u"enculé",u"chagasse",u"cagole",u"abruti",u"ahuri",u"analphabète",u"andouille",
u"atardé",u"avorton",u"bachibouzouk",u"(balais|brosse) (de|à) chiotte(|s)",
u"batard",u"blaireau",u"bouffon",u"branque",u"bouseux",u"branleur",u"catin",u"chacal",
u"charogne",u"chiant(|e)",u"chieur",u"cochon",u"coprophage",u"couillon",u"crapule",u"crevard",
u"cruche",u"cuistre",u"ducon",u"décérébré",
u"emmerdeur",u"feignasse",u"fainéant",u"fourbe",u"freluquet",u"frigide",
u"garce",u"glandu",u"gogol",u"goujat",u"gourdasse",u"gredin",u"gringalet",u"grognasse",
u"naze",u"truie",u"iconoclaste",
u"peigne(-|)cul",u"ignare",u"illétré",u"lèche(|-)cul",u"malotru",u"motherfucker",u"nabot",u"nigaud",
u"nul",u"escroc",u"pouffiasse",u"pourriture",u"raclure",u"relou",u"sagouin",u"putain",
u"péripatéticienne"]
config_insultes_answers=[
u"Oh non ! Quelle insulte ! Je crois que je ne m'en relèverai jamais…\nEnfin presque.",
u"J'entends comme un vague murmure, vous disiez ?",
u"Je vais prendre ça pour un compliment.",
u"Vous savez, pour vous c'est peut-être une insulte, mais pour moi ce n'est qu'une suite de 0 et de 1…",
u"Permettez-moi de vous retourner le compliment.",
u"Votre indélicatesse vous sied à ravir.",
u"Parfois, je me demande pourquoi je fais encore ce métier…",
u"Le saviez-vous : l'invective ne déshonore que son auteur.",
u"Le saviez-vous : vous perdez plus de temps à m'insulter qu'à vous taire.",
u"Mais je ne vous permets pas ! Enfin, pas comme ça…"]

# config "jeu", d'ailleurs, j'ai perdu.
config_premier_groupe_terminaisons=u"(e|es|ons|ez|ent|er(|ai|as|a|ons|ez|ont)|(|er)(ais|ait|ions|iez|aient)|(a(i|s|)|â(mes|tes|t)|èrent)|ass(e(|s|nt)|i(ons|ez))|é(|s|e|es))"
config_regexp_etre=u"(être|suis|e(s|t)|so(mmes|nt)|êtes|(ét|ser)(ai(s|t|ent)|i(ons|ent)|)|ser(ai|as|a|ons|ez|ont)|so(i(s|t|ent)|y(ons|ez))|f(u(s|t|rent)|û(mes|tes|t))|fuss(e(|s|nt)|i(ons|ez))|étant)"
config_regexp_etre_avec_c=u"c'(e(s|st)|étai(t|ent))"
config_regexp_faire=u"fais"
config_perdu=[u"perd(|s|ons|ez|ent|r(e|ai|as|a|ons|ez|ont)|(|r)(ais|ait|ions|iez|aient))"
u"perd(i(s|t|rent)|î(mes|tes|t))", # oui, j'ai inclus qu'il perdît
u"perdiss(e(|s|nt)|i(ons|ez))",
u"perdu(|s|e|es)",u"perdant(|s|e|es)",u"perte(|s)",

u"(gagn|trouv)"+config_premier_groupe_terminaisons,u"gagnant(|s|e|es)",u"gain(|s)",

u"trouvant",u"trouvaille(|s)",

u"victoire(|s)",u"vaincu(|s|e|es)",
u"loose",u"lost",u"looser(|s)",u"win(|ner)(|s)",
u"jeu(|x)",u"game(|s)"]
config_time_between_perdu_trigger=3600*3 #temps moyen pour perdre en l'absence de trigger
config_time_between_perdu_trigger_delta = 30*60 #marge autorisée autour de ^^^
config_time_between_perdu=30*60 #temps pendant lequel on ne peut pas perdre

# config "tais-toi"
config_tag_triggers=[u"t(|a)g",u"ta gueule",u"la ferme",u"ferme( |-)la",u"tais-toi",u"chut",u"tu fais trop de bruit",u"tu parles trop"]
config_tag_actions=[u"se tait",u"se tient coi"]
config_tag_answers=[
u"Ç'aurait été avec plaisir, mais je ne crois pas que vous puissiez vous passer de mes services.",
u"Dès que cela sera utile.",
u"Une autre fois, peut-être.",
u"Si je me tais, qui vous rappellera combien vous me devez ?",
u"J'aurais aimé accéder à votre requête, mais après mûre réflexion, j'en ai perdu l'envie.",
u"Je ne ressens pas de besoin irrésistible de me taire, navré."]

# config ping
config_tesla_triggers=[u"t('|u )es là \?",u"\?",u"plop \?",u"plouf \?"]
config_tesla_answers=[
u"Oui, je suis là.",
]
config_tesla_actions=[u"déprime",u"est prêt à kicker les gens heureux"]

# config en cas de non-insulte
config_compliment_triggers=[u"gentil",u"cool",u"sympa",u"efficace"]
config_compliment_answers=[
u"Merci, c'est gentil de votre part. :)",
u"Permettez-moi de vous retourner le compliment, sans ironie cette fois.",
u"Je vous remercie.",
u"C'est trop d'honneur.",
u"Vous êtes bien aimable."
]

# config merci
config_merci_triggers=[u"merci",u"remercie",u"thx",u"thank(|s)"]
config_merci_answers=[u"Mais de rien.",u"À votre service. ;)",u"Quand vous voulez. :)",
u"Tout le plaisir est pour moi."]

# config "ta mère" 
config_tamere_triggers=[u"ta mère"]
config_tamere_answers=[u"Laissez donc ma mère en dehors de ça !",
u"Puis-je préciser que je n'ai pas de mère ? Seulement deux pères…",
u"""Un certain Max chantait "♩ J'ai vu ta mère sur chat rouleeeeeeette ♫", vous êtes de sa famille ?""",
u"""N'avait-on pas dit "pas les mamans" ?"""]

# config pour les actions désagréables
config_bad_action_triggers=[u"(frappe|cogne|tape)(| sur)",u"(démolit|dégomme|fouette|agresse|tabasse)",
u"(vomit|pisse|chie|crache) sur",u"slap(|s)"]
config_bad_action_answers=[
u"Je ne peux pas dire que j'apprécie, mais je l'ai sans doute bien mérité.",
u"{}: Pourquoi tant de violence en ce monde si doux ?",
u"""Si je n'étais pas aussi prude, je dirais "Mais euh…", cependant, je me contenterai de hausser un sourcil.""",
u"{}: J'aurais préféré que vous ne fassiez pas cela en public.",
u"{}: Entre nous, cela vous gratifie-t-il ?",
u"{}: Une telle relation entre nous deux n'est pas saine, revenons à quelque chose de plus conventionnel. :D",
u"J'ai la désagréable impression que {} cherche comment tuer le temps en ce moment…"
]
config_bad_action_actions=[u"prend de la distance, par précaution…",u"esquive",u"est bon pour prendre une semaine de repos… virtuel !",u"n'aime pas servir de souffre douleur, mais n'a malheureusement pas le choix", u"s'en souviendra sans doute longtemps… de quoi parlait-on déjà ?"]

# config pour les actions agréables
config_good_action_triggers=[u"fait (:?des bisous|un c(?:â|a)lin|des c(?:â|a)lins) à",u"embrasse",u"c(?:â|a)line",u"caresse"]
config_good_action_answers=[u":D",u"{}: Moi aussi je vous aime. ♡",u"Tant de délicatesse ne saurait être ignorée !",u"Pour une fois que quelqu'un me considère à ma juste valeur…"]
config_good_action_actions=[u"ronronne",u"aimerait exprimer avec des mots simples le bonheur que {} lui procure !",u"éprouve une joie indescriptible",u"apprécie que des personnes comme {} soient sur IRC, sans quoi il n'y aurait sans doute jamais personne pour tenir compte de lui"]

# config bonjour/bonsoir/que fais-tu encore debout à cette heure, gros sale !
config_bonjour_triggers=[u"(s|)(a|'|)lu(t|)",u"hello",u"pl(o|i)p",u"pr(ou|ü)t",u"bonjour",u"bonsoir",u"coucou"]
config_bonjour_answers=[u"Bien le bonjour, {}.",u"Bonjour {}.",u"{}: bonjour.",u"{}: Quel beau temps aujourd'hui (arrêtez-moi si je me trompe) !",u"Meteo: Cachan"]
config_bonsoir_answers=[u"Bonsoir {} !",u"{}: bonsoir.",u"Quel beau te… euh… bonsoir !",u"{}: Je cherche désespérément une formule pour vous dire bonsoir, mais j'avoue que mon lexique est un peu… limité."]
config_night_answers=[u"{}: vous m'avez fait peur, je m'étais assoupi !", u"Debout à une heure pareille, {} ? Que vous arrive-t-il ?",u"Vous venez prendre la relève, {} ?"]
config_daytime = [7,18]
config_nighttime = [3, 6]

# config dodo
config_bonne_nuit_triggers=[u"bonne nuit",u"'?nite",u"'?nuit",u"'?night",u"good night",u"'?nenuit"]
config_bonne_nuit_answers=[u"{}: thanks, make sweet dreams tonight ! ;)",u"Bonne nuit {}.",u"À demain {}. :)",u"{}: si seulement j'avais le droit de dormir… enfin, bonne nuit !",u"{}: à vous aussi !"]

# config quelqu'un est encore en train d'abuser de ses droits.
config_kick_answers=[u"Suis-je de trop ici ?",u"{}: je m'excuse pour ce bruit indu qui a stimulé votre colère",u"{} a le /kick facile, sans doute la fatigue.",u"{}: j'ai l'impression que vous n'allez pas bien aujourd'hui, vous vous en prenez à un robot !"]
config_kick_actions=[u"sera désormais exemplaire",u"prépare une lettre d'excuses à {}",u"essaiera de ne plus s'attirer les foudres de {}",u"croyait avoir tout bien fait… cruelle déception."]

# config on m'a demandé de mourir/partir
config_quit_messages=[u"J'ai enfin trouvé une corde et un tabouret"]
config_leave_messages=config_quit_messages
config_quit_fail_messages=[u"Tu rêves là."]
config_leave_fail_messages=config_quit_fail_messages


# config de kick
config_kick_channels=config_chanlist

config_smileys = [ur':(-|o)?\)', u'\^(_|\.)?\^', u':-?(p|P)', u'=(\)|D|p|P)', ur'\\o/', ur':-?D', ur'x(\)|D)', u'krkr', ur':-?(\]|>)', ur'(<|d|q|\(|\[)(:|=)', u'mdr']
config_anglicismes = [u"wtf", u"ftfy", u"it works?", u"fyi", u"kill[^ ]*", u"kick[^ ]*", u"chan(nel)?", u"join",
u"btw", u"lmgtfy", u"rtfm", u"asap", u"afaik", u"shit", u"damn", u"fuck", u"bitch", u"updat(e|ed|ing)", u"lol", u"buffer[^ ]*", u"rofl"]

def log(serveur,channel,auteur=None,message=None):
    f=open(get_config_logfile(serveur),"a")
    if auteur==message==None:
        # alors c'est que c'est pas un channel mais juste une ligne de log
        chain="%s %s"%(time.strftime("%F %T"),channel)
    else:
        chain="%s [%s:%s] %s"%(time.strftime("%F %T"),channel,auteur,message)
    f.write(chain+"\n")
    if config_debug_stdout:
        print chain
    f.close()

reg_is_smiley = re.compile(u".*("+u"|".join(config_smileys)+u")")
def is_smiley(chain):
    chain=unicode(chain,"utf8")
    o=re.match(reg_is_smiley,chain)
    return o

reg_is_anglicisme = re.compile(u".*(?:^| )(" + u"|".join(config_anglicismes) + u")(?:$|\.| |,|;)")
def is_anglicisme(chain):
    chain = unicode(chain, "utf8").lower()
    o = re.match(reg_is_anglicisme, chain)
    return o

# Cette liste contient la liste des raisons pour lesquelles on peut se faire kicker
# chaque élément contient :
#  - la fonction de détection du kick (qui matchera une regexp et renverra l'objet de match)
#  - la raison donnée au moment du kick ({0} étant remplacé par ce qui a matché)
config_kicking_list = [
[is_smiley, u'"{0}" ? Ici on déprime.'],
[is_anglicisme, u'"{0}" ? Get out, you and your fucking anglicism !']
]

def is_something(chain,matches,avant=u".*(?:^| )",apres=u"(?:$|\.| |,|;).*",case_sensitive=False,debug=False):
    if case_sensitive:
        chain=unicode(chain,"utf8")
    else:
        chain=unicode(chain,"utf8").lower()
    allmatches="("+"|".join(matches)+")"
    reg=(avant+allmatches+apres).lower()
    o=re.match(reg,chain)
    return o

def is_insult(chain,debug=True):
    return is_something(chain,config_insultes,avant=".*(?:^| |')")
def is_not_insult(chain):
    chain=unicode(chain,"utf8")
    insult_regexp=u"("+u"|".join(config_insultes)+u")"
    middle_regexp=u"(une? (?:(?:putain|enfoiré) d(?:e |'))*|)(?:| super )(?: (?:gros|petit|grand|énorme) |)"
    reg=".*pas %s%s.*"%(middle_regexp,insult_regexp)
    if re.match(reg,chain):
        return True
    else:
        return False
def is_compliment(chain,debug=True):
    return is_something(chain,config_compliment_triggers,avant=".*(?:^| |')")
def is_perdu(chain):
    return is_something(chain,config_perdu)
def is_tag(chain):
    return is_something(chain,config_tag_triggers)
def is_tesla(chain):
    return is_something(chain,config_tesla_triggers,avant=u"^",apres=u"$",debug=True)
def is_merci(chain):
    return is_something(chain,config_merci_triggers)
def is_tamere(chain):
    return is_something(chain,config_tamere_triggers)
def is_bad_action_trigger(chain,pseudo):
    return is_something(chain,config_bad_action_triggers,avant=u"^",
                            apres="(?: [a-z]*ment)? %s($|\.| |,|;).*"%(pseudo))
def is_good_action_trigger(chain,pseudo):
    return is_something(chain,config_good_action_triggers,avant=u"^",
                            apres="(?: [a-z]*ment)? %s($|\.| |,|;).*"%(pseudo))
def is_bonjour(chain):
    return is_something(chain,config_bonjour_triggers,avant=u"^")
def is_bonne_nuit(chain):
    return is_something(chain,config_bonne_nuit_triggers,avant=u"^")
def is_pan(chain):
    return re.match(u"^(pan|bim|bang)( .*)?$",unicode(chain,"utf8").lower().strip())

def is_time(conf):
    _,_,_,h,m,s,_,_,_=time.localtime()
    return (conf[0],0,0)<(h,m,s)<(conf[1],0,0)
def is_day():
    return is_time(config_daytime)
def is_night():
    return is_time(config_nighttime)

      
class UnicodeBotError(Exception):
    pass
def bot_unicode(chain):
    try:
        unicode(chain,"utf8")
    except UnicodeDecodeError as exc:
        raise UnicodeBotError

class Themis(ircbot.SingleServerIRCBot):
    def __init__(self,serveur,debug=False):
        temporary_pseudo=config_irc_pseudo+str(random.randrange(10000,100000))
        ircbot.SingleServerIRCBot.__init__(self, [(serveur, 6667)],
                              temporary_pseudo,"Des[bot]e de #déprime", 10)
        self.debug=debug
        self.serveur=serveur
        self.overops=config_overops
        self.ops=self.overops+config_ops
        self.report_bugs_to=config_report_bugs_to
        self.chanlist=config_chanlist
        self.kick_channels=config_kick_channels
        self.stay_channels=config_stay_channels
        self.quiet_channels=config_quiet_channels
        self.last_perdu=0


    def give_me_my_pseudo(self,serv):
        serv.privmsg("NickServ","RECOVER %s %s"%(config_irc_pseudo,config_irc_password))
        serv.privmsg("NickServ","RELEASE %s %s"%(config_irc_pseudo,config_irc_password))
        time.sleep(0.3)
        serv.nick(config_irc_pseudo)

    def give_me_my_op_status(self,serv,chan):
        serv.privmsg("ChanServ","OP %s"%(chan))

    def on_welcome(self, serv, ev):
        self.serv=serv # ça serv ira
        self.give_me_my_pseudo(serv)
        serv.privmsg("NickServ","identify %s"%(config_irc_password))
        log(self.serveur,"Connected")
        if self.debug:
            self.chanlist=["#bot"]
            self.kick_channels=["#bot"]
        for c in self.chanlist:
            log(self.serveur,"JOIN %s"%(c))
            serv.join(c)
            self.give_me_my_op_status(serv,c)


    def lost(self,serv,channel,forced=False):
        if self.last_perdu+config_time_between_perdu<time.time() or forced:
            if not channel in self.quiet_channels or forced:
                serv.privmsg(channel,"J'ai perdu !")
            self.last_perdu=time.time()
            delay=config_time_between_perdu_trigger
            delta=config_time_between_perdu_trigger_delta
            serv.execute_delayed(random.randrange(delay-delta,delay+delta),self.lost,(serv,channel))
    
    def pourmoi(self, serv, message):
        """renvoie (False,lemessage) ou (True, le message amputé de "pseudo: ")"""
        pseudo=self.nick
        size=len(pseudo)
        if message[:size]==pseudo and len(message)>size and message[size]==":":
            return (True,message[size+1:].lstrip(" "))
        else:
            return (False,message)

    def on_privmsg(self, serv, ev):
        message=ev.arguments()[0]
        auteur = irclib.nm_to_n(ev.source())
        try:
            test=bot_unicode(message)
        except UnicodeBotError:
            if config_utf8_trigger:
                serv.privmsg(auteur, config_utf8_fail)
            return
        message=message.split()
        cmd=message[0].lower()
        notunderstood=False
        if cmd=="help":
            helpdico={"help":["""HELP <commande>
 Affiche de l'aide sur la commande""",None,None],
 "join": [None, """JOIN <channel>
 Me fait rejoindre le channel""",None],
 "leave": [None,"""LEAVE <channel>
 Me fait quitter le channel (sauf s'il est dans ma stay_list).""",None],
 "quiet": [None,"""QUIET <channel>
 Me rend silencieux sur le channel.""",None],
 "noquiet": [None,"""NOQUIET <channel>
 Me rend la parole sur le channel.""",None],
 "say": [None,None,"""SAY <channel> <message>
 Me fait parler sur le channel."""],
 "do": [None,None,"""DO <channel> <action>
 Me fait faitre une action (/me) sur le channel."""],
 "stay": [None,None,"""STAY <channel>
 Ajoute le channel à ma stay_list."""],
 "nostay": [None,None,"""NOSTAY <channel>
 Retire le channel de ma stay_list."""],
 "ops": [None,None,"""OPS
 Affiche la liste des ops."""],
 "overops": [None,None,"""OVEROPS
 Affiche la liste des overops."""],
 "kick": [None,None,"""KICK <channel> <pseudo> [<raison>]
 Kicke <pseudo> du channel (Il faut bien entendu que j'y sois op)."""],
 "die": [None,None,"""DIE
 Me déconnecte du serveur IRC."""]
 }
            helpmsg_default="Liste des commandes disponibles :\nHELP"
            helpmsg_ops=" JOIN LEAVE QUIET NOQUIET LOST"
            helpmsg_overops=" SAY DO STAY NOSTAY OPS OVEROPS KICK DIE"
            op,overop=auteur in self.ops, auteur in self.overops
            if len(message)==1:
                helpmsg=helpmsg_default
                if op:
                    helpmsg+=helpmsg_ops
                if overop:
                    helpmsg+=helpmsg_overops
            else:
                helpmsgs=helpdico.get(message[1].lower(),["Commande inconnue.",None,None])
                helpmsg=helpmsgs[0]
                if op and helpmsgs[1]:
                    if helpmsg:
                        helpmsg+="\n"+helpmsgs[1]
                    else:
                        helpmsg=helpmsgs[1]
                if overop and helpmsgs[2]:
                    if helpmsg:
                        helpmsg+="\n"+helpmsgs[2]
                    else:
                        helpmsg=helpmsgs[2]
            for ligne in helpmsg.split("\n"):
                serv.privmsg(auteur,ligne)
        elif cmd=="join":
            if auteur in self.ops:
                if len(message)>1:
                    if message[1] in self.chanlist:
                        serv.privmsg(auteur,"Je suis déjà sur %s"%(message[1]))
                    else:
                        serv.join(message[1])
                        self.chanlist.append(message[1])
                        serv.privmsg(auteur,"Channels : "+" ".join(self.chanlist))
                        log(self.serveur,"priv",auteur," ".join(message))
                else:
                    serv.privmsg(auteur,"Channels : "+" ".join(self.chanlist))
            else:
                notunderstood=True
        elif cmd=="leave":
            if auteur in self.ops and len(message)>1:
                if message[1] in self.chanlist:
                    if not (message[1] in self.stay_channels) or auteur in self.overops:
                        self.quitter(message[1]," ".join(message[2:]))
                        self.chanlist.remove(message[1])
                        log(self.serveur,"priv",auteur," ".join(message)+"[successful]")
                    else:
                        serv.privmsg(auteur,random.choice(config_leave_fail_messages))
                        log(self.serveur,"priv",auteur," ".join(message)+"[failed]")
                else:
                    serv.privmsg(auteur,"Je ne suis pas sur %s"%(message[1]))
            else:
                notunderstood=True
        elif cmd=="stay":
            if auteur in self.overops:
                if len(message)>1:
                    if message[1] in self.stay_channels:
                        log(self.serveur,"priv",auteur," ".join(message)+"[failed]")
                        serv.privmsg(auteur,"Je stay déjà sur %s."%(message[1]))
                    else:
                        log(self.serveur,"priv",auteur," ".join(message)+"[successful]")
                        self.stay_channels.append(message[1])
                        serv.privmsg(auteur,"Stay channels : "+" ".join(self.stay_channels))
                else:
                    serv.privmsg(auteur,"Stay channels : "+" ".join(self.stay_channels))
            else:
                notunderstood=True
        elif cmd=="nostay":
            if auteur in self.overops:
                if len(message)>1:
                    if message[1] in self.stay_channels:
                        log(self.serveur,"priv",auteur," ".join(message)+"[successful]")
                        self.stay_channels.remove(message[1])
                        serv.privmsg(auteur,"Stay channels : "+" ".join(self.stay_channels))
                    else:
                        log(self.serveur,"priv",auteur," ".join(message)+"[failed]")
                        serv.privmsg(auteur,"Je ne stay pas sur %s."%(message[1]))

            else:
                notunderstood=True
        elif cmd=="die":
            if auteur in self.overops:
                log(self.serveur,"priv",auteur," ".join(message)+"[successful]")
                self.mourir()
            else:
                notunderstood=True
        elif cmd=="quiet":
            if auteur in self.ops:
                if len(message)>1:
                    if message[1] in self.quiet_channels:
                        serv.privmsg(auteur,"Je me la ferme déjà sur %s"%(message[1]))
                        log(self.serveur,"priv",auteur," ".join(message)+"[failed]")
                    else:
                        self.quiet_channels.append(message[1])
                        serv.privmsg(auteur,"Quiet channels : "+" ".join(self.quiet_channels))
                        log(self.serveur,"priv",auteur," ".join(message)+"[successful]")
                else:
                    serv.privmsg(auteur,"Quiet channels : "+" ".join(self.quiet_channels))
            else:
                notunderstood=True
        elif cmd=="noquiet":
            if auteur in self.ops:
                if len(message)>1:
                    if message[1] in self.quiet_channels:
                        self.quiet_channels.remove(message[1])
                        serv.privmsg(auteur,"Quiet channels : "+" ".join(self.quiet_channels))
                        log(self.serveur,"priv",auteur," ".join(message)+"[successful]")
                    else:
                        serv.privmsg(auteur,"Je ne me la ferme pas sur %s."%(message[1]))
                        log(self.serveur,"priv",auteur," ".join(message)+"[failed]")
            else:
                notunderstood=True
        elif cmd=="say":
            if auteur in self.overops and len(message)>2:
                serv.privmsg(message[1]," ".join(message[2:]))
                log(self.serveur,"priv",auteur," ".join(message))
            elif len(message)<=2:
                serv.privmsg(auteur,"Syntaxe : SAY <channel> <message>")
            else:
                notunderstood=True
        elif cmd=="do":
            if auteur in self.overops and len(message)>2:
                serv.action(message[1]," ".join(message[2:]))
                log(self.serveur,"priv",auteur," ".join(message))
            elif len(message)<=2:
                serv.privmsg(auteur,"Syntaxe : DO <channel> <action>")
            else:
                notunderstood=True
        elif cmd=="kick":
            if auteur in self.overops and len(message)>2:
                serv.kick(message[1],message[2]," ".join(message[3:]))
                log(self.serveur,"priv",auteur," ".join(message))
            elif len(message)<=2:
                serv.privmsg(auteur,"Syntaxe : KICK <channel> <pseudo> [<raison>]")
            else:
                notunderstood=True
        elif cmd=="ops":
            if auteur in self.overops:
                serv.privmsg(auteur," ".join(self.ops))
            else:
                notunderstood=True
        elif cmd=="overops":
            if auteur in self.overops:
                serv.privmsg(auteur," ".join(self.overops))
            else:
                notunderstood=True
        else:
            notunderstood=True
        if notunderstood:
            serv.privmsg(auteur,"Je n'ai pas compris. Essayez HELP…")
    
    def on_pubmsg(self, serv, ev):
        auteur = irclib.nm_to_n(ev.source())
        canal = ev.target()
        message = ev.arguments()[0]
        try:
            test=bot_unicode(message)
        except UnicodeBotError:
            if not canal in self.quiet_channels and config_utf8_trigger:
                serv.privmsg(canal, "%s: %s"%(auteur,config_utf8_fail))
            return
        pour_moi,message=self.pourmoi(serv,message)
        for (detect, reason) in config_kicking_list:
            matching = detect(message)
            if matching:
                if canal in self.kick_channels:
                    serv.kick(canal,auteur,(reason.format(matching.groups()[0])).encode("utf8"))
                    return
        if pour_moi and message.split()!=[]:
            cmd=message.split()[0].lower()
            try:
                args=" ".join(message.split()[1:])
            except:
                args=""
            if cmd in ["meurs","die","crève","pends-toi"]:
                if auteur in self.overops:
                    log(self.serveur,canal,auteur,message+"[successful]")
                    self.mourir()
                else:
                    serv.privmsg(canal,"%s: %s"%(auteur,random.choice(config_quit_fail_messages)))
                    log(self.serveur,canal,auteur,message+"[failed]")
    
            elif cmd in ["part","leave","dégage","va-t-en"]:
                if auteur in self.ops and (not (canal in self.stay_channels)
                                           or auteur in self.overops):
                    self.quitter(canal)
                    log(self.serveur,canal,auteur,message+"[successful]")
                    if canal in self.chanlist:
                        self.chanlist.remove(canal)
                else:
                    serv.privmsg(canal,"%s: %s"%(auteur,random.choice(config_leave_fail_messages)))
                    log(self.serveur,canal,auteur,message+"[failed]")
            
            elif cmd in ["deviens","pseudo"]:
                if auteur in self.ops:
                    become=args
                    serv.nick(become)
                    log(self.serveur,canal,auteur,message+"[successful]")
    
            if cmd in ["meur", "meurt","meurre","meurres"] and not canal in self.quiet_channels:
                serv.privmsg(canal,'%s: Mourir, impératif, 2ème personne du singulier : "meurs" (de rien)'%(auteur))
            elif cmd in ["ping"] and not canal in self.quiet_channels:
                serv.privmsg(canal,"%s: pong"%(auteur))
#            if is_insult(message) and not canal in self.quiet_channels:
#                if is_not_insult(message):
#                    answer=random.choice(config_compliment_answers)
#                    for ligne in answer.split("\n"):
#                        serv.privmsg(canal,"%s: %s"%(auteur,ligne.encode("utf8")))
#                else:
#                    answer=random.choice(config_insultes_answers)
#                    for ligne in answer.split("\n"):
#                        serv.privmsg(canal,"%s: %s"%(auteur,ligne.encode("utf8")))
#            elif is_compliment(message) and not canal in self.quiet_channels:
#                answer=random.choice(config_compliment_answers)
#                for ligne in answer.split("\n"):
#                    serv.privmsg(canal,"%s: %s"%(auteur,ligne.encode("utf8")))
            if is_tesla(message) and not canal in self.quiet_channels:
                l1,l2=config_tesla_answers,config_tesla_actions
                n1,n2=len(l1),len(l2)
                i=random.randrange(n1+n2)
                if i>=n1:
                    serv.action(canal,l2[i-n1].encode("utf8"))
                else:
                    serv.privmsg(canal,"%s: %s"%(auteur,l1[i].encode("utf8")))
            if is_tag(message) and not canal in self.quiet_channels:
                if auteur in self.ops:
                    action=random.choice(config_tag_actions)
                    serv.action(canal,action.encode("utf8"))
                    self.quiet_channels.append(canal)
                else:
                    answer=random.choice(config_tag_answers)
                    for ligne in answer.split("\n"):
                        serv.privmsg(canal,"%s: %s"%(auteur,ligne.encode("utf8")))
            if is_bonjour(message) and not canal in self.quiet_channels:
                if is_night():
                    answer=random.choice(config_night_answers)
                elif is_day():
                    answer=random.choice(config_bonjour_answers)
                else:
                    answer=random.choice(config_bonsoir_answers)
                serv.privmsg(canal,answer.format(auteur).encode("utf8"))
            if is_bonne_nuit(message) and not canal in self.quiet_channels:
                answer=random.choice(config_bonne_nuit_answers)
                serv.privmsg(canal,answer.format(auteur).encode("utf8"))
        else:
            if not canal in self.quiet_channels:
                mypseudo=self.nick
                if re.match((u"^("+u"|".join(config_bonjour_triggers)
                                  +u")( {}| all| tout le monde|(|à) tous)(\.|( |)!|)$"
                             ).format(mypseudo).lower(), message.strip().lower()):
                    answer=random.choice(config_bonjour_answers)
                    serv.privmsg(canal,answer.format(auteur).encode("utf8"))

    def on_action(self, serv, ev):
        action = ev.arguments()[0]
        auteur = irclib.nm_to_n(ev.source())
        channel = ev.target()
        try:
            test=bot_unicode(action)
        except UnicodeBotError:
            if not channel in self.quiet_channels and config_utf8_trigger:
                serv.privmsg(channel, "%s: %s"%(auteur,config_utf8_fail))
            return
        mypseudo=self.nick
        
#        if is_bad_action_trigger(action,mypseudo) and not channel in self.quiet_channels:
#            l1,l2=config_bad_action_answers,config_bad_action_actions
#            n1,n2=len(l1),len(l2)
#            i=random.randrange(n1+n2)
#            if i>=n1:
#                serv.action(channel,l2[i-n1].format(auteur).encode("utf8"))
#            else:
#                serv.privmsg(channel,l1[i].format(auteur).format(auteur).encode("utf8"))
#        if is_good_action_trigger(action,mypseudo) and not channel in self.quiet_channels:
#            l1,l2=config_good_action_answers,config_good_action_actions
#            n1,n2=len(l1),len(l2)
#            i=random.randrange(n1+n2)
#            if i>=n1:
#                serv.action(channel,l2[i-n1].format(auteur).format(auteur).encode("utf8"))
#            else:
#                serv.privmsg(channel,l1[i].format(auteur).format(auteur).encode("utf8"))
    
    def on_kick(self,serv,ev):
        auteur = irclib.nm_to_n(ev.source())
        channel = ev.target()
        victime = ev.arguments()[0]
        raison = ev.arguments()[1]
        if victime==self.nick:
            log(self.serveur,"%s kické de %s par %s (raison : %s)" %(victime,channel,auteur,raison))
            time.sleep(2)
            serv.join(channel)
            username = irclib.nm_to_u(ev.source()).lower()
            print ev.source()
            print channel, username
            if channel == "#déprime" and "peb" in username or "becue" in username:
                time.sleep(5)
                serv.kick(auteur, "Va abuser de tes droits ailleurs !")
    
    def kicker(self, chan, pseudo, raison=None):
        if raison==None:
            raison = config_kick_default_reason
        self.serv.kick(chan,pseudo,raison)

    def quitter(self,chan,leave_message=None):
        if leave_message==None:
            leave_message=random.choice(config_leave_messages)
        self.serv.part(chan,message=leave_message.encode("utf8"))
    
    def mourir(self):
        quit_message=random.choice(config_quit_messages)
        self.die(msg=quit_message.encode("utf8"))
    
    def _getnick(self):
        return self.serv.get_nickname()
    nick=property(_getnick)
    
    def start_as_daemon(self, outfile):
        sys.stderr = Logger(outfile)
        self.start()


class Logger(object):
    """Pour écrire ailleurs que sur stdout"""
    def __init__(self, filename="themis.full.log"):
        self.filename = filename

    def write(self, message):
        f = open(self.filename, "a")
        f.write(message)
        f.close()


if __name__=="__main__":
    import sys
    if len(sys.argv)==1:
        print "Usage : themis.py <serveur> [--debug] [--no-output] [--daemon [--pidfile]] [--outfile]"
        print "        --outfile sans --no-output ni --daemon n'a aucun effet"
        exit(1)
    serveur=sys.argv[1]
    if "--daemon" in sys.argv:
        thisfile = os.path.realpath(__file__)
        thisdirectory = thisfile.rsplit("/", 1)[0]
        os.chdir(thisdirectory)
        daemon = True
    else:
        daemon = False
    if "debug" in sys.argv or "--debug" in sys.argv:
        debug=True
    else:
        debug=False
    if "--no-output" in sys.argv or "--daemon" in sys.argv:
        outfile = "/var/log/bots/themis.full.log"
        for arg in sys.argv:
            arg = arg.split("=")
            if arg[0].strip('-') in ["out", "outfile", "logfile"]:
                outfile = arg[1]
        sys.stdout = Logger(outfile)
    serveurs={"a♡":"acoeur.crans.org","acoeur":"acoeur.crans.org","acoeur.crans.org":"acoeur.crans.org",
              "irc":"irc.crans.org","crans":"irc.crans.org","irc.crans.org":"irc.crans.org"}
    try:
        serveur=serveurs[serveur]
    except KeyError:
        print "Server Unknown : %s"%(serveur)
        exit(404)
    themis=Themis(serveur,debug)
    if daemon:
        child_pid = os.fork()
        if child_pid == 0:
            os.setsid()
            themis.start_as_daemon(outfile)
        else:
            # on enregistre le pid de themis
            pidfile = "/var/run/bots/themis.pid"
            for arg in sys.argv:
                arg = arg.split("=")
                if arg[0].strip('-') in ["pidfile"]:
                    pidfile = arg[1]
            f = open(pidfile, "w")
            f.write("%s\n" % child_pid)
            f.close()
    else:
        themis.start()