import struct
import socket
import time
import hashlib
import sys
from random import choice

# To do
# - fix mouse list

version = 167

def bin_to_str(b):
    return ' '.join([hex(ord(c))[2:].rjust(2,'0') for c in b])

class Server:
    EN1 = ('91.121.28.82', 443)
    EN2 = ('95.142.173.20', 44444)
    KR = ('91.121.157.83', 44444)
    BR = ('187.22.25.190', 44444)
    BR2 = ('173.246.100.255', 44444)
    BR3 = ('173.246.103.161', 44444)
class Packet:
    int_size = {1:'b', 2:'h', 4:'l'}

    def __init__(self, data=""):
        self.data = data
        self.protocol = 'new'
    def setProtocol(self, t):
        self.protocol = t

    def peek(self, b):
        return self.data[:b]
    def read(self, b):
        ret = self.data[:b]
        self.data = self.data[b:]
        return ret
    def readint(self, b):
        s = self.read(b)
        #return int(s.encode('hex'), 16)
        return struct.unpack('!'+self.int_size[b], s)[0]
    def readstring(self):
        s_len = self.readint(2)
        return self.read(s_len)

    def write(self, s):
        self.data += s
    def writeint(self, i, size):
        size_c = self.int_size[size]
        self.data += struct.pack('!'+size_c, i)
    def writebyte(self, b):
        self.data += chr(b)
    def writestring(self, s):
        self.writeint(len(s), 2)
        self.write(s)

    def oldProtocolSplit(self):
        ret = self.data.split('\x01')
        ret = map(lambda s: s.replace('\x00',''), ret)
        return ret

    def size(self):
        return len(self.data)

    def __str__(self):
        if len(self.data) > 0: return bin_to_str(self.data)
        else: return 'Empty packet'


class PrefixGen:
    def __init__(self, data):
        self.MDT = []
        self.data = data
        self.data = self.data.replace('\x00','')
        message = self.data.split('\x01')
        LCMDT = list(message[2])
        for c in map(int, LCMDT):
            if c == 0: self.MDT.append(chr(10))
            else: self.MDT.append(chr(c))

        self.CMDTEC = int(message[3])

    def __call__(self):
        final = ""
        loc_2 = map(int, list(str(self.CMDTEC%9000 + 1000)))
        final = ''.join([self.MDT[x] for x in loc_2])
        self.CMDTEC += 1
        return final


class Mouse:
    mice_ref = []

    def __init__(self, mousedata):
        data = mousedata.split('#')
        #print 'MouseData:',data
        self.name = "Unknown"
        self.code = "0"
        self.score = 0
        self.codeforum = "0"
        self.dead = True

        if len(data) == 9:
            self.name = data[0]
            self.code = data[1]
            self.score = int(data[3])
            self.codeforum = data[8]
            self.dead = data[2] == "1"
        self.x = 0
        self.y = 0
        self.speedx = 0
        self.speedy = 0
        self.jump = False
        self.left = False
        self.right = False
        self.lastdir = 0



class MouseList:
    def __init__(self):
        self.mice = []

    def clear(self):
        self.mice = []

    def add(self, m):
        self.mice.append(m)

    def getCodes(self):
        return [m.code for m in self.mice]

    def findBy(self, lamb, con):
        f = filter(lamb, con)
        if len(f) > 0:
            return f[0]
        else: return None

    def findByCode(self, code):
        return self.findBy(lambda m: m.code == code, self.mice)

    def findByForumCode(self, fcode):
        return self.findBy(lambda m: m.forumcode == fcode, self.mice)

    def findByName(self, name):
        return self.findBy(lambda m: m.name == name, self.mice)


class Magic:
    ARROW = 0
    SMALLBOX = 1
    LARGEBOX = 2
    SMALLBOARD = 3
    LARGEBOARD = 4
    BALL = 6
    TRAMPOLINE = 7
    ANVIL = 10
    CANNONDOWN = 18
    CANNONRIGHT = 19
    CANNONLEFT = 20
    SPIRIT = 24
    RUNE = 32

class ForbiddenMagic:
    REDPOINT = 11
    REDLEFT = 12
    REDRIGHT = 13
    BLUEPOINT = 14
    BLUERIGHT = 15
    BLUELEFT = 16
    YELLOWPOINT = 22
    CANNONUP = 17
    BOMB = 23
    CHEESE = 25
    BLUEPORTAL = 26
    ORANGEPORTAL = 27
    BALLOON = 28
    REDBALLOON = 29
    GREENBALLOON = 30
    YELLOWBALLOON = 31
    SNOW = 34
    #HEAVYBALL = 5
    #SMALLROUGHPLANK = 8
    #LARGEROUGHPLANK = 9
    #STICKYBALL = 21


class Bot:
    def __init__(self, roomname, username, password=""):
        self.sock = None
        self.GeneratePrefix = None
        self.r_data = ""
        self.packet_queue = []
        self.o_username = username
        self.username = username
        self.password = password
        self.roomname = roomname
        self.loginstate = "not ready"
        self.tzat_last = time.time()
        self.move_code = "0"
        self.mice = MouseList()
        self.disconnected = False
        self.shaman = False
        self.sync = False
        self.running = True
        self.stayalive = True
        self.casting = False
        self.object_count = 0
        self.micerz = []
    def TZAT(self):
        self.tzat_last = time.time()
        p = Packet("\x1A\x02111000")
        self.send(p)

    def send(self, packet, prefix=True):
        p_size = packet.size()+8
        if packet.protocol=='old': p_size += 4

        data = Packet()
        data.writeint(p_size, 4)
        pre = '\x00\x00\x00\x00' if not self.GeneratePrefix else self.GeneratePrefix()
        if prefix == False: pre = '\x00\x00\x00\x00'
        data.write(pre)
        if packet.protocol=='old':
            data.write('\x01\x01')
            data.writeint(packet.size(), 2)
        data.write(packet.data)
        #print 'Sending:',str(data)
        try:
            self.sock.send(data.data)
        except:
            print 'Connection problem.'
            self.disconnected = True

    def delay_packet(self, delay, packet, msg="", exe=""):
        self.packet_queue.append([time.time()+delay, packet, msg, exe])

    def sendVersion(self):
        packet = Packet()
        packet.writebyte(0x1C)
        packet.writebyte(0x01)
        packet.writeint(version, 2)
        self.send(packet, prefix=False)

    def login(self):
        passwordhash = hashlib.sha256(self.password).hexdigest()
        if self.password == "":
            passwordhash = ""
        print 'password:',self.password.encode('base64'),'passhash',passwordhash
        p = Packet()
        p.setProtocol('old')
        p.write('\x1A\x04\x01')
        p.write(self.o_username)
        p.write('\x01')
        p.write(passwordhash)
        p.write('\x01')
        p.write(self.roomname)
        self.send(p)
        self.loginstate = "logged in"
        if self.password == "":
            self.username = '*'+self.username

    def connect(self, server):
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        try:
            self.sock.connect(server)
        except:
            return False
        self.sendVersion()
        time.sleep(1)
        self.sock.setblocking(False)
        self.disconnected = False
        return True

    def parsePacket(self, packet):
        packet_type = packet.peek(2)
        try:
            # Mice in server & prefix gen data
            if packet_type == '\x1A\x1B':
                msg = packet.oldProtocolSplit()
                print 'Mice in server:',int(msg[1])
                self.GeneratePrefix = PrefixGen(packet.data)
                self.loginstate = "ready to login"

            # Name data
            if packet_type == '\x1A\x08':
                msg = packet.oldProtocolSplit()
                self.username = msg[1]

            # Ping
            if packet_type == '\x1A\x1A':
                #print ' * PING *'
                p = Packet()
                p.setProtocol('old')
                p.write('\x1A\x1A')
                self.delay_packet(11, p) #, ' * PONG *')

            # New Map
            if packet_type == '\x05\x05':
                msg = packet.oldProtocolSplit()
                self.move_code = msg[3]
                self.object_count = 0
                if self.stayalive:
                    keepalive = Packet("\x04\x0A")
                    keepalive.setProtocol('old')
                    self.send(keepalive)
                self.event_newmap()

            # Chat
            if packet_type == '\x06\x06':
                packet.read(2)
                number = packet.readint(4)
                who = packet.readstring()
                said = packet.readstring()
                self.event_chat(who, said)

            # Whisper
            if packet_type == '\x06\x07':
                #print 'WHISPER,',str(packet)
                packet.read(2)
                sent_by_me = not bool(packet.readint(1))
                #print 'sent_by_me',sent_by_me
                who = packet.readstring()
                try:
                    whispered = packet.readstring()
                except:
                    whispered = ""

                if not sent_by_me:
                    self.event_whisper(who, whispered)
            # Profile
            if packet_type == '\x08\x0A':
                packet.read(1)
                said = packet.readstring()
                self.event_profile(said)
            # Serveur
            if packet_type == '\x06\x14':
                #'\x06\x14'
                packet.read(1)
                said = packet.readstring()
                #WConio.textattr(#WConio.GREEN)
                #WConio.cputs("[Serveur] ")
                #WConio.textattr(#WConio.CYAN)
                #WConio.cputs("%s\r\n" % (said))
                self.event_serveur(said)
                #\x06\x14
                #\x14
                #\x01
                #Split = \x1A
                #0A*
            # Mod message
            if packet_type == '\x06\x0A':
                packet.read(2)
                unknown = packet.read(1)
                who = packet.readstring()
                said = packet.readstring()
                self.event_mod(who, said)
                print '[ModArb Channel][%s] %s' % (who, said)
            # Shaman info
            if packet_type == '\x08\x14':
                msg = packet.oldProtocolSplit()
                #print 'Shaman info',msg
                if len(msg) > 1:
                    self.shaman = False
                    sha_ids = msg[1:]
                    for sha_id in sha_ids:
                        tm = self.mice.findByCode(sha_id)
                        if tm:
                            print "Shaman:",repr(tm.name)
                            #print repr(tm.name),"vs.",repr(self.username)
                            if tm.name == self.username:
                                #print 'I am shaman'
                                self.shaman = True

                    self.event_shamaninfo(sha_ids)

            # Mice in room
            if packet_type == '\x08\x09':
                msg = packet.oldProtocolSplit()
                newlist = MouseList()
                for mouseinfo in msg[1:]:
                    m_object = Mouse(mouseinfo)
                    newlist.add(m_object)

                old_codes = self.mice.getCodes()
                for new_mouse in newlist.getCodes():
                    if not new_mouse in old_codes:
                        new_m = newlist.findByCode(new_mouse)
                        print 'New mouse',newlist.findByCode(new_mouse).name
                        name = newlist.findByCode(new_mouse).name
                        if name == "Artebot":
                            pass
                        else:
                            self.micerz.append(newlist.findByCode(new_mouse).name)

                del self.mice
                self.mice = newlist

            # Mouse joined room
            if packet_type == '\x08\x08':
                msg = packet.oldProtocolSplit()
                m = Mouse(msg[1])
                self.mice.add(m)
                who = m.name
                self.micerz.append(who)
                self.event_mousejoined(m.name)
                self.event_micejoined(who)

            # Mouse left room
            if packet_type == '\x08\x07':
                msg = packet.oldProtocolSplit()
                print 'Mouse left room',msg
                self.event_mouseleft(msg[2])
                self.micerz.remove(msg[2])

            # Join tribe request
            if packet_type == '\x10\x0E':
                msg = packet.oldProtocolSplit()
                self.event_jointribe(msg[2], msg[3])

            # Mouse movement
            if packet_type == '\x04\x04':
                packet.read(2)
                code = packet.read(4)
                data = packet.peek(13)
                goingright = packet.readint(1)
                goingleft = packet.readint(1)
                posx = packet.readint(2)
                posy = packet.readint(2)
                movx = packet.readint(2)
                movy = packet.readint(2)
                jump = bool(packet.readint(1))
                jumpimage = packet.readint(1)
                unk = packet.readint(1)
                mouse_code = packet.readint(4)

                tm = self.mice.findByCode(str(mouse_code))
                if tm:
                    tm.right = goingright; tm.left = goingleft
                    tm.x = posx; tm.y = posy
                    tm.jump = jump
                    tm.speedx = movx; tm.speedy = movy
                    if tm.right: tm.lastdir = 1
                    if tm.left: tm.lastdir = -1

                self.event_mousemove(mouse_code, data)

            # Got cheese
            if packet_type == '\x05\x13':
                msg = packet.oldProtocolSplit()
                self.event_gotcheese(msg[1])
            # Cheese to hole
            if packet_type == '\x08\x06':
                msg = packet.oldProtocolSplit()
                self.event_hole(msg[1])

            # Mouse died
            if packet_type == '\x08\x05':
                msg = packet.oldProtocolSplit()
                self.event_mousedied(msg[1])

            # Mouse ballooned
            if packet_type == '\x08\x10':
                msg = packet.oldProtocolSplit()
                self.event_mouseballoon(msg[1])

            # 20 seconds remaining
            if packet_type == '\x06\x11':
                self.event_20seconds()

            # Ducking
            if packet_type == '\x04\x09':
                msg = packet.oldProtocolSplit()
                ducking = (len(msg) == 3)
                self.event_mouseduck(msg[1], ducking)

            # Emote
            if packet_type == '\x08\x16':
                msg = packet.oldProtocolSplit()
                #print 'emote packet',msg
                mouse_id = msg[1]
                emote = ['dance','laugh','cry','kiss'][int(msg[2])-1]
                self.event_emote(mouse_id, emote)

            # Sync status
            if packet_type == '\x08\x15':
                msg = packet.oldProtocolSplit()
                #print 'Sync status',msg
                self.event_syncstatus(msg[1])
                self.sync = False
                tm = self.mice.findByCode(msg[1])
                if tm and tm.name == self.username:
                    #self.whisper("Randompeople", "OH NO, IM SYNC D: - changing sync...")
                    if self.micerz == []:
                        #self.whisper("Randompeople", "No mice in room, not changing sync.")
                        pass
                    else:
                        newsync = choice(self.micerz)
                        #self.whisper("Randompeople", "New sync: %s" % (newsync))
                        self.command("sy "+newsync)
                    #self.sync = True
        except:
            pass
    def change_gravity(self, x_dir, y_dir, delay=0.0):
        p = Packet('\x05\x22\x01')
        p.write(str(x_dir)+'\x01')
        p.write(str(y_dir))
        p.setProtocol('old')
        self.delay_packet(delay, p)
    def move_cheese(self, nx, ny, delay=0.0):
        p = Packet('\x05\x10\x01')
        p.write(str(int(nx))+'\x01')
        p.write(str(int(ny)))
        p.protocol = 'old'
        self.delay_packet(delay, p)
    def conjuration(self, x, y, delay=0.0):
        print 'Making conjuration at',(int(x),int(y))
        p = Packet('\x04\x0E\x01')
        p.write(str(int(x)))
        p.write(str(int(y)))
        p.setProtocol('old')
        self.delay_packet(delay, p)

    # [type, id, X, Y, speedX, speedY, rot, rotspeed, dur(?), sleep]

    def remove_object(self, code, delay=0.0):
        p = Packet('\x05\x18')
        p.writeint(code, 2)
        self.delay_packet(delay, p)
    def explosion(self, x, y, power=1, radius=1,unk=True, delay=0.0):
        p = Packet('\x05\x11\x01')
        p.write(str(int(x))+'\x01')
        p.write(str(int(y))+'\x01')
        p.write(str(power)+'\x01')
        p.write(str(radius)+'\x01')
        p.write(str(int(unk))+'\x01')
        p.write('1')
        p.setProtocol('old')
        self.delay_packet(delay, p)
    def create_object(self, code, x, y, speedx=0, speedy=0, rot=0, normal=True):
        #p = Packet('\x05\x15\x01')
        #p.write(str(code)+'\x01')
        #p.write(str(int(x))+'\x01')
        #p.write(str(int(y))+'\x01')
        #p.write(str(rot)+'\x01')  # 1
        #p.write(str(speedx)+'\x01')
        #p.write(str(speedy)+'\x01')
        #p.write(str(int(normal))+'\x01') # 1
        #p.setProtocol('old')

        p = Packet('\x05\x14')
        p.writeint(code, 2)
        p.write('\xFC\x16')
        p.writeint(int(x), 2)
        p.writeint(int(y), 2)
        p.writeint(int(rot), 2)
        p.writeint(int(speedx), 1)
        p.writeint(int(speedy), 1)
        p.writebyte(int(normal))
        self.send(p)

        self.object_count += 1
        return self.object_count-1

    def magic_begin(self, code, x, y, delay=0.0, rot=1):
        p = Packet('\x05\x08\x01')
        p.write(str(code)+'\x01')
        p.write(str(x)+'\x01')
        p.write(str(y)+'\x01')
        p.write(str(int(rot)))
        p.setProtocol('old')
        self.delay_packet(delay, p, exe="self.casting = True")

    def magic_cast(self, code, x, y, delay=0.0, speedx=0, speedy=0, rot=0, normal=True):
        p = Packet('\x05\x14')
        p.writeint(code, 2)
        p.write('\xFF\xFF')
        p.writeint(int(x), 2)
        p.writeint(int(y), 2)
        p.writeint(int(rot), 2)
        p.writebyte(int(speedx))
        p.writebyte(int(speedy))
        p.writebyte(int(normal))
        self.delay_packet(delay, p)

    def magic_stop(self, delay=0.0):
        p = Packet('\x05\x09')
        p.setProtocol('old')
        self.delay_packet(delay, p, exe="self.casting = False")

    def magic(self, code, x, y, delay=0.0, cast_time=1.0, speedx=0, speedy=0, rot=1, normal=True, attach=None):
        if self.casting: return

        if not self.shaman: return
        self.magic_begin(code,x,y, delay, rot)
        self.magic_cast(code,x,y,delay+cast_time, speedx, speedy, rot, normal)
        if attach:
            self.attach_balloon(attach, delay+cast_time+0.2)
        #else:
        #    p = Packet('\x05\x07\x0111,0,0,0,0,-2,5.4,6.2,0')
        #    p.setProtocol('old')
        #    self.delay_packet(delay+cast_time+0.2, p)
        self.magic_stop(delay+cast_time+0.2)

    def attach_balloon(self, mouse_code, delay=0.0):
        p = Packet('\x08\x10\x01')
        p.write(str(mouse_code))
        p.setProtocol('old')
        self.delay_packet(delay, p)

    def command(self, txt, delay=0.0):
        p = Packet('\x06\x1A\x01')
        p.setProtocol('old')
        p.write(txt)
        self.delay_packet(delay, p)
    def tribe(self, txt):
        p = Packet('\x06\x08')
        p.writestring(txt)
        self.send(p)
    def modmessage(self, txt):
        p = Packet('\x06\x0A\x00')
        p.writestring(txt)
        self.send(p)

    def chat(self, txt, delay=0.0):
        p = Packet('\x06\x06')
        p.writestring(txt)
        self.delay_packet(delay, p)
    def deathpacket(self):
        p = Packet('\x0E\x03')
        self.send(p)
    def whisper(self, who, txt):
        p = Packet('\x06\x07')
        p.writestring(who)
        p.writestring(txt)
        self.send(p)

    def duck(self, state, delay=0.0):
        if state == True: p = Packet('\x04\x09\x01\x31')
        else: p = Packet('\x04\x09\x01\x30')
        p.setProtocol('old')
        self.delay_packet(delay, p)

    def get_cheese(self, delay=0.0):
        p = Packet('\x05\x13\x01'+str(self.move_code))
        p.setProtocol('old')
        self.delay_packet(delay, p)
    def modmessagez(self, txt):
        p = Packet('\x06\x0A\x03')
        p.writestring(txt)
        self.send(p)
    def hole(self, delay=0.0):
        p = Packet('\x05\x12\x010\x01'+str(self.move_code))
        p.setProtocol('old')
        self.delay_packet(delay, p)

    def die(self, delay=0.0):
        self.dead = True
        p = Packet('\x04\x05')
        p.writeint(int(self.move_code), 4)
        self.delay_packet(delay, p)

    def change_room(self, new_room):
        self.command("room "+new_room)

    def event_20seconds(self):
        pass

    def event_mousemove(self, mouse_code, data):
        pass

    def event_mouseduck(self, mouse_code, state):
        pass

    def event_mousedied(self, mouse_code):
        pass

    def event_mousejoined(self, mouse_name):
        pass

    def event_mouseleft(self, mouse_name):
        pass

    def event_mouseballoon(self, mouse_code):
        pass

    def event_gotcheese(self, mouse_code):
        pass

    def event_hole(self, mouse_code):
        pass

    def event_emote(self, mouse_id, emote):
        pass

    def event_shamaninfo(self, sha_ids):
        pass

    def event_jointribe(self, who, tribename):
        pass

    def event_newmap(self):
        pass

    def event_chat(self, who, said):
        pass

    def event_whisper(self, who, whispered):
        pass

    def event_syncstatus(self, mouse_code):
        pass

    def mainLoop(self):
        # Send delayed packets
        for packet_data in self.packet_queue:
            if time.time() >= packet_data[0]:
                self.send(packet_data[1])
                if packet_data[2] != "":
                    print packet_data[2]
                if packet_data[3] != "":
                    exec(packet_data[3])
                try:
                    self.packet_queue.remove(packet_data)
                except: pass

        # TZAT packet
        if self.loginstate == "logged in" and time.time()-self.tzat_last >= 11.2:
            self.TZAT()

        # Receive data from the server
        data = ''
        try:
            data = self.sock.recv(2*1024)
            if data == '':
                #print str(self.last_packet)
                print ' -- Connection problem --'
                #self.reset_data()
        except socket.error:
            pass

        #if data == '':
        #    return

        #print 'Got:',str(Packet(data))

        self.r_data += data

        # Parse data
        if self.r_data != "":
            try:
                packet_size = struct.unpack('!L', self.r_data[:4])[0]
            except:
                self.r_data = ""
                return

            #print 'Packet should be ',packet_size,', packet is ',len(self.r_data)
            if packet_size <= len(self.r_data):
                p_data = self.r_data[:packet_size]
                self.r_data = self.r_data[packet_size:]

                p = Packet(p_data)
                p.read(4)
                if p.peek(2) == '\x01\x01':
                    p.read(4)
                    p.setProtocol('old')

                if not (p.peek(2) in ['\x04\x03']):
                    pass

                self.parsePacket(p)


class Testbot(Bot):
    target = "Maqqara"
    def __init__(self, *args, **kwargs):
        Bot.__init__(self, *args, **kwargs)
        self.timer = 0
        self.last_code = 0

    def event_newmap(self):
        self.command("sy Idibot")
        self.command("npp @332541")

    def event_chat(self, who, said):
        print '('+who+') said',said

        if said.lower().strip('!?.,') == "idibot die":
            self.die()

    def event_syncstatus(self, mouse_code):
        tm = self.mice.findByCode(mouse_code)
        if tm:
            print '** Sync:',tm.name,'**'

    def event_mousemove(self, mouse_code, data):
        tm = self.mice.findByCode(str(mouse_code))
        if tm and tm.name == self.target:
            pass
    def event_mouseduck(self, mouse_code, ducking):
        tm = self.mice.findByCode(str(mouse_code))
        if tm and tm.name == self.target:
            if ducking:
                self.last_code = self.create_object(ForbiddenMagic.CANNONUP, 540, 128)

    def event_whisper(self, who, said):
        print '(',who,') whispered',said

        if who == "Maqqara":
            cmd = said.split()
            if cmd[0] == 'spawn':
                obj = None
                try: obj = eval("Magic."+cmd[1].upper())
                except: pass

                if obj:
                    print 'Spawning',cmd[1],'...'
                    self.last_code = self.create_object(obj, 540, 128)

            if cmd[0] == 'room':
                r = (' '.join(cmd[1:])).replace('<','<')
                self.command('room '+r)


if __name__ == '__main__':
    server = Server.EN1
    bot = Testbot("bottest6", "Idibot", "xxxxxx")

    success = bot.connect(server)
    if not success:
        print 'Connecting to the server failed.'
        sys.exit(1)

    while True:
        bot.mainLoop()

        if bot.loginstate == "ready to login":
            print 'Logging in...'
            bot.login()

        if bot.disconnected:
            print 'Attempting to re-connect...'
            time.sleep(5)
            success = bot.connect(server)
            if not success:
                print 'Re-connecting failed.'