import socket
import threading
import configparser
from struct import *

PORT = 25565
maxpolaczenia = 20
server = socket.socket()
server.bind(('', PORT))


def varint_pack(d):
    o = b''
    while True:
        b = d & 0x7F
        d >>= 7
        o += pack("B", b | (0x80 if d > 0 else 0))
        if d == 0:
            break
    return o


def varint_unpack(s):
    d, l = 0, 0
    length = len(s)
    if length > 5:
        length = 5
    for i in range(length):
        l += 1
        b = s[i]
        d |= (b & 0x7F) << 7 * i
        if not b & 0x80:
            break
    return (d, s[l:])


def data_pack(data):
    return varint_pack(len(data)) + data


def data_unpack(bytes):
    length, bytes = varint_unpack(bytes)
    return bytes[:length], bytes[length:]


def string_pack(string):
    return data_pack(string.encode())


def string_unpack(bytes):
    string, rest = data_unpack(bytes)
    return string.decode(), rest

"""
def struct_unpack(format, struct):
    data = unpack_from(format, struct)
    rest = struct[calcsize(format):]
    return data, rest
"""

def sendd(se, id, data):
    packid = varint_pack(int(id, 16))
    se.send(data_pack(packid + data))


def handShake(version, host, port, next):
    if next == 2:
        global mode
        mode = "login"

    version = varint_pack(version)
    host = string_pack(host)
    port = pack('!H', port)
    next = varint_pack(next)
    return version + host + port + next


def Login(name):
    name = string_pack(name)
    return name

def _send_data(connection, *args):
    """ Send the data on the connection """
    data = b''

    for arg in args:
        data += data_pack(arg)

    connection.send(varint_pack(len(data)) + data)


class listener(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)

    def run(self):
        while True:
            addr = server.listen(maxpolaczenia)
            local_socket, local_address = server.accept()
            print(str(local_address[0]) + ":" + str(local_address[1]) + " " + "Connected to the proxy!")
            user = client(local_socket).start()



#            local_socket.close()

#     print(str(local_address[0] + ":" + local_address[1]))

class client(threading.Thread):
    def __init__(self, s):
        threading.Thread.__init__(self)
        self.s = s

    def run(self):
        user = socket.socket()
        try:
            print("Laczenie..")
            user.connect(("localhost", 25567))
        except:
            print("Nie udalo sie polaczyc z serwerem!")

        while 1:
            data = self.s.recv(4096)
            if data  == b"":
                pass
            elif data == b"\x06\x00/\x00c\xdd\x02\n\x00\x08Masloids":
                user.sendall(data)
                print(data)
                #p = player(user, self.s)
            else:
                user.sendall(data)
                print(str(data))



"""
        elif data == b"\x06\x00/\x00c\xdd\x02\n\x00\x08Masloids":
            print("Przechwycono handshake!")
            print("Zamieniam...")
            try:
                user.sendall(data)
                while 1:
                    lol = user.recv(1024)
                    self.s.sendall(lol)
                    # print(str(lol))
                # sendd(user, "0x00", Login("Masloids"))
            except:
                print("Nie zamieniono!")


        else:
            print(data)
            user.send(data)
            # self.s.sendall(data)

"""
class player(threading.Thread):

    def __init__(self, soc, s):
        threading.Thread.__init__(self)
        self.soc = soc
        self.s = s

    def run(self):
        while 1:
            lol = self.soc.recv(1024)
            self.s.sendall(lol)


listener = listener().start()