#!/usr/bin/python3

import asyncio
import logging
import pickle
import os
import binascii
import sys


logging.basicConfig(level=logging.DEBUG, format="%(asctime)s %(message)s")
peer_id = os.urandom(32)
res_id = os.urandom(32) if len(sys.argv) < 4 else binascii.a2b_hex(sys.argv[3])
logging.info('\npeer_id: %s\nres_id: %s', binascii.b2a_hex(
    peer_id), binascii.b2a_hex(res_id))


class TrackerClientProtocol:

    def __init__(self):
        pass

    def connection_made(self, transport):
        self.transport = transport

    def sendto(self, message, addr):
        self.transport.sendto(pickle.dumps(message), addr)

    def datagram_received(self, data, addr):
        message = pickle.loads(data)

        if 'type' in message:
            logging.debug('received datagram %s from %s', message['type'], addr)

            if message['type'] == 'echo-request':
                message['type'] = 'echo-response'
                self.sendto(message, addr)
            elif message['type'] == 'echo-response':
                pass
            elif message['type'] == 'peers':
                logging.debug('%d peers', len(message['peers']))
                for p_id, meta_info in message['peers'].items():
                    if p_id == peer_id:
                        continue

                    ping = {
                        'type': 'echo-request',
                        'res_id': meta_info['res_id'],
                        'peer_id': peer_id,
                        'data': os.urandom(8)
                    }
                    logging.debug('sending ping to %s', meta_info['addr'])
                    self.sendto(ping, meta_info['addr'])
            else:
                logging.warn("received invalid message %s", message)
        else:
            logging.warn("receive invalid message %s", message)

    def error_received(self, exc):
        logging.warn('error received: %s', exc)

    def connection_lost(self, exc):
        logging.warn("socket closed, stop the event loop")

loop = asyncio.get_event_loop()
addr = ('0.0.0.0', 0)
listen = loop.create_datagram_endpoint(TrackerClientProtocol, local_addr=addr)
transport, protocol = loop.run_until_complete(listen)
logging.info("Started UDP client %s", str(transport.get_extra_info('socket')))


tracker_addr = (sys.argv[1], int(sys.argv[2]))


async def send_announce():
    while True:
        announce = {'type': 'announce', 'res_id': res_id, 'peer_id': peer_id}
        logging.info('sending announce %s', str(announce))
        transport.sendto(pickle.dumps(announce), tracker_addr)
        await asyncio.sleep(10)

asyncio.ensure_future(send_announce())

try:
    loop.run_forever()
except KeyboardInterrupt:
    pass

transport.close()
loop.close()