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

#update votes etc if a player leaves
#update votes etc on a nick change

#mlock the modes, set +v the sexy way ie +vvvvvvvvv
#give owner more privs, such as forceing votes, forcing leaves etc, maybe give half op so can kick faggots
#start >lynch command
#read commands, descriptions etc from a xml file
#fix bugs and tidy code
#update dict.get maybe

oper_pass = ''
ns_pass = ''

min_players = 3
min_players_2_wolves = 6

#info make loadable from xml in another class etc

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'
            }


night_end = 'The night has ended, suburbia awakens to find the dead raped body of:'
night_begin = 'Night time begins in suburbia, 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... 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):
        if self.game_schedule:
            del self.players[user]
            self.msg(channel,'%s just dissapeard, 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 dissapeard, %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:
                    del self.wolf_targets[user]
                    self.wolf_target = None
                    self.killed = False
                    #means there was 2, one remains.
                    other_wolf = self.wolves[0]
                    if self.wolf_targets[other_wolf] == None:
                        self.msg(other_wolf,'Your fellow %s %s has dissapeard, continue choosing your target' % (roles[1],user))
                    else:
                        self.msg(other_wolf,'Your fellow %s %s has dissapeard, 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 dissapeard, select a new target')
                        else:
                            self.msg(self.wolves[0],'Your target of choice has dissapeard, 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 dissapeard, 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)

        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]))

        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):
        if self.seen and self.killed:
            self.mode(self.factory.channel,False,'v',None,self.wolf_target,None)
            self.msg(self.factory.channel,'%s %s' % (night_end, self.wolf_target))
            role_num = self.players[self.wolf_target]
            self.msg(self.factory.channel,'%s was a %s. %s' % (self.wolf_target,roles[role_num],roles_left[role_num]))

            self.dead.append(self.wolf_target)
            del self.players[self.wolf_target]
            if role_num == 2:
                self.seer = None

            if not self.check_winner(self.factory.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))
        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)
            #print 'self.not_voted'
            #if self.vote_dict[target] >= self.majority: #was a get #bad make it loop through and check
            #   print 'we have maj'
            #   self.lynch(target,channel)
            #else:
            #   self.msg(channel,'Voteing stalemate, either come to a majority decision or %s can now use >force' % self.owner)
            #   print 'vote stalemate game owner could use >force now'
            #self.check_majority()
            #check who has majority vote,
            #decide what to do if a stalemate, could probably....

    def check_votes(self,channel):
        if [k for k, v in self.vote_dict.iteritems() if v >= self.majority]:
            self.lynch(k,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)
            print 'village win'
            return True
        elif len(self.wolves) >= len([k for k, v in self.players.iteritems() if v != 1]):
            self.msg(channel,wolf_win)
            print 'wolf win'
            return True
        else:
            return False

    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]
        new_nick = params[0]
        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]
        command = msg.split(' ')[0]

        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]
                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.get(nick,None)] -= 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]
                        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]
                    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]
                    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,'You are sure %s is a %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='Premium_Bot'):
        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('paimon.skidsr.us', 6667, WolfBotFactory('#venuism'))
    reactor.run()