# Helper class to track client connection status
import threading
import time
import socket

from message_queue.Manager import Manager
import shared_manager
from utils import manager_callback


def start_discovery_service(port):
    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    sock.bind(('0.0.0.0', port))
    print(f"Discovery service listening on port {port}...")

    while True:
        data, addr = sock.recvfrom(1024)
        if data.decode() == "DISCOVER_SERVER":
            print(f"Received discovery request from {addr}")
            sock.sendto(b"SERVER_RESPONSE", addr)
            break
    sock.close()
    return addr

class ConnectionTracker:
    def __init__(self):
        self.last_message_time = time.time()
        self.timeout = 15  # 15-second timeout
        self.last_client_ip = None  # Track last connected client IP

    def update_last_message_time(self, client_ip=None):
        self.last_message_time = time.time()
        if client_ip:
            self.last_client_ip = client_ip  # Update last known client

    def is_client_active(self):
        """Check if the last client is still active within the last 15 seconds."""
        return (time.time() - self.last_message_time) < self.timeout
# Create an instance of ConnectionTracker
connection_tracker = ConnectionTracker()


class ConnectionThread(threading.Thread):
    def __init__(self,debug = False,core = None):
        super().__init__()
        self.running = True
        self.__debug = debug
        self.__core = core

    def run(self):
        while self.running:
            time.sleep(0.5)

            if connection_tracker.last_client_ip:

                if self.__debug:
                    print(f"Checking if last client {connection_tracker.last_client_ip} is still available...")

                if self.query_last_client(connection_tracker.last_client_ip):
                    connection_tracker.update_last_message_time()

                    if self.__debug:
                        print(f"Last client {connection_tracker.last_client_ip} responded. Continuing...")
                    continue  # Skip discovering a new client
            if not connection_tracker.is_client_active():


                print("Client inactive for 15 seconds. Searching for another client...")
                cl_ip, _ = start_discovery_service(12345)
                print(f"New client found: {cl_ip}")

                # Reinitialize the Manager with the new client address
                shared_manager.manager = Manager(f"tcp://{cl_ip}:5558", f"tcp://{cl_ip}:5557")
                shared_manager.manager.start(manager_callback)

                connection_tracker.update_last_message_time(cl_ip)  # Update with new client

    def query_last_client(self, client_ip):
        """Send a heartbeat packet to the last known client IP on port 29170 and wait for a response."""

        if self.__debug:
            print(f"Sending heartbeat to {client_ip}:29170")  # Debugging

        sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        sock.settimeout(5)  # 5-second timeout
        heartbeat_port = 29170  # New port for heartbeat

        try:
            sock.sendto(b"HEARTBEAT", (client_ip, heartbeat_port))  # Send heartbeat message
            data, addr = sock.recvfrom(1024)  # Wait for response

            if self.__debug:
                print(f"Received response from {addr}: {data.decode()}")  # Debugging

            if data.decode() == "HEARTBEAT_ACK":
                connection_tracker.update_last_message_time()  # Update the last message time

                if self.__debug:
                    print(f"Client {client_ip} is still responding.")
                return True

        except socket.timeout:

            print(f"Client {client_ip} did not respond. Marking as inactive.")

        finally:
            sock.close()

        return False  # Client did not respond


    def stop(self):
        self.running = False