import socket
import struct
import random
import threading

class SABot:
    def __init__(self, Username, Password, IP, Port):
        self.NullByte = struct.pack('B', 0)
        self.BufSize = 4096
        self.CommandChar = '.'
        self.InLobby = False
        self.OnlineUsers = {}
        self.OnlineUserMap = {}
        self.Dead = []

        self.NameToIP = {'2D Central': '74.86.43.9:1138', 'Paper Thin City': '74.86.43.8:1138', 'Fine Line Island':  '198.58.106.101:1138', 'U of SA':  '69.164.207.72:1138',
                                      'Amsterdam':  '139.162.151.57:1138',  'Mobius Metro':  '45.56.72.83:1138', 'Cartesian':  '198.58.106.101:1139'}

        self.IPToName = {'74.86.43.9:1138': '2D Central', '74.86.43.8:1138': 'Paper Thin City', '198.58.106.101:1138': 'Fine Line Island', '69.164.207.72:1138': 'U of SA',
                                               '139.162.151.57:1138': 'Amsterdam', '45.56.72.83:1138': 'Mobius Metro', '198.58.106.101:1139': 'Cartesian'}

        self.ServerIP = IP
        self.ServerPort = Port
        self.Commands = True
        self.BotServer = self.IPToName[ '{}:{}'.format(self.ServerIP, self.ServerPort)]
        self.BotPassword = Password

        self.connectToServer(Username, Password, self.ServerIP, self.ServerPort)

    def sendPacket(self, Socket, PacketData, Receive = False):
        Packet = bytes(PacketData, 'utf-8')

        if Socket:
            Socket.send(Packet + self.NullByte)

            if Receive:
                return Socket.recv(self.BufSize).decode('utf-8')

    def startKeepAlive(self, TimerSeconds = 20):
        if hasattr(self, 'SocketConn'):
            KeepAliveTimer = threading.Timer(TimerSeconds, self.startKeepAlive)
            KeepAliveTimer.daemon = True
            KeepAliveTimer.start()

            self.sendPacket(self.SocketConn, '0')

    def sendPrivateMessage(self, UserID, Message):
        if UserID != self.BotID:
            if UserID in self.OnlineUsers:
                self.sendPacket(self.SocketConn, '00' + UserID + 'P' + Message)

    def sendPublicMessage(self, Message):
        self.sendPacket(self.SocketConn, '9' + Message)

    def connectionHandler(self):
        Buffer = b''

        while hasattr(self, 'SocketConn'):
            try:
                Buffer += self.SocketConn.recv(self.BufSize)
            except ConnectionAbortedError:
                return

            if len(Buffer) == 0:
                print('{} has disconnected'.format(self.BotUsername))

                break
            elif Buffer.endswith(self.NullByte):
                Receive = Buffer.split(self.NullByte)
                Buffer = b''

                for Data in Receive:
                    Data = Data.decode('utf-8')

                    if Data.startswith('U'):
                        UserID = Data[1:][:3]
                        Username = Data[4:][:20].replace('#', '')

                        self.parseUserData(Data)
                    elif Data.startswith('D'):
                        UserID = Data[1:][:3]
                        Username = self.OnlineUsers[UserID]

                        del self.OnlineUserMap[Username]
                        del self.OnlineUsers[UserID]
                    elif Data.startswith('M'):
                        UserID = Data[1:][:3]

                        self.parseUserMessage(UserID, Data)
                    elif Data.startswith('0g') or Data.startswith('0j'):
                        print('{{Server}}: {}'.format(Data[2:]))
                    elif Data.startswith('0f') or Data.startswith('0e'):
                        Time, Reason = Data[2:].split(';')
                        print('This account has just been banned [Time: {} / Reason: {}]'.format(Time, Reason))

    def connectToServer(self, Username, Password, ServerIP, ServerPort):
        try:
            self.SocketConn = socket.create_connection((ServerIP, ServerPort))
        except Exception as Error:
            print(Error)
            return

        Handshake = self.sendPacket(self.SocketConn, '08HxO9TdCC62Nwln1P', True).strip(self.NullByte.decode('utf-8'))

        if Handshake == '08':
            Credentials = '09{};{}'.format(Username, Password)
            RawData = self.sendPacket(self.SocketConn, Credentials, True).split(self.NullByte.decode('utf-8'))

            for Data in RawData:
                if Data.startswith('A'):
                    self.AutoRelog = True
                    self.InLobby = True
                    self.BotID = Data[1:][:3]
                    self.BotUsername = Data[4:][:20].replace('#', '')
                    self.BotCred = Data[43:].split(';')[8]

                    print('Bot Username: {} | Bot ID: {} | Bot Cred: {} | Located in {}'.format(self.BotID, self.BotUsername, self.BotCred, self.BotServer))

                    EntryPackets = ['02Z900_', '03_', '0a', '01']

                    for Packet in EntryPackets:
                        self.sendPacket(self.SocketConn, Packet)

                    self.startKeepAlive()
                    ConnectionThread = threading.Thread(target=self.connectionHandler)
                    ConnectionThread.start()
                    break
                elif Data == '09':
                    print('Incorrect password')
                    break
                elif Data == '091':
                    print('Currently banned')
                    break
        else:
            print('Server capacity check failed')

    def parseUserData(self, Packet, Password = None):
        StatsString = Packet.replace('\x00', '')
        UserID = StatsString[1:][:3]
        Type = StatsString[:1]

        if Type == 'U':
            if self.InLobby == True:
                Username = StatsString[4:][:20].replace('#', '')
                StatsString = StatsString[24:]

                self.OnlineUsers[UserID] = Username
                self.OnlineUserMap[Username] = UserID
            else:
                Username = StatsString[9:][:20].replace('#', '')

                self.OnlineUsers[UserID] = Username
                self.OnlineUserMap[Username] = UserID

    def parseUserMessage(self, SenderID, Packet):
        if SenderID in self.OnlineUsers:
            Sender = self.OnlineUsers[SenderID]

            NoUseTypes = ['1', '2', '4', '5', '6', '7', '8', '~']
            MessageType = Packet[4:][:1]
            SenderMessage = Packet[5:]
            RawMessage = Packet[1:].replace(SenderID, '')

            if MessageType in NoUseTypes:
                return
            elif MessageType == '9':
                if self.Commands:
                    self.handleCommand(SenderID, Sender, SenderMessage, False)
            elif MessageType == 'P':
                if self.Commands:
                    self.handleCommand(SenderID, Sender, SenderMessage, True)
            else:
                self.handleCommand(SenderID, Sender, RawMessage, True)

                try:
                    print('[' + Sender + ']: ' + RawMessage)
                except:
                    pass

    def handleCommand(self, SenderID, Sender, SenderMessage, Private):
        RespondByPM = (False if Private == False else True)
        Message = SenderMessage.strip()
        MessageCheck = Message.split()

        if Message.startswith(self.CommandChar):
            Command = MessageCheck[0][1:].lower()
            HasArguments = (True if len(MessageCheck) > 1 else False)
            Arguments = (' '.join(MessageCheck[1:]) if HasArguments else None)

            if Command == 'reset':
                RespondByPM = True
                self.Dead = []
                self.BotAdmin = None

                Response = 'RR list has been reset.'
            elif Command == 'users':
                RespondByPM = True
                UserList = []

                for User in self.OnlineUserMap:
                    UserList .append(User)

                Response = 'There are {} people in the lobby. Users: {}'.format(len(UserList), ', '.join(UserList))
            elif Command == 'addcol' or Command == 'getcol':
                RespondByPM = True

                if Private:
                    if HasArguments:
                        SpinnerType = Arguments.split()[0]
                        RGB = Arguments.split()[1]
                        Password = Arguments.replace(' ', '')[12:]
                        Response = 'Attempting to add the requested RGB to your account...'

                        ColorRequest = threading.Thread(target=self.handleColorRequest, args=(SenderID, Sender, SpinnerType, RGB, Password))
                        ColorRequest.daemon = True
                        ColorRequest.start()
            elif Command == 'rr':
                if Sender not in self.Dead:
                    GoodNumber = random.randint(0, 2)
                    BadNumber = random.randint(0, 2)

                    if GoodNumber == BadNumber:
                        self.Dead.append(Sender)
                        Response = 'You\'re dead, {}'.format(Sender)
                    else:
                        Response = 'You live, {}'.format(Sender)

        if 'Response' in locals():
            if Private:
                print('[PM from {} in {}] Response: {}'.format(Sender, self.BotServer, Response))
            else:
                print('[{} in {}] Response: {}'.format(Sender, self.BotServer, Response))

            if RespondByPM:
                self.sendPrivateMessage(SenderID, Response)
            else:
                self.sendPublicMessage(Response)

    def handleColorRequest(self, SenderID, Sender, SpinnerType, RGB, Password):
        SocketConn = socket.create_connection((self.ServerIP, self.ServerPort), socks.PROXY_TYPE_SOCKS5, 'localhost', 9150)
        Handshake = self.sendPacket(SocketConn, '08HxO9TdCC62Nwln1P', True).strip(self.NullByte.decode('utf-8'))

        if Handshake == '08':
            Credentials = '09{};{}'.format(Sender, Password)
            RawData = self.sendPacket(SocketConn, Credentials, True)

            for Data in RawData:
                if Data.startswith('A'):
                    self.sendPacket(SocketConn, '02Z900_')
                    self.sendPacket(SocketConn, '03_')

                    self.sendPacket(SocketConn, '0b' + SpinnerType + RGB + RGB)
                elif Data == '09':
                    SentMessage = False

                    while not SentMessage:
                        if SenderID in self.OnlineUsers:
                            SentMessage = True
                            self.sendPrivateMessage(SenderID, 'Incorrect password')
                            break

                break

        SocketConn.shutdown(socket.SHUT_RD)
        SocketConn.close()
        del SocketConn

if __name__ == '__main__':
    Username = 'funkseason'
    Password = 'password'

    SABot(Username,  Password, '74.86.43.9', 1138)