from __future__ import division
from math import ceil
from twisted.words.protocols import irc
from twisted.internet import protocol
from twisted.internet import reactor
import random

#give owner more privs, such as forceing votes, forcing leaves etc, maybe give half op so can kick grifers
#start >force command, maybe scrap it
#start >end command
#maybe a >help command for spastics
#read commands, descriptions etc from a xml file
#fix bugs and tidy code
#add colors
#split,killed and lynched, maybe 2d dict
#timeout maybe

server = 'irc.hardchats.org'
channel = '#chats'

oper_pass = ''
ns_pass = ''

min_players = 4
min_players_2_wolves = 7
max_players = 12

roles = {1:'Nigger',2:'Cop',3:'Housewife'}

commands = {'lynch':'>lynch','see':'>raid','kill':'>rape'}

roles_left = {1:'They left behind a empty bucket of kfc and a half eaten watermelon.',
            2:'They left behind a empty box of donuts.',
            3:'Nothing of value was lost.'}

roles_objective = {1:'Your objective is to blend in with the rest of suburbia, once a night,',
                        2:'Your objective is to determine the identity of any %s hiding in suburbia, once a night,' % roles.get(1,None),
                        3:'Your objective is to decide upon who you think is a %s.' % roles.get(1,None)
                }

#role is reminded at night, maybe sca
roles_ability = {1:'you must use %s TARGET to rape a housewife.' % commands.get('kill',None),
            2:'you must use %s TARGET to determine the targets real identity.' % commands.get('see',None),
            3:'Try not to get raped'
            }


game_intro = ['This is a game of justified paranoia and great truth.  Everyone in this group appears to be a common white suburban housewife, but several of you are \'special\'. One or two of you are actually genuine chicken eating niggers, seeking to rape everyone and everything while concealing their identity.',
'And one of you is also a \'cop\'; you have the ability to learn whether a specific person is or is not a nigger in disguise.',
'As a community, your group objective is to weed out the niggers and lynch them like back in the good ol days, before you\'re all raped in your sleep'
]

night_end = 'The night has ended, suburbia awakens to find the dead raped body of:'
night_begin = 'Night time begins in suburbia, everyone sleeps peacfully but niggery is afoot'

cant_kill_self = 'You cannot rape yourself.'
cant_kill_wolf = 'You cannot rape another nigger.'

cant_see_self = 'You cannot raid yourself'

enough_2_wolves = 'There are enough players for 2 niggers'
two_wolves = 'There are two niggers in this game the other nigger is:'

lynch_begin = 'Suburbia has made its decision, and has decided to lynch:'

#do the even thing? going with determining what roles are left, for added lulz and dickery
wolf_win = 'Suburbia has been thoroughly raped, niggers rein supreme and now no longer hide... there goes the neighborhood.'
village_win = 'Suburbia has been saved and is now rid of all niggers, the suburban dream is safe... for now.'

class WolfBot(irc.IRCClient):

    def _get_nickname(self):
        return self.factory.nickname

    nickname = property(_get_nickname)

    def signedOn(self):
        #self.sendLine('OPER %s' % oper_pass)
        self.mode(self.factory.nickname,True,'BH',None,None,None)
        self.msg('Nickserv','id %s' % ns_pass)
        self.msg('Operserv', 'set superadmin on')
        self.join(self.factory.channel)

    def player_gone(self,user,channel):
        user = user.lower()
        if self.game_schedule:
            del self.players[user]
            self.msg(channel,'%s just disappeared, nothing of value was lost' % user)
        elif self.game:
            role_num = self.players.get(user, None)
            del self.players[user]
            self.msg(channel,'%s just disappeared, %s was a %s, %s' % (user,user,roles[role_num],roles_left[role_num]))
            if role_num == 1:
                self.wolves.remove(user)
                if self.wolves and not self.lynch_time:
                    self.wolf_target = None
                    self.killed = False
                    try:
                        del self.wolf_targets[user]
                    except KeyError, e:
                        pass
                    else:
                        #means there was 2, one remains.
                        other_wolf = self.wolves[0]
                        if self.wolf_targets.get(other_wolf,None) == None:
                            self.msg(other_wolf,'Your fellow %s %s has disappeared, continue choosing your target' % (roles[1],user))
                        else:
                            self.msg(other_wolf,'Your fellow %s %s has disappeared, confirm your target' % (roles[1],user))

            elif role_num == 2:
                self.seer = None

            if not self.check_winner(channel):
                if not self.lynch_time:
                    #fix wolf target dissapearing
                    if user == self.wolf_target or user in self.wolf_targets.values(): #hope dont throw error
                        self.killed = False
                        self.wolf_target = None
                        if len(self.wolves) == 2:
                            for k, v in self.wolf_targets.iteritems():
                                if v == user:
                                    self.wolf_targets[k] = None
                                    self.msg(k,'Your target of choice has disappeared, select a new target')
                        else:
                            self.msg(self.wolves[0],'Your target of choice has disappeared, select a new target')

                else:
                    #fix votes here
                    if user in self.not_voted:
                        self.not_voted.remove(user)
                    else:
                        #lower the person who they voted fors tally:
                        self.vote_dict[self.player_vote[user]] -= 1
                        del self.player_vote[user]
                    #give the people who voted for user their vote back and append them to self.not_voted, remove them from vote_dict
                    if self.vote_dict[user] > 0:
                        #could listcomp it
                        people = []
                        for k, v in self.player_vote.iteritems():
                            if v == user:
                                #give the people who voted for user there vote back, and inform them/channel
                                self.not_voted.append(k)
                                people.append(k)
                                self.player_vote[k] = None #bad?
                        self.msg(channel,'Because %s disappeared, the following people who voted for them, must vote again: %s' % (user,', '.join(people)) )

                    del self.vote_dict[user]
                    #lower self.majority
                    self.majority -= 1

        if user == self.owner: #need to tie this in with line 101 somehow
            self.owner = random.choice(self.players.keys())
            self.msg(channel,'%s was the game owner, %s has become the owner now' % (user,self.owner))

        #self.check_winner

    def assign_roles(self,channel):
        if len(self.players) >= min_players_2_wolves:
            self.msg(channel,enough_2_wolves)
            self.wolves = random.sample(self.players.keys(),3)
        else:
            self.wolves = random.sample(self.players.keys(),2)

        self.seer = random.choice(self.wolves)
        self.wolves.remove(self.seer)

        self.mode(channel,True,'m',None,None,None)
        self.mode(channel,True,'v' * len(self.players),None,' '.join([i for i in self.players.keys()]),None)

        for player in self.players.keys():
            #self.mode(channel,True,'v',None,player,None)
            if player == self.seer:
                self.players[player] = 2
            elif player in self.wolves:
                self.players[player] = 1
            else:
                self.players[player] = 3
            role_num = self.players.get(player, None)
            self.msg(player,'You are a %s. %s' % (roles[role_num],roles_objective[role_num]))

        for line in game_intro:
            self.msg(channel,line)

        self.night_begin()

    def night_begin(self):
        self.owner_force = False
        self.lynch_time = False
        self.killed = False
        if self.seer:
            self.seen = False
        else:
            self.seen = True
        for player, role_num in self.players.iteritems():
            self.msg(player,roles_ability.get(role_num,None))
            if role_num == 1 and len(self.wolves) == 2:
                self.msg(player,'%s %s, you must agree on the same targets.' % (two_wolves,self.get_other_wolf(player)))

        self.msg(self.factory.channel,night_begin)

    def check_night_finished(self):
        channel = self.factory.channel
        if self.seen and self.killed:
            self.mode(channel,False,'v',None,self.wolf_target,None)
            self.msg(channel,'%s %s' % (night_end, self.wolf_target))
            role_num = self.players[self.wolf_target]
            self.msg(channel,'%s was a confirmed %s. %s' % (self.wolf_target,roles[role_num],roles_left[role_num]))
            self.dead.append(self.wolf_target)
            self.msg(channel,'The following players have been killed: %s ...,may they R.I.P' % ', '.join(self.dead))
            self.msg(channel,'As a community your objective now is to use %s TARGET to cast your vote on who you beleive the %s is.' % (commands['lynch'],roles[1]))

            self.msg(self.wolf_target,'You are now dead and can no longer take part in this current game.')
            del self.players[self.wolf_target]
            if role_num == 2:
                self.seer = None

            if not self.check_winner(channel):
                self.lynch_time = True
                self.wolf_target = None
                self.wolf_targets = {}

                self.not_voted = self.players.keys()
                self.vote_dict = {i:0 for i in self.not_voted}
                self.player_vote = {}

                num_players = len(self.players)
                if num_players%2==0:
                    self.majority = int((num_players / 2) + 1)
                else:
                    self.majority = int(ceil(num_players / 2))


    def update_vote(self,nick,target,channel):
        self.msg(channel,'%s has vote for %s' % (nick,target))
        #msg current vote tally
        self.msg(channel,'Current votes: %s, a majority of %s is needed' % (', '.join(['%s:%s' % (k,v) for k, v in self.vote_dict.iteritems() if v > 0]),self.majority))
        #if waiting on people to vote:
        if self.not_voted:
            self.msg(channel,'Waiting for: %s to vote.' % ', '.join(self.not_voted))
            #temp till timeout and owner commands
            if not self.check_votes(channel):
                print 'fix'
        else:
            #check majority vote
            if not self.check_votes(channel):
                self.msg(channel,'Voteing stalemate, either come to a majority decision or %s can now use >force' % self.owner)


    def check_votes(self,channel):
        winner = [k for k, v in self.vote_dict.iteritems() if v >= self.majority]
        if winner:
            self.lynch(winner[0],channel)
            return True
        else:#need the else?
            return False

    def lynch(self,target,channel):
        self.mode(channel,False,'v',None,target,None)
        self.msg(channel,'%s %s' % (lynch_begin,target))
        role_num = self.players[target]
        self.msg(channel,'after examining the remains of %s everyone learns that %s was a %s. %s' % (target,target,roles[role_num],roles_left[role_num]))

        if role_num == 1:
            self.wolves.remove(target)
        elif role_num == 2:
            self.seer = None
        #refresh variables
        del self.players[target]

        if not self.check_winner(channel):
            self.night_begin()

    def check_winner(self,channel):
        if not self.wolves:
            self.msg(channel,village_win)
            self.game_fin(channel)
            return True
        elif len(self.wolves) >= len([k for k, v in self.players.iteritems() if v != 1]):
            self.msg(channel,wolf_win)
            self.game_fin(channel)
            return True
        else:
            return False

    def game_fin(self,channel):
        #channel modes
        if self.wolves:
            if len(self.wolves) == 1:
                self.msg(channel,'%s was a %s' % (self.wolves[0],roles[1]))
            else:
                self.msg(channel,'%s were %ss' % (' and '.join(self.wolves),roles[1]))
        if self.seer:
            self.msg(channel,'%s was a %s' % (self.seer,roles[2]))
        self.mode(channel,False,'m',None,None,None)
        self.mode(channel,False,'v' * len(self.players),None,' '.join([i for i in self.players.keys()]),None)

        #reset all variables to default shit
        self.game = False
        self.game_schedule = False
        self.lynch_time = False
        self.seen = False
        self.killed = False
        self.owner_force = False
        self.dead = []
        self.players = {}
        self.wolf_targets = {}
        self.wolf_target = None
        self.owner = None


    game = False
    game_schedule = False
    lynch_time = False
    seen = False
    killed = False
    #used to track targets when more than one wolf
    wolf_targets = {}
    wolf_target = None
    dead = []
    owner = None #game owner/starter/founder
    players = {}
    owner_force = False

    def userLeft(self, user, channel):
        if user in self.players:
            self.player_gone(user,channel)

    def userQuit(self, user, quitMessage):
        if user in self.players:
            self.player_gone(user,self.factory.channel)

    def userKicked(self, user, channel, kicker, message):
        if user in self.players:
            self.player_gone(user,channel)

    def irc_NICK(self, user, params):
        old_nick = user.split('!')[0].lower()
        new_nick = params[0].lower()
        if old_nick in self.players:
            role = self.players[old_nick]
            if role == 1:
                self.wolves[self.wolves.index(old_nick)] = new_nick
                self.wolf_targets[new_nick] = self.wolf_target[old_nick]
                del self.wolf_target[old_nick]
            elif role == 2:
                self.seer = new_nick

            if old_nick == self.wolf_target:
                self.wolf_target = new_nick
            if old_nick in self.wolf_targets.values():
                for k, v in self.wolf_targets.iteritems():
                    if v == old_nick:
                        self.wolf_targets[k] = new_nick

            del self.players[old_nick]
            self.players[new_nick] = role

            #update votes etc
            if self.lynch_time:
                if old_nick in self.not_voted:
                    self.not_voted.remove(old_nick)
                    self.not_voted.append(new_nick)
                else:
                    self.player_vote[new_nick] = self.player_vote[old_nick]
                    del self.player_vote[old_nick]
                #update vote count for this person
                self.vote_dict[new_nick] = self.vote_dict[old_nick]
                del self.vote_dict[old_nick]

            if old_nick == self.owner:
                self.owner = new_nick
            self.notice(new_nick,'Tracked your nick change.')

    def privmsg(self, user, channel, msg):
        nick = user.split('!')[0].lower()
        command = msg.split(' ')[0].lower()
        #needs to be faster :o
        #could do handleing here maybe

        if command == '>join' and channel == self.factory.channel:
            if self.game and nick in self.players:
                self.notice(nick,'You are already in the game in progress')
            elif self.game and nick not in self.players:
                self.notice(nick,'You may not join a game in progress')
            elif self.game_schedule and nick in self.players:
                self.notice(nick,'You have already joined')
            elif self.game_schedule and nick not in self.players:
                self.msg(channel,'%s has just joined the game' % nick)
                self.players[nick] = None
            else:
                self.notice(nick,'No game at the moment, use >start to begin one')

        elif command == '>leave' and channel == self.factory.channel:
            if self.game and nick in self.players:
                self.notice(nick,'You cant leave a game in progress')
            elif self.game and nick not in self.players:
                self.notice(nick,'You cant leave a game you\'re not a part of')
            elif self.game_schedule and nick in self.players:
                del self.players[nick]
                self.notice(nick,'You have just left the game')
            elif self.game_schedule and nick not in self.players:
                self.notice(nick,'You cant leave a game you\'re not a part of')
            else:
                self.notice(nick,'No game at the moment, use >start to begin one')

        elif command == '>start' and channel == self.factory.channel:
            #expand
            if self.game or self.game_schedule:
                self.notice(nick,'Game already in progress')
            else:
                self.game_schedule = True
                self.owner = nick
                self.players[nick] = None
                self.notice(nick,'You are the game owner, use >begin to begin the game one all players have joined')
                self.msg(channel,'%s has just started a new game, use >join to join!' % nick)

        elif command == '>begin' and channel == self.factory.channel:
            if self.game:
                self.notice(nick,'Game already in progress')
            elif nick != self.owner and self.game_schedule:
                self.notice(nick,'Only the game owner can begin the game, current owner: %s' % self.owner)
            elif nick == self.owner and self.game_schedule:
                if len(self.players) < min_players:
                    self.msg(channel,'Not enough players to begin the new game')
                else:
                    self.game_schedule = False
                    self.game = True
                    self.msg(channel,'New game starting, assigining roles')
                    self.assign_roles(channel)
            elif not self.game_schedule:
                self.notice(nick,'No game at the moment, use >start to begin one')

        elif command == commands['lynch'] and channel == self.factory.channel:
            if not self.lynch_time:
                self.notice(nick,'Now is not the time for that')
            else:
                try:
                    target = msg.split(' ')[1].lower()
                except IndexError, e:
                    self.notice(nick,'No target given.')
                else:
                    if target in self.players:
                        if nick == target:
                            self.notice(nick,'You cannot vote for yourself')
                        elif nick in self.not_voted:
                            self.not_voted.remove(nick)
                            self.vote_dict[target] += 1
                            self.player_vote[nick] = target
                            self.notice(nick,'Vote set, current vote: %s' % target)
                            self.update_vote(nick,target,channel)
                        elif self.player_vote.get(nick,None) != target:
                            self.vote_dict[self.player_vote[nick]] -= 1
                            self.player_vote[nick] = target
                            self.vote_dict[target] += 1
                            self.notice(nick,'Vote updated, current vote: %s' % target)
                            self.update_vote(nick,target,channel)
                        elif self.player_vote.get(nick,None) == target:
                            self.notice(nick,'%s has already got your vote.' % target)

                    elif target in self.dead:
                        self.notice(nick,'You cannot vote for %s, since they are already dead' % target)
                    else:
                        self.notice(nick,'%s isn\'t playing' % target)

        elif command == commands['kill'] and channel == self.nickname:
            if self.lynch_time and nick in self.wolves:
                self.msg(nick,'Now is not the time for that')
            if not self.lynch_time and nick in self.wolves:
                if self.killed:
                    if len(self.wolves) == 2:
                        self.msg(nick,'You and the other %s have already decided on your target' % roles[1])
                    else:
                        try:
                            target = msg.split(' ')[1].lower()
                        except IndexError, e:
                            self.msg(nick,'No target given')
                        else:
                            if target == nick:
                                self.msg(nick,cant_kill_self)
                            elif target in self.dead:
                                self.msg(nick,'%s is already dead' % target)
                            elif target in self.players:
                                self.msg(nick,'Target updated')
                                self.wolf_target = target
                                self.check_night_finished()
                else:
                    try:
                        target = msg.split(' ')[1].lower()
                    except IndexError, e:
                        self.msg(nick,'No target given')
                    else:
                        if target == nick:
                            self.msg(nick,cant_kill_self)
                        elif target in self.dead:
                            self.msg(nick,'%s is already dead' % target)
                        elif target in self.players and len(self.wolves) != 2:
                            self.msg(nick,'Target set')
                            self.wolf_target = target
                            self.killed = True
                            self.check_night_finished()
                        elif target in self.wolves:
                            self.msg(nick,cant_kill_wolf)
                        elif target in self.players and len(self.wolves) == 2:
                            self.msg(nick,'Target set')
                            self.wolf_targets[nick] = target
                            other_wolf = self.get_other_wolf(nick)
                            if self.wolf_targets.get(other_wolf, None) == target:
                                self.msg('%s,%s' % (nick,other_wolf),'Target has been agreed on, no going back.') #sake of ease
                                self.wolf_target = target
                                self.killed = True
                                self.check_night_finished()
                            elif self.wolf_targets.get(other_wolf, None) == None:
                                self.msg(nick,'%s hasn\'t chose a target yet' % other_wolf)
                                self.msg(other_wolf,'%s has just chosen %s as a target' % (nick,target))
                            else:
                                self.msg(other_wolf,'%s has just chosen %s as a target' % (nick,target))
                                self.msg('%s,%s' % (nick,other_wolf),'You have both chosen different targets, you need to agree')

                        else:
                            self.msg(nick,'%s isn\'t playing' % target)

        elif command == commands['see'] and channel == self.nickname:
            if self.lynch_time and nick == self.seer:
                self.msg(nick,'Now is not the time for that')
            elif not self.lynch_time and nick == self.seer:
                if self.seen:
                    self.msg(nick,'You have already used your ability for tonight')
                else:
                    try:
                        target = msg.split(' ')[1].lower()
                    except IndexError, e:
                        self.msg(nick,'No target given')
                    else:
                        if target == nick:
                            self.msg(nick,'%s...try again' % cant_see_self)
                        elif target in self.dead:
                            self.msg(nick,'%s is dead' % target)
                        elif target in self.players:
                            self.msg(nick,'%s is a confirmed %s' % (target, roles[self.players[target]]))
                            self.seen = True
                            self.check_night_finished()
                        else:
                            self.msg(nick,'%s isn\'t playing' % target)

    def get_other_wolf(self,user):
        for wolf in self.wolves:
            if wolf != user:
                return wolf

    def ctcpQuery(self, user, channel, messages):
        print 'Faggot is ctcp\'in'


class WolfBotFactory(protocol.ClientFactory):
    protocol = WolfBot

    def __init__(self, channel, nickname='Wolf'):
        self.channel = channel
        self.nickname = nickname

    def clientConnectionLost(self, connector, reason):
        connector.connect()

    def clientConnectionFailed(self, connector, reason):
        print "Connection failure:", reason
        reactor.stop()

if __name__ == '__main__':
    reactor.connectTCP(server, 6667, WolfBotFactory(channel))
    reactor.run()