#Word Assassins bot written by Crayboff and Dritz.

# system imports
import time, sys, urllib, pickle, random, re, os, shelve, math, httplib
#from datetime import *

from twisted.words.protocols import irc
from twisted.internet import reactor, protocol, task, defer

global debug
debug = True

class Komurin(irc.IRCClient):

    def __init__(self):
        self.nickname = "Assassins"
        self.password = ""
        self.version = "0.6.0"
        self.lineRate = 1
        self.Owner = 'crayboff'
        self.trigger = '-'
        self.helpmessage = "Welcome to Word Assassins. The goal of the game is to 'kill' your targets by having/tricking/waiting for them to say a certain common word. After you kill a person, you will obtain their target and must 'kill' the new target as well, until you are the last man standing. Out of over 800 words, only one will kill you. The game ends every 24 hours, so good luck and good killing!"
        self.helpcommands = "Possible commands are: %shelp  %sjoin  %smyscore  %sstats  %sstart  %stime  %stopscorer  %squit" % (self.trigger, self.trigger, self.trigger, self.trigger, self.trigger, self.trigger, self.trigger, self.trigger)
        self.resetcycle = 86400
        self.timeleftingame = self.resetcycle + 60
        self.resetwarning = 3600
        self.gamedata = {}
        self.isgame = False
        self.playerlist = []
        self.joinedlist = []
        self.userlists = {}
        self.userlist = []
        self.alreadyassigned = []
        self.deadlist = []
        self.quelist = []

    def resetstats(self):
        self.gamedata = {}
        self.playerlist = []
        self.userlists = {}
        self.userlist = []
        self.alreadyassigned = []
        self.deadlist = []
        if self.isgame:
            try:
                self.gameend.cancel()
                self.hourwarning.cancel()
            except:
                pass
        self.isgame = False
        self.startgame(self.nickname)
        if not self.isgame:
            self.notifylist("There was a problem when automatically starting a new game.")

    def connectionMade(self):
        irc.IRCClient.connectionMade(self)
        #print self.wordlist

        if os.path.exists("assassins_wordlist.txt"):
            wordfile = open("assassins_wordlist.txt", "r")
            self.wordlist = wordfile.read()
            wordfile.close()
            self.wordlist = self.wordlist.lower().split(",")
            print len(self.wordlist)
            print 'number of words ^'
        else:
            print "ERROR: NO WORDLIST FOUND"

        if os.path.exists('assassins_joinedlist.txt'):
            k = open('assassins_joinedlist.txt', 'r')
            self.joinedlist = pickle.load(k)
            k.close()
        else:
            self.joinedlist = []
            k = open('assassins_joinedlist.txt', 'w')
            pickle.dump(self.joinedlist, k)
            k.close()
        print "joinedlist loaded"

        if os.path.exists('assassins_scores.txt'):
            m = open('assassins_scores.txt', 'r')
            self.assassinsscores = pickle.load(m)
            m.close()
        else:
            self.assassinsscores = {}
            m = open('assassins_scores.txt', 'w')
            pickle.dump(self.assassinsscores, m)
            m.close()
        print "scores loaded"

    def connectionLost(self, reason):
        print("LOST CONNECTION! REASON:  %s" % reason)
        self.timercounter.stop()
        irc.IRCClient.connectionLost(self, reason)

    def signedOn(self):
        self.join(self.factory.channel)
        self.mode(self.nickname, True, '+B', limit=None, user=self.nickname)
        print('Joined irc.foonetic.net as %s' %(self.nickname))
        print "version %s" % self.version

    def joined(self, channel):
        print('Joined %s' %(channel))
        #self.me(channel, 'version '+self.version)

    def noticed(self, user, channel, msg):
        user = user.split('!', 1)[0]
        if user == 'Nickserv':
            self.msg('Nickserv', 'identify '+self.password)

    def action(self, user, channel, msg):
        mask = user.split('!', 1)[1]
        user = user.split('!', 1)[0].lower()
        msg = msg.strip().lower()
        if user in self.gamedata.keys() and self.isgame:
            self.checkusermsg(user, mask, channel, msg)

    def privmsg(self, user, channel, msg):
        mask = user.split('!', 1)[1]
        user = user.split('!', 1)[0].lower()
        msg = msg.strip().lower()
        if msg.startswith(self.trigger) or msg.startswith(self.nickname.lower()+':') or msg.startswith(self.nickname.lower()+','):
            self.gameparser(user, mask, channel, msg)
        elif user in self.gamedata.keys() and self.isgame:
            self.checkusermsg(user, mask, channel, msg)

    def writejoinlist(self):
        joinedfile = open("assassins_joinedlist.txt", "w")
        joinedfile.write(",".join(self.joinedlist))
        joinedfile.close()

    def gameparser(self, user, mask, channel, msg):
        if msg.startswith(self.nickname.lower()):
            msg = msg.split(' ',1)[1]
        else:
            msg = msg.strip(self.trigger)

        if msg == ('join'):
            self.playerjoin(user)
        elif msg.startswith('start'):
            self.startgame(user)
        elif msg.startswith('stats') or msg.startswith('status'):
            self.userstats(user)
        elif msg.startswith('end'):
            self.endgame(user)
        elif msg.startswith('help'):
            self.help(user)
        elif msg.startswith('time'):
            if self.isgame:
                self.istheretime(user)
            else:
                self.notifyuser(user, 'There is no game playing!')
        elif msg.startswith('quit'):
            self.quitgame(user, channel, msg)
        elif msg.startswith('version'):
            self.notifyuser(user, self.version)
        elif msg.startswith('myscore'):
            self.myscore(user)
        elif msg.startswith('topscorer'):
            self.topscore(user)
        elif msg.startswith('joinchan') and user == self.Owner:
            self.channeljoiner(user, msg)
        elif msg.startswith('partchan') and user == self.Owner:
            self.channelparter(user, msg)

    def channeljoiner(self, user, msg):
        chan = msg.split(' ', 1)[1]
        self.notifyuser(user, "Attempting to join channel %s..." % (chan))
        self.join(chan)

    def channelparter(self, user, msg):
        chan = msg.split(' ', 1)[1]
        self.notifyuser(user, "Attempting to part channel %s..." % (chan))
        self.part(chan)

    def playerjoin(self, user):
        if user in self.joinedlist:
            self.notifyuser(user, 'You are already in the game.')
        elif self.isgame:
            self.notifyuser(user, "There is a game already in session. You will be notified when the next game begins.")
            self.joinedlist.append(user)
        else:
            self.joinedlist.append(user)
            self.notifyuser(user, "Welcome to the game of Word Assassins. When the game begins, you will recieve a target and a word you must have them say. If your target says the word (and it is detected by me, yes spelling counts) then he will be killed and you will recieve his target and so on. The last player standing wins! Good luck! Use %sstats whenever you want to check your current game status. The game will restart 24 hours after it has begun." % self.trigger)
            self.writejoinlist()
        k = open('assassins_joinedlist.txt', 'w')
        pickle.dump(self.joinedlist, k)
        k.close()

    def startgame(self, user):
        self.alllist = self.gamedata.keys()
        for player in self.joinedlist:
            self.notifyuser(player, 'New game starting... handing out assignments...')
        #try:
        if self.isgame == False:
            if len(self.joinedlist) <= 2:
                self.notifyuser(user, "There aren't enough players to begin! You need at least 3 players")
                return
            else:
                self.playerlist = self.joinedlist
                random.shuffle(self.playerlist)
                for player in self.playerlist:
                    playercount = self.playerlist.index(player)
                    #print playercount
                    #print self.playerlist[playercount]
                    if playercount < len(self.playerlist)-1:
                        target = self.playerlist[playercount+1]
                    elif playercount == len(self.playerlist)-1:
                        target = self.playerlist[0]
                    deathword = random.choice(self.wordlist)
                    self.gamedata[player] = {'target':target, 'wordtodie':deathword}
                for player in self.gamedata.keys():
                    targ = self.gamedata[player]['target']
                    wordtokill = self.gamedata[targ]['wordtodie']
                    self.notifyuser(player, "Your mission is to kill: %s. You must get this person to say: %s." % (targ, wordtokill))
                self.isgame = True
                self.timeleftingame = self.resetcycle + 60
                self.gameend = reactor.callLater(self.resetcycle, self.hours24)
                self.hourwarning = reactor.callLater(self.resetcycle-self.resetwarning, self.hours23)
                self.timercounter = task.LoopingCall(self.timeleft)
                self.timercounter.start(60)
        else:
            self.notifyuser(user, "There is already a game in progress.")
        #except IndexError:
         #   self.gamedata = {}
          #  self.alreadyassigned = []
           # self.startgame(user)

    def quitgame(self, user, channel, msg):
        if user in self.joinedlist:
            self.joinedlist.remove(user)
            self.notifyuser(user, "You will no longer join new games.")
            self.writejoinlist()
            if user in self.gamedata.keys() and self.isgame:
                self.playerdeath(user, channel, msg)
            elif user in self.playerlist and self.isgame == False:
                self.notifylist("%s has quit!" % (user))
                self.playerlist.remove(user)
        else:
            self.notifyuser(user, "You can't quit a game you aren't in!")

    def checkusermsg(self, user, mask, channel, msg):
        if self.gamedata[user]['wordtodie'] in msg:
            self.playerdeath(user, channel, msg)

    def playerdeath(self, user, channel, msg):
        newtarget = self.gamedata[user]['target']
        newdeathword = self.gamedata[newtarget]['wordtodie']
        for player in self.gamedata:
            if self.gamedata[player]['target'] == user:
                if player in self.assassinsscores:
                    self.assassinsscores[player] += 1
                else:
                    self.assassinsscores[player] = 1
                m = open('assassins_scores.txt', 'w')
                pickle.dump(self.assassinsscores, m)
                m.close()
                self.notifyuser(player, "%s has said '%s'! You have taken on %s's target. \x02NEW TARGET:\x02 %s  \x02WORD TO KILL:\x02 %s. Your current kill count = %d" % (user, self.gamedata[user]['wordtodie'], user, newtarget, newdeathword, self.assassinsscores[player]))
                self.notifyuser(user, "You have said '%s'! That was the word your killer was trying to get you to say. Your killer has now taken your target to kill. Better luck next game." % self.gamedata[user]['wordtodie'])
                self.gamedata[player]['target'] = newtarget

        del self.gamedata[user]
        self.deadlist.append(user)
        self.notifylist("%s has just died, his/her mysterious killer roams free." % (user))
        if len(self.gamedata.keys()) == 1:
            winner = self.gamedata.keys()[0]
            self.notifylist("The Assassin game is OVER. Congratulations to the new winner: %s" % winner)
            self.timercounter.stop()
            for player in self.gamedata.keys():
                self.topscore(player)
            self.resetstats()

    def myscore(self, user):
        if user not in self.assassinsscores:
            self.assassinsscores[user] = 0
        self.notifyuser(user, "Your current kill count: %d" % (self.assassinsscores[user]))
        m = open('assassins_scores.txt', 'w')
        pickle.dump(self.assassinsscores, m)
        m.close()

    def topscore(self, user):
        topsscore = {}
        for player, score in self.assassinsscores.iteritems():
            if score not in topsscore:
                topsscore[score] = []
            topsscore[score].append(player)
        sortedscore = sorted(topsscore.iteritems(), reverse=True, key=lambda n:n[0])
        print 'top scorers:'
        print sortedscore[0]
        if sortedscore[0][0] == 0:
            self.notifyuser(user, "Noone has a kill yet!")
        else:
            tops = ', '.join(sortedscore[0][1])
            self.notifyuser(user, "\x02Top killer(s)\x02: \x02%s\x02 with a score of %d" % (tops, sortedscore[0][0]))

    def timeleft(self):
        self.timeleftingame -= 60
        print self.timeleftingame

    def istheretime(self, user):
        if self.isgame:
            minleft = (self.timeleftingame / 60) % 60
            hoursleft = self.timeleftingame / 3600
            self.notifyuser(user, "There are %d hours and %d minutes left in this round." % (hoursleft, minleft))

    def userstats(self, user):
        if user in self.gamedata.keys() and self.isgame:
            target = self.gamedata[user]['target']
            wordtokill = self.gamedata[target]['wordtodie']
            self.notifyuser(user, "Your mission is to kill: %s. You must get this person to say: %s." % (target, wordtokill))
        elif self.isgame == False:
            self.notifyuser(user, "There is no game currently in play to get your information from!")
        elif user not in self.gamedata.keys() and user in self.deadlist:
            self.notifyuser(user, "You are currently dead in this round!")
        else:
            self.notifyuser(user, "You are not currently playing!")
        self.istheretime(user)

    def endgame(self, user):
        if user == self.Owner:
            self.notifylist("Game has been ended by owner.")
            print 'Game ended by owner'
            self.resetstats()
        else:
            self.notifyuser(user, "Only my owner may end games at this point.")

    def notifylist(self, message):
        for player in self.playerlist:
            self.notifyuser(player, message)

    def notifyuser(self, person, message):
        self.notice(person, message)

    def hours23(self):
        self.notifylist("There is one hour remaining before the game ends by default. Hurry up and get killing!")

    def hours24(self):
        self.notifylist("24 hours have elapsed without a victor declared. Please rejoin now.")
        for person in self.quelist:
            self.notifyuser(person, "24 hours have elapsed without a victor declared. Please rejoin now.")
        self.resetstats()

    def help(self, user):
        self.notifyuser(user, self.helpmessage)
        self.notifyuser(user, self.helpcommands)

class KomurinFactory(protocol.ClientFactory):        #A 'factory' for the bot.
    protocol = Komurin

    def __init__(self, channel):
        self.channel = channel

    def clientConnectionLost(self, connector, reason):        #We got disconnected, reconnect.
        connector.connect()


    def clientConnectionFailed(self, connector, reason):
        #print "connection failed:", reason
        reactor.stop()


if __name__ == '__main__':                                #Check if we ran it, not imported it.
    dev = '#kiwi'
    chan = '#kiwi,#pygbot,#mafia,#mafia-testing,#mafia-discuss,#xkcd-love,#xkcd-sex,#xkcd-cs,#bots,#boats,#uno,#TheJohnHenry,###,#,#assassins,#assassin,#xkcd-flu'

    if debug:
        f = KomurinFactory(dev)                           #No spaces between channels
    else:
        f = KomurinFactory(chan)

    reactor.connectTCP("irc.foonetic.net", 6667, f)        #Connect the factory to the network.

    reactor.run()