import json
import socket
import threading

from Classes.System.Network.EventHandler import UDPEventHandler, TCPEventHandler

class NetworkManager:

    class UDP:
        __Addr:str
        __Port:str
        __BufferSize:int = 1024
        __udpSocket:socket
        __users:list
        __UDPClientThread:threading.Thread
        __eventHandler: UDPEventHandler
        
        def __init__(self, Addr:str, Port:str):
            clientUdpSocket, clientUdpAddress = self.__udpSocket.accept()
            self.__Addr = Addr
            self.__Port = int(Port)

            self.__users = {}
            self.__udpSocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
            self.__udpSocket.bind((self.__Addr, self.__Port))
            self.__eventHandler = UDPEventHandler(clientUdpSocket)
                        
            self.__UDPClientThread = threading.Thread(target=self.receive)
            self.__UDPClientThread.start()

        # handles incomming udp data
        def receive(self):
            while True:
                data, address = self.__udpSocket.recvfrom(self.__BufferSize)
                message = data.decode()
                messageJson = json.loads(message)
                user = messageJson.get("user")

                if user not in self.__users:
                    self.__users[user] = address  # Storing new user in dictionary

                # Process the message and handle accordingly
                self.__eventHandler.handleUDPEvents(messageJson)
                print(f"Received message from {address}: {message}")

        def broadcast(self, payload:dict):
            for user_address in self.__users.values():
                self.__udpSocket.sendto(json.dumps(payload).encode(), user_address)

        def send(self, payload:dict, user:str):
            if user in self.__users:
                self.__udpSocket.sendto(json.dumps(payload).encode(), self.__users[user])
                
    class TCP:
        def __init__(self, Addr: str, Port: str):
            self.__Addr = Addr
            self.__Port = int(Port)
            self.__users = {}
            self.__tcpSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            self.__tcpSocket.bind((self.__Addr, self.__Port))
            self.__tcpSocket.listen()

            self.__eventHandler = TCPEventHandler()

            self.__receive_thread = threading.Thread(target=self.accept_connections)
            self.__receive_thread.start()

        def accept_connections(self):
            while True:
                client_tcp_socket, client_address = self.__tcpSocket.accept()
                print(f"Connected with {client_address}")
                self.__users[client_address] = client_tcp_socket
                client_handler_thread = threading.Thread(target=self.receive, args=(client_tcp_socket, client_address))
                client_handler_thread.start()

        def receive(self, __tcpSocket: socket.socket, address):
            while True:
                try:
                    data = __tcpSocket.recv(1024)
                    if not data:
                        break

                    message = data.decode()
                    message_json = json.loads(message)
                    user = message_json.get("user")

                    if user not in self.__users:
                        self.__users[user] = address  # Storing new user in dictionary

                    # Process the message and handle accordingly
                    self.__eventHandler.handleTCPEvents(message_json)
                    print(f"Received message from {address}: {message}")

                except ConnectionResetError:
                    print(f"Connection with {address} closed.")
                    del self.__users[address]
                    break

        def broadcast(self, payload: dict):
            for user_socket in self.__users.values():
                user_socket.send(json.dumps(payload).encode())

        def send(self, payload: dict, user_address):
            if user_address in self.__users:
                user_socket = self.__users[user_address]
                user_socket.send(json.dumps(payload).encode())
            else:
                print(f"User {user_address} is not connected.")

        def close(self):
            self.__tcpSocket.close()
            
    tcp: TCP
    udp: UDP

    def __init__(self, Addr:str, TCPPort:str, UDPPort:str):
        self.tcp = self.TCP(Addr, TCPPort)
        self.udp = self.UDP(Addr, UDPPort)