import re
import hashlib
import time
import os
import logging, logging.handlers
import thread, threading
import sqlite3
import struct
import random
import unicodedata
from datetime import datetime
from twisted.internet import reactor, protocol

import warnings
from zope.interface import implements

class TFMClientProtocol(protocol.Protocol):

    recvd = ""
    structFormat = "!I"

    def stringReceived(self, string):
        raise NotImplementedError

    def inforequestReceived(self, string):
        raise NotImplementedError

    def dataReceived(self, data):
        self.recvd += data
        while not self.recvd == "":
            datalength = len(self.recvd)
            if datalength>=4:
                packetlength = int((struct.unpack("%sL" % "!", self.recvd[:4]))[0])
                if datalength == packetlength:
                    self.stringReceived(self.recvd[4:])
                    self.recvd = ""
                elif datalength < packetlength:
                    break
                else:
                    self.stringReceived(self.recvd[4:packetlength])
                    self.recvd = self.recvd[packetlength:]
            else:
                break

    def sendString(self, string):
        if len(string) >= 2 ** (8 * 4):
            raise StringTooLongError(
                "Try to send %s bytes whereas maximum is %s" % (
                len(string), 2 ** (8 * 4)))
        self.transport.write(
            struct.pack(self.structFormat, len(string)) + string)

class BotClient(TFMClientProtocol):

    def __init__(self):
        self.username = "racebot" #Put its name here
        self.password = "xxxxxxx1" #Put its password here
        self.startroom = "racing" #Put its starting room here
        self.controlmouse="bob" #And put your name here

        self.controlplayercode = ""
        self.currentmap = ""
        self.requestinginfo = False
        self.parsingmaps = False
        self.recievedmap = False
        self.follow = False
        self.room = False

        self.maps = ["@16","@22", "@29", "@42", "@18", "@93", "@94", "@95", "@96", "@97", "@98" , "@99", "@100" ]

        self.position = 0

    def connectionMade(self):
        self.transport.write("\x00\x00\x00\x0C\x00\x00\x00\x00" + "\x1C" + "\x01" + struct.pack("!h", 164))
        self.TempsZeroBR = (time.time() * 1000)
        reactor.callLater(11, self.pingThread)

    def stringReceived(self, data):
        self.parseData(data)

    def sendOutput(self, string):
        print str(datetime.today())+" "+string

    def sendTZAT(self):
        self.sendData("\x1A" + "\x1A", True)

    def pingThread(self):
        Lasttime = int(time.time() * 1000)
        self.sendData("\x1A" + "\x02" + "\x01" + str(int(time.time() * 1000) - int(self.TempsZeroBR)), True)
        self.TempsZeroBR = Lasttime
        reactor.callLater(11, self.pingThread)

    def login(self):
        self.sendData("\x1A" + "\x04" + "\x01" + self.username + "\x01" + str(hashlib.sha256(self.password).hexdigest()) + "\x01" + self.startroom, True)

    def magic(self, obj, x, y, rotation, dx, dy, solid):
        self.sendData("\x05\x14"+struct.pack("!hhhhbbb",obj,x,y,rotation,dx,dy,solid), False)

    def getName(self, playerCode):
        playerdbcur.execute("select name from players where playercode = \""+str(playerCode)+"\"")
        try:
            result = playerdbcur.fetchall()[0][0].encode('ascii','ignore')
        except:
            result = False
        return result

    def getPlayerCode(self, name):
        playerdbcur.execute("select playercode from players where name = \""+str(name)+"\"")
        try:
            result = playerdbcur.fetchall()[0][0].encode('ascii','ignore')
        except:
            result = False
        return result

    def pfo(self, obj):
        if obj == 0:
            need = 0
        elif obj == 24:
            need = 1
        else:
            need = 2
        return need
    def sendData(self, data, isUTF):
        Pos = int((self.CMDTEC)%9000 + 1000)
        d1 = int(Pos / 1000)
        d2 = int(Pos / 100) % 10
        d3 = int(Pos / 10) % 10
        d4 = int(Pos % 10)
        mdtprefix = chr(int(self.MDT[d1])) + chr(int(self.MDT[d2])) + chr(int(self.MDT[d3])) + chr(int(self.MDT[d4]))
        self.CMDTEC += 1
        if isUTF:
            packetlength = struct.pack("!l", (len(data)+12))
            utflength = struct.pack("!h", len(data))
            self.transport.write(packetlength + mdtprefix + "\x01" + "\x01" + utflength + data)
        else:
            packetlength = struct.pack("!l", (len(data)+8))
            self.transport.write(packetlength + mdtprefix + data)

    def parseData(self, data):

        if data[0] == "\x01" and data[1] == "\x01":
            eventutflength = data[2:4]
            data = data[4:struct.unpack("!h", eventutflength)[0]+4]
            values = data.split("\x01")
            prefix = values.pop(0)

        else:
            prefix = data[:2]
            data = data[2:]

    def nextMap(self, reason):
        if reason == 1:
            self.sendData("\x06\x1A\x01"+"mm "+"Too few mice left.", True)
        else:
            self.sendData("\x06\x1A\x01"+"mm "+"Time limit reached.", True)



        if prefix[0] == "\x04":
            self.sendData("\x04\x0A",True)




        elif prefix[0] == "\x05":
            #05 05 prefix
            if prefix[1] == "\x05":
                self.gamecode = values[2]
                self.sendData("\x06\x1A\x01"+"ch "+self.username, True)
                self.sendData("\x06\x1A\x01"+"npp "+random.choice(self.maps), True)
                playerdbcur.execute("update game set points = points + 1 where 1 = 1")
                reactor.callLater(60,self.nextMap,0)
                self.position = 1
            elif prefix[1] == "\x14":
                self.itemnotrecieved = False
            else:
                pass

        elif prefix[0] == "\x06":
            if prefix[1] == "\x06":
                #Chat Message
                #Here's how to send a chat message:
                #message="Hi"
                #self.sendData("\x06\x06"+struct.pack('!h', len(message))+message, False)
                playercode=struct.unpack("!l", data[:4])[0]
                data=data[4:]
                utflength=struct.unpack("!h", data[:2])[0]
                name=str(data[2:int(utflength)+2])
                data=data[utflength+2:]
                utflength=struct.unpack("!h", data[:2])[0]
                message=data[2:utflength+2]
                self.sendOutput(name + ": " + message)


            elif prefix [1] == "\x07":
                #Whisper
                #Here's how to send a whisper:
                #name="Playername"
                #message="Hi"
                #self.sendData("\x06\x07"+struct.pack('!h', len(name))+name+struct.pack('!h', len(message))+message, False)
                msgtype=data[:1]
                data=data[1:]
                if msgtype == "\x00":
                    utflength=struct.unpack("!h", data[:2])[0]
                    name=str(data[2:int(utflength)+2])
                    data=data[utflength+2:]
                    utflength=struct.unpack("!h", data[:2])[0]
                    message=data[2:utflength+2]
                    self.sendOutput("To " + name + ": " + message)
                elif msgtype == "\x01":
                    utflength=struct.unpack("!h", data[:2])[0]
                    name=str(data[2:int(utflength)+2])
                    data=data[utflength+2:]
                    utflength=struct.unpack("!h", data[:2])[0]
                    message=data[2:utflength+2]
                    self.sendOutput("From " + name + ": " + message)
                else:
                    print "Problably the player doesn't exist..."

            elif prefix [1] == "\x08":
                #Tribe Message
                #And here's how to send a tribe message:
                #message="Hi"
                #self.sendData("\x06\x08"+struct.pack('!h', len(message))+message, False)
                utflength=struct.unpack("!h", data[:2])[0]
                message=data[2:int(utflength)+2]
                data=data[utflength+2:]
                utflength=struct.unpack("!h", data[:2])[0]
                name=data[2:utflength+2]
                self.sendOutput("[Tribe] " + name + ": " + message)
            elif prefix [1] == "\x14":
                pass
            else:
                pass

        elif prefix[0] == "\x08":
            if prefix[1] == "\x05":
                #Player Died
                playerCode, AliveMiceCount, score = values

            elif prefix[1] == "\x06":
                #Player got in hole
                if self.position == 1:
                    bonus = "Well done, you came 1st!"

                elif self.position == 2:
                    bonus = "Awww, so close!"
                else:
                    bonus = "Better luck next time!"

                self.position = self.position + 1
                playerCode, AliveMiceCount, score, place, timeTaken = values
                name = self.getName(playerCode)
                mess=(bonus)
                self.sendData("\x06\x07"+struct.pack('!h', len(name))+name.encode('ascii','ignore')+struct.pack('!h', len(mess))+mess, False)
                self.sendData("\x06\x1A\x01"+"mm "+name+" got a time of "+ str(int(timeTaken) / float(10)) + " seconds.", True)



            elif prefix[1] == "\x09":

                playerdbcur.execute("delete from players")
                for player in values:
                    playerdata = player.split("\x23")
                    name = playerdata[0]
                    playercode = playerdata[1]
                    playerdbcur.execute("insert into players (name, playercode) values (?, ?)", (name, playercode))
                    playerdbcur.execute("update game set playercode = \""+playercode+"\" where name = \""+name+"\"")
            elif prefix[1] == "\x15":
                if str(values[0])==str(self.playerCode):
                    pass
            else:
                pass

        elif prefix[0] == "\x10":
            if prefix[1] == "\x05":
                self.sendOutput("[Tribe] " + values[0] + ": " + values[1])
            else:
                pass


        elif prefix[0] == "\x1A":
            if prefix[1] == "\x1A":
                reactor.callLater(10, self.sendTZAT)
            elif prefix[1] == "\x1B":
                self.MDT = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
                LCDMT = values[1]
                self.CMDTEC = int(values[2])
                i = 0
                while(i < 10):
                    self.CMDT = LCDMT[i]
                    if self.CMDT == "0":
                        self.MDT[i] = "10"
                    else:
                        self.MDT[i] = self.CMDT
                    i = (i+1)
                self.login()
            elif prefix [1] == "\x08":
                self.playerCode=values[1]
            else:
                pass
        else:
            pass

class BotFactory(protocol.ClientFactory):
    protocol = BotClient
    def clientConnectionLost(self, connector, reason):
        reactor.stop()
        print "Connection Lost :("
    def clientConnectionFailed(self, connector, reason):
        reactor.stop()

if __name__ == '__main__':
    playerdb = sqlite3.connect(":memory:", check_same_thread = False)
    playerdb.isolation_level = None
    playerdbcur = playerdb.cursor()
    playerdb.row_factory = sqlite3.Row
    playerdbcur.execute("""create table players(name text, playercode text)""")
    playerdbcur.execute("""create table game(name text,posx int,posy int ,points int ,obj int ,whshot text,solid int,rotation int ,playercode text, lstime int)""")

    f = BotFactory()
    reactor.connectTCP("cheeseforlife.no-ip.org", 443, f)
    print "\033[31;49;1mI'm online!\033[0m"
    reactor.run()