from .packet import Packet
from .EnumQuery import EnumQuery
from .EnumResponse import EnumResponse
from .CFrame import CFrame
from .DFrame import DFrame
from giants.masterserver import MasterServer
from .session import Session
import socket
import threading
import traceback
import uuid
from utils.logger import setup_logger
from giants.player import Player

logger = setup_logger(__name__)


class Netserver:
    def __init__(self, server):
        self.socket = None
        self.statssocket = None
        self.server = server
        self.addrs = []
        self.guid = uuid.uuid4().bytes

    def run(self):
        self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        self.socket.bind((self.server.listen_ip, self.server.listen_port))
        logger.debug("Listening to %s:%s", self.server.listen_ip, self.server.listen_port)
        gameserverthread = threading.Thread(target=self.handle_packets)
        gameserverthread.start()

        #ms = MasterServer(self.server)
        #statsserverthread = threading.Thread(target=ms.register_and_run)
        #statsserverthread.start()

        gameserverthread.join()
        #statsserverthread.join()

    def handle_packets(self):
        while True:
            data, addr = self.socket.recvfrom(1024)
            logger.debug("%s:%s > %s", addr[0], addr[1], data.hex())
            self.handle_new_packet(addr, data)

    def handle_new_packet(self, addr, bData):
        pPacket = Packet(bData)
        first = pPacket.getByte()
        if len(bData) >= 4 and first & DFrame.PACKET_COMMAND_DATA:
            self.handle_new_dframe(addr, pPacket)
        elif len(bData) >= 12 and first & CFrame.PACKET_COMMAND_FRAME:
            self.handle_new_cframe(addr, pPacket)
        elif first == EnumQuery.LEAD or first == EnumResponse.LEAD:
            self.handle_new_enum(addr, pPacket)
        else:
            logger.error("Unknown frame received")
            return

    def handle_new_enum(self, addr, data):
        # EnumQuery or EnumResponse
        second = data.getByte()
        if second == EnumQuery.COMMAND:
            # EnumQuery
            try:
                eq = EnumQuery(data)
                logger.debug("Got EnumQuery, sending EnumResponse")
                er = EnumResponse()
                er.Payload = eq.Payload
                er.ApplicationDescSize = 0x50
                er.ApplicationDescFlags = 0x41
                er.MaxPlayers = self.server.maxplayers
                er.CurrentPlayers = len(self.server.players)
                er.SessionName = self.server.name
                er.ApplicationInstanceGUID = self.guid
                er.ApplicationGUID = eq.ApplicationGUID
                er.ApplicationReservedData = b'\xff'  # Map ID
                er.ApplicationReservedData += b'\x00\x04\x00'
                er.ApplicationReservedData += b'\xd9\x05'  # game version
                er.ApplicationReservedData += b'\x02\x92\x05\x00\x01\x00\x00\x00\x00\x00'  # Unknown
                er.ApplicationReservedData += b'\x9c\x53\xf4\xdd'  # Seems to be a checksum of current map
                # \x00\x00\x00\x00: [None]
                # \x00\x00\x00\x01: <custom map>
                # \x9c\x53\xf4\xdd: Three Way Island - Canyons
                # \x1e\xe9\x39\xe1: Still Winter
                er.ApplicationReservedData += self.server.currentmap.mapname.encode("ascii")
                er.ApplicationReservedData += b'\x00' * (32 - len(self.server.currentmap.mapname))
                self.send_packet(addr, er.to_packet())
            except Exception:
                logger.error("Could not parse EnumQuery or forge EnumResponse: ")
                traceback.print_exc()
                return
        elif second == EnumResponse.COMMAND:
            # wait what? ignore that shit
            return
        else:
            logger.error("Unknown DPLHP command: %s", second)

    def handle_new_cframe(self, addr, data):
        try:
            cframe = CFrame(data)
            session = self.get_session(addr)
            if cframe.ExtOpCode == CFrame.FRAME_EXOPCODE_CONNECT:
                # CONNECT CFRAME
                if session and session.Full:
                    logger.error("Session %s:%s was already fully connected. Ignoring.", session.ip, session.port)
                    return
                elif session and not session.Full and session.SessID == cframe.SessID:
                    # send CONNECTED
                    logger.debug("Already partially established connection. Sending a CFRAME CONNECTED again.")
                    session.send_cframe_connected(cframe)
                    #session.setup_Connect_Retry_Timer()
                    return
                if not self.server.accept_new_players:
                    # ignore new players
                    return
                else:
                    logger.debug("New connection. Sending a CFRAME CONNECTED.")
                    session = Session(self.socket)
                    session.SessID = cframe.SessID
                    session.ip = addr[0]
                    session.port = addr[1]
                    self.addrs.append(session)
                    session.send_cframe_connected(cframe)
                    #session.setup_Connect_Retry_Timer()
            elif cframe.ExtOpCode == CFrame.FRAME_EXOPCODE_CONNECTED:
                # CONNECTED CFRAME
                # check if already sent a CONNECT packet
                logger.debug("%s:%s sent back a CONNECTED CFrame.", session.ip, session.port)
                if not session:
                    logger.error("%s sent a CONNECTED opcode without having sent a CONNECT before. GTFO.", addr)
                    return

                if not cframe.SessID == session.SessID or cframe.Command & CFrame.PACKET_COMMAND_POLL:
                    logger.error("Sent a CONNECTED packet with incorrect SessID or had COMMAND_POLL")
                    return
                session.Full = True # fully connected
                session.cancel_Connect_Retry_Timer()

            elif cframe.ExtOpCode == CFrame.FRAME_EXOPCODE_SACK:
                if not session or not session.Full:
                    logger.error("Received a SACK packet for a non fully connected session")
                    return

                sack_sent = False
                if not cframe.NSeq == session.next_expected_seq:
                    logger.error("Received CFRAME (%s) does not have the same NSeq (%s). Did we miss a packet?", cframe.NSeq, session.next_expected_seq)
                    if not sack_sent:
                        session.send_cframe_sack()
                        sack_sent = True

                if not session.CFRAME_NRcv == cframe.NRecv:
                    logger.error("Received CFRAME (%s) does not have same NRcv (%s). One sent packet might have been lost.", cframe.NRecv, session.CFRAME_NRcv)
                    if not sack_sent:
                        session.send_cframe_sack()
                        sack_sent = True

                # WIP: The bNSeq, bNRcv, optional selective acknowledgment (SACK), and optional send mask fields are then processed by using the standard rules in sections 3.1.5.2.1 through 3.1.5.2.4
                # TODO: A successfully validated SACK packet SHOULD count as a valid receive and thus restart the KeepAlive timer

            if cframe.Command & CFrame.PACKET_COMMAND_POLL:
                if not session:
                    logger.error("Received a POLL packet for a non fully connected session")
                    return
                logger.debug("Got a CFrame POLL. Replying with a SACK.")
                # must send back a ACK
                session.send_cframe_sack()
        except Exception:
            logger.error("Should have been a CFRAME but could not parse it")
            traceback.print_exc()
            return

    def handle_new_dframe(self, addr, data):
        try:
            dframe = DFrame(data)
            logger.debug("Received DFRAME")
            session = next((x for x in self.addrs if x.ip == addr[0] and x.port == addr[1]), None)
            if not session:
                logger.debug("%s sent a DFRAME without having sent a CONNECT before. GTFO.", addr)
                logger.debug(self.addrs)
                return
            if not dframe.Seq == session.next_expected_seq:
                logger.error("%s unexpected SEQ. Got %s, expected %s", addr, dframe.Seq, session.next_expected_seq)
                #return

            if dframe.Control & DFrame.PACKET_CONTROL_END_STREAM:
                if not session:
                    logger.error("Received a END STREAM packet for a non fully connected session")
                    return
                # disconnect
                resp = DFrame()
                resp.Command = DFrame.PACKET_COMMAND_DATA | DFrame.PACKET_COMMAND_NEW_MSG | DFrame.PACKET_COMMAND_END_MSG | DFrame.PACKET_COMMAND_RELIABLE | DFrame.PACKET_COMMAND_SEQUENTIAL
                resp.Control = DFrame.PACKET_CONTROL_END_STREAM
                resp.Seq = dframe.NRcv
                resp.NRcv = session.next_send
                session.send(resp)

                session.send_cframe_sack()

                # TODO: broadcast session has disconnected
                self.addrs.remove(session)
                return

            session.next_expected_seq += 1
            if dframe.Payload:
                self.handle_game_packet(session, dframe.Payload)
            else:
                pass
        except Exception as e:
            logger.error("Could not parse DFRAME: ")
            traceback.print_exc()
            return

    def handle_game_packet(self, session, payload):
        logger.debug("Payload: %s", payload)
        if payload[0] == 0xc1:
            # connect frame?
            _ = payload[0:4]
            _ = payload[4:8]
            _ = payload[8:12]
            _ = payload[12:16]
            _ = payload[16:20]
            _ = payload[20:52]
            instanceguid = payload[52:68]
            gameguid = payload[68:84]
            _ = payload[84:88]
            _ = payload[88:92]
            name = payload[92:]
            name = name.decode("utf-16-le")[0:-1]
            logger.debug("%s connected!", name)
            player = Player(name, session)
            self.server.new_player(player)
            session.send_dframe_keepalive()

            r = DFrame()
            r.Command = DFrame.PACKET_COMMAND_DATA | DFrame.PACKET_COMMAND_RELIABLE | DFrame.PACKET_COMMAND_SEQUENTIAL | DFrame.PACKET_COMMAND_POLL | DFrame.PACKET_COMMAND_NEW_MSG | DFrame.PACKET_COMMAND_END_MSG | DFrame.PACKET_COMMAND_USER_1
            r.Control = 0x00
            r.Seq = session.next_send
            r.NRcv = session.next_expected_seq
            payload = Packet()
            payload.putLong(0xc2)  # C2 = response to a C1 connection?
            payload.putLong(0x00)  # unknown
            payload.putLong(0x00)  # unknown
            payload.putLong(0x50)  # unknown - 80
            payload.putLong(0x41)  # unknown - 65
            payload.putLong(0x14)  # max players
            payload.putLong(0x02)  # current players
            payload.write(b'\x0e\x01\x00\x00')  # unknown - 3585 - or \x16\x01\x00\x00
            payload.putLong(len((self.server.name + "\x00").encode("utf-16-le")))  # SERVERNAME LENGTH
            for _ in range(4):
                payload.putLong(0)  # unknown
            payload.putLong(0xda)  # unknown - 218 - or 0xe2
            payload.putLong(0x34)  # unknown - 52
            payload.write(self.guid)  # instance guid
            payload.write(
                b"\x10\x5e\x62\xa7\x96\x1a\xd2\x11\x9a\xfc\x00\x60\x08\x45\xe5\x71")  # app guid
            payload.write(b'\x40\xf5\x62\xe1')
            payload.putLong(0x21)  # unknown - 33
            payload.putLong(0x00)  # unknown
            payload.putLong(0x02)  # unknown - 2
            payload.putLong(0x00)
            payload.write(b'\x45\xf5\x52\xe3')
            payload.putLong(0x00)
            payload.write(b'\x02\x04\x00\x00')  # unknown
            payload.putLong(0x02)  # unknown - 2
            payload.putLong(0x00)  # unknown
            payload.putLong(0x07)  # unknown - 7
            for _ in range(6):
                payload.putLong(0)  # unknown
            payload.write(b'\x40\xf5\x62\xe1')  # unknown - 1089823457
            payload.putLong(0x00)  # unknown
            payload.write(b'\x00\x02\x00\x00')  # unknown - ?
            payload.putLong(0x21)  # unknown - 33
            payload.putLong(0x00)  # unknown - 0
            payload.putLong(0x07)  # unknown - 7
            payload.putLong(0xcc)  # unknown - 204
            payload.putLong(0x0e)  # unknown - 6
            for _ in range(4):
                payload.putLong(0)  # unknown
            payload.write((name + "\x00").encode("utf-16-le"))
            payload.write(b'\xff')  # map ID
            payload.write(b'\x01\x01\x00')
            #payload.write(b'\x00\x04\x00')
            payload.write(b'\xd9\x05') # game version
            payload.write(b'\x02\x92\x05\x00\x01\x00\x00\x00\x00\x00')  # Unknown
            payload.write(b'\x9c\x53\xf4\xde')  # Seems to be a checksum of current map
            payload.write(self.server.currentmap.mapname.encode("ascii"))
            payload.putLong(0x00)  # ??
            payload.write((self.server.name + "\x00").encode("utf-16-le"))

            r.Payload = payload.getvalue()
            session.send(r)

        if payload[0] == 0xc3:
            self.server.broadcast_message(name + " is a dick.")


    def send_packet(self, addr, packet):
        self.socket.sendto(packet.getvalue(), addr)
        logger.debug("%s:%s < %s", addr[0], addr[1], packet.getvalue().hex())

    def get_session(self, iporaddr, port=None):
        if not port:
            return next((x for x in self.addrs if x.ip == iporaddr[0] and x.port == iporaddr[1]), None)
        else:
            return next((x for x in self.addrs if x.ip == iporaddr and x.port == port), None)