import asyncio
import logging

from asyncio_mqtt import Client
import json
import fabapi
from timer import Timer

BFFHD_HOST = "127.0.0.1"
MQTT_HOST = "127.0.0.1"
MACHINE_URN = ""
READER_ID = ""

async def main():
    done = False
    auth_cap = None
    session = None
    msg = None

    async with Client(MQTT_HOST) as client:
        await client.publish("/cmnd/reader", payload='{"Cmd":"haltPICC"}', qos=2, retain=False)
        await client.publish("/cmnd/reader", payload='{"Cmd": "message", "MssgID": 0, "AddnTxt":"    Karte auflegen"}', qos=2, retain=False)
        async with client.filtered_messages(f"/rfid_reader/{READER_ID}") as messages:
            await client.subscribe("/rfid_reader/#")
            async for message in messages:
                response_for_reader = None
                if not auth_cap:
                    timeout_timer = Timer(10, lambda: handle_timeout(client))
                    auth_cap, response_for_reader = await fabapi.connect_with_fabfire_initial(
                        BFFHD_HOST, 59961, message.payload)
                elif not session:
                    response_for_reader, session = await fabapi.connect_with_fabfire_step(auth_cap,
                                                                                               message.payload)
                    if session:
                        timeout_timer.cancel()
                        await client.publish(f"/cmnd/reader/{READER_ID}", payload='{"Cmd":"haltPICC"}', qos=2,
                                             retain=False)

                        info = session.machineSystem.info
                        ma = await info.getMachineURN(f"{MACHINE_URN}").a_wait()

                        if ma.which() == "just":
                            ma = ma.just
                        else:
                            logging.critical(
                                f"Could not get machine {MACHINE_URN}. Machine does not exist or insufficient permissions")
                            raise Exception(
                                f"Could not get machine {MACHINE_URN}. Machine does not exist or insufficient permissions")

                        if ma.state == "inUse":
                            await ma.inuse.giveBack().a_wait()
                            await client.publish(f"/cmnd/reader/{READER_ID}",
                                                 payload='{"Cmd":"message","MssgID":0,"AddnTxt":""}', qos=2,
                                                 retain=False)
                        else:
                            await ma.use.use().a_wait()
                            await client.publish(f"/cmnd/reader/{READER_ID}", payload=response_for_reader, qos=2,
                                                 retain=False)
                            await asyncio.sleep(2)
                            await client.publish(f"/cmnd/reader/{READER_ID}",
                                                 payload='{"Cmd":"message","MssgID":3,"AddnTxt":""}', qos=2,
                                                 retain=False)
                        session = None
                        auth_cap = None
                        response_for_reader = None
                if response_for_reader:
                    await client.publish(f"/cmnd/reader/{READER_ID}", payload=response_for_reader, qos=2, retain=False)

                await client.publish("/cmnd/reader", payload=msg, qos=2, retain=False)

async def handle_timeout(client, reader_id):
    await client.publish(f"/cmnd/reader/{reader_id}", payload='{"Cmd":"haltPICC"}', qos=2,
                             retain=False)
    logging.critical(f"authentication timed out on reader {reader_id}")

if __name__ == "__main__":
    loop = asyncio.get_event_loop()
    loop.run_until_complete(main())