import asyncio
from functools import wraps
import socketio
import socket

def get_ip_address():
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    try:
        # This IP address doesn't need to be reachable, as we're only using it to find the local IP address
        s.connect(("10.255.255.255", 1))
        ip = s.getsockname()[0]
    except Exception:
        ip = "127.0.0.1"
    finally:
        s.close()
    return ip

# Update these with the correct values for your host and server
HOST_SERVER_IP = "192.168.1.113"
HOST_SERVER_PORT = 4999
SERVER_NAME = "server_1"
SERVER_IP = get_ip_address()
SERVER_PORT = 8000

sio = socketio.AsyncClient()

async def announce_server():
    @sio.event
    async def connect():
        await sio.emit('register', {'name': SERVER_NAME, 'ip': SERVER_IP, 'port': SERVER_PORT})

    async def main():
        await sio.connect(f'http://{HOST_SERVER_IP}:{HOST_SERVER_PORT}')

    @sio.on("heartbeat")
    async def on_heartbeat():
        print("Received heartbeat from host")

    @sio.event
    async def disconnect():
        print("Disconnected from host")
    
    await main()

# def announce_server_decorator(host_block_function):
#     @wraps(host_block_function)
#     def wrapper(*args, **kwargs):
#         loop = asyncio.get_event_loop()

#         # Start the server announcement task
#         announce_task = loop.create_task(announce_server())

#         # Run the original host_block function
#         result = host_block_function(*args, **kwargs)

#         # Cancel the announcement task after the host_block function is done
#         announce_task.cancel()

#         return result

#     return wrapper

def announce_server_decorator(host_block_function):
    @wraps(host_block_function)
    def wrapper(*args, **kwargs):
        async def main(*args, **kwargs):
            loop = asyncio.get_event_loop()
            host_block_thread = loop.run_in_executor(None, host_block_function)

            # Announce the server to the host
            await announce_server()
            # announce_task = loop.create_task(announce_server())

            # run announcement task infinitely in background but allow host_block to run
            # await asyncio.gather(announce_task, host_block_thread)
            # Wait for host_block to finish
            await host_block_thread

            # announce_task.cancel()

        return asyncio.run(main())
    return wrapper