#!/usr/bin/env python3
import asyncio
import logging
import traceback

from os import path

from pyrad.dictionary import Dictionary
from pyrad.packet import AccessAccept
from pyrad.server_async import ServerAsync
from pyrad.server import RemoteHost

try:
    import uvloop

    asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
except:
    pass

logging.basicConfig(
    level="DEBUG", format="%(asctime)s [%(levelname)-8s] %(message)s"
)


def print_attributes(packet):
    print("Attributes returned by server:")
    for key, value in packet.items():
        print(f"{key}: {value}")


class FakeServer(ServerAsync):
    def __init__(self, loop, dictionary):

        ServerAsync.__init__(
            self,
            loop=loop,
            dictionary=dictionary,
            enable_pkt_verify=True,
            debug=True,
        )

    def handle_auth_packet(self, protocol, packet, addr):
        print("Received an authentication request with id ", packet.id)
        print("Authenticator ", packet.authenticator.hex())
        print("Secret ", packet.secret)
        print_attributes(packet)

        reply = self.CreateReplyPacket(
            packet,
            **{
                "Service-Type": "Framed-User",
                "Framed-IP-Address": "192.168.0.1",
                "Framed-IPv6-Prefix": "fc66::/64",
            },
        )

        reply.code = AccessAccept
        protocol.send_response(reply, addr)

    def handle_acct_packet(self, protocol, packet, addr):
        print("Received an accounting request")
        print_attributes(packet)

        reply = self.CreateReplyPacket(packet)
        protocol.send_response(reply, addr)

    def handle_coa_packet(self, protocol, packet, addr):
        print("Received an coa request")
        print_attributes(packet)

        reply = self.CreateReplyPacket(packet)
        protocol.send_response(reply, addr)

    def handle_disconnect_packet(self, protocol, packet, addr):
        print("Received an disconnect request")
        print_attributes(packet)

        reply = self.CreateReplyPacket(packet)
        # COA NAK
        reply.code = 45
        protocol.send_response(reply, addr)


def main(path_to_dictionary):
    # create server and read dictionary
    loop = asyncio.get_event_loop()
    server = FakeServer(loop=loop, dictionary=Dictionary(path_to_dictionary))

    # add clients (address, secret, name)
    server.hosts["127.0.0.1"] = RemoteHost(
        "127.0.0.1", b"Kah3choteereethiejeimaeziecumi", "localhost"
    )

    try:
        # Initialize transports
        loop.run_until_complete(
            asyncio.ensure_future(
                server.initialize_transports(
                    enable_auth=True, enable_acct=True, enable_coa=True
                )
            )
        )

        try:
            # start server
            loop.run_forever()
        except KeyboardInterrupt:
            pass

        # Close transports
        loop.run_until_complete(
            asyncio.ensure_future(server.deinitialize_transports())
        )

    except Exception as exc:
        print("Error: ", exc)
        traceback.print_exc()

        # Close transports
        loop.run_until_complete(
            asyncio.ensure_future(server.deinitialize_transports())
        )

    loop.close()


if __name__ == "__main__":
    dictionary = path.join(path.dirname(path.abspath(__file__)), "dictionary")
    main(dictionary)