import sys
import datetime
import requests
import json
import usb.core
import usb.util
from PyQt6 import QtWidgets, uic, QtGui

app = QtWidgets.QApplication(sys.argv)

TIME = 600

USB_IF      = 0 # Interface
USB_TIMEOUT = 5 # Timeout in ms
USB_VENDOR  = 0xffff # Vendor-ID:
USB_PRODUCT = 0x0035 # Product-ID

with open('config.json', 'r') as f:
    config = json.load(f)

session = requests.Session()
session.post(config['login_url'], {'email':config['login'], 'password': config['password']})


last_card = 1111
last_time = datetime.datetime.now()


response = session.get(config['racers_url'])

racers = response.json()


def register_racer():
    card_id = last_card
    index = window.racers.currentIndex()
    racer_id = int(index.data().split(' ')[-1])
    try:
        starting_number = int(window.starting_number.text())
    except Exception:
        raise

    response = session.post(config['card_register'], json={'racer_id': racer_id, 'starting_number': starting_number, 'card_id': last_card})
    if response.status_code != 200:
        raise Exception(response.status_code, response.content)

    racer = list(filter(lambda x: x['racer_id'] == racer_id, racers))[0]
    racer['card_id'] = card_id
    racer['starting_number'] = starting_number
    updateRacers()


def unregister_racer():
    card_id = last_card
    time = last_time

    response = session.post(config['url'], json={'card_id': card_id, 'time': time.strftime('%d.%m.%Y %H:%M:%S.%f'), 'station_id': config['station_id']})




window = uic.loadUi("registrace.ui")
window.register_racer.clicked.connect(register_racer)
window.unregister_racer.clicked.connect(unregister_racer)
window.show()


model = QtGui.QStandardItemModel()
window.racers.setModel(model)

def updateRacers():
    model.clear()
    for racer in racers:
        if racer['starting_number'] or racer['card_id']:
            continue
        item = QtGui.QStandardItem(f"{racer['last_name']} {racer['first_name']} {racer['date_of_birth']} {racer['racer_id']}")
        model.appendRow(item)


updateRacers()


def updateLastCard(card_id):
    window.lastCard.setText(str(card_id))


class UsbCardReader():
    def __init__(self, **kargs):
        # Find the HID device by vendor/product ID
        self.dev = usb.core.find(idVendor=USB_VENDOR, idProduct=USB_PRODUCT)
        # Get and store the endpoint
        self.endpoint = self.dev[0][(0,0)][0]
        if self.dev.is_kernel_driver_active(USB_IF) is True:
            self.dev.detach_kernel_driver(USB_IF)
        # Claim the device
        usb.util.claim_interface(self.dev, USB_IF)
        self.receivedNumber = 0

        cardread=threading.Thread(target=self.read)
        cardread.start()

    def read(self):
        global last_card, last_time

        print("Waiting for card")
        receivedNumber = 0

        while True:
            control = None
            try:
                control = self.dev.read(self.endpoint.bEndpointAddress, self.endpoint.wMaxPacketSize, USB_TIMEOUT)
                if (control[2] != 40) & (control[2] != 0):
                    receivedDigit = control[2] - 29
                    if receivedDigit == 10:
                        receivedDigit = 0
                    receivedNumber = 10 * receivedNumber + receivedDigit

                if (( control[0] == 0 )) & (( control[2] == 40 )) & (( not receivedNumber == 0 )):
                    updateLastCard(receivedNumber)
                    if last_card != receivedNumber:
                        last_time = datetime.datetime.now()
                    last_card = receivedNumber
                    receivedNumber = 0

            except KeyboardInterrupt:
                exit()
            except:
                pass

            time.sleep(0.001)

UsbCardReader()

app.exec()