# Pygame is the easiest way to read joystick inputs I know of
import pygame

import os
import socket
import sys
from math import trunc
from time import sleep
from multiprocessing import Process, Queue

# We need to map PyGame input codes to what sys-botbase is expecting
from switch_relay.mapping import BUTTONS, TRIGGERS, STICKS, DPAD_X, DPAD_Y

# This doesn't need to render anything, so stub out Pygame's video system
os.environ["SDL_VIDEODRIVER"] = "dummy"

# ...then init Pygame and the joystick submodule
pygame.init()
pygame.joystick.init()

# Create a socket connection but don't connect it yet
switch = socket.socket(socket.AF_INET, socket.SOCK_STREAM)


# Utility function for formatting and sending data over the socket
def send(data):
    switch.sendall((data + "\r\n").encode())


# A "packet" here being the minimum of one command sent to the switch
# In retrospect this doesn't necessarily need to exist,
# but saves me some format string chicanery later
def make_packet(command, data):
    return f"{command} {data}"


# A receiver process for all of our events - we want to avoid
# as much latency as possible, so send events the moment we have them
def reader_proc(queue):
    while True:
        msg = queue.get()
        send(msg)
        if msg == "DONE":
            break


# Finally, our entrypoint
def cli():
    if len(sys.argv) > 1:
        ip = sys.argv[1]
    else:
        ip = input("Enter the IP address of your Switch > ")

    # Spawn up a queue and a second process to read from it
    pqueue = Queue()
    reader_p = Process(target=reader_proc, args=((pqueue),))
    reader_p.daemon = True
    reader_p.start()

    # Connect to the switch
    switch.connect((ip, 6000))

    # Initialize Pygame's event engine for all available joysticks
    joysticks = [pygame.joystick.Joystick(i) for i in range(pygame.joystick.get_count())]

    for joystick in joysticks:
        joystick.init()

    # We need to calculate the difference between previous d-pad
    # and current d-pad state, as they count as buttons
    # instead of a HAT or AXIS in sys-botbase
    dpad_state = {
        "LEFT": False,
        "RIGHT": False,
        "DOWN": False,
        "UP": False,
    }

    # Same deal for the sticks
    x_names = ["LEFT", "RIGHT"]
    y_names = ["DOWN", "UP"]

    stick_state = {
        "LEFT": {
            0: "",
            1: "",
        },
        "RIGHT": {
            3: "",
            4: "",
        },
    }

    # At time of writing, this is an undocumented feature of sys-botbase
    # but we don't want it to sleep at all between processing inputs
    send("configure mainLoopSleepTime 0")
    send("configure buttonClickSleepTime 0")
    send("configure keySleepTime 0")

    # This is probably unnecessary, but is leftover from getting a
    # comfortable and lag-free Breath of the Wild experience
    send("configure pollRate 32000")

    # Now we just get inputs, translate them, and send them down the pipe!
    while True:
        for event in pygame.event.get():
            if event.type == pygame.JOYAXISMOTION:
                if event.axis in TRIGGERS.keys():
                    if event.value > -0.9:
                        pqueue.put(make_packet("press", TRIGGERS[event.axis]))
                    else:
                        pqueue.put(make_packet("release", TRIGGERS[event.axis]))
                else:
                    stick_name = STICKS[event.axis]
                    multiplier = -32767 if event.axis not in [0, 3] else 32767

                    stick_state[stick_name][event.axis] = hex(trunc(event.value * multiplier))
                    pqueue.put(
                        make_packet(
                            "setStick",
                            "{} {} {}".format(stick_name, *stick_state[stick_name].values()),
                        )
                    )

            if event.type == pygame.JOYBUTTONDOWN:
                pqueue.put(make_packet("press", BUTTONS[event.button]))
            if event.type == pygame.JOYBUTTONUP:
                pqueue.put(make_packet("release", BUTTONS[event.button]))

            if event.type == pygame.JOYHATMOTION:
                x_val, y_val = event.value

                if x_val != 0:
                    pqueue.put(make_packet("press", "D{}".format(DPAD_X[x_val])))
                    dpad_state[DPAD_X[x_val]] = True
                else:
                    for direction in x_names:
                        if dpad_state[direction]:
                            pqueue.put(make_packet("release", f"D{direction}"))
                            dpad_state[direction] = False

                if y_val != 0:
                    pqueue.put(make_packet("press", "D{}".format(DPAD_Y[y_val])))
                    dpad_state[DPAD_Y[y_val]] = True
                else:
                    for direction in y_names:
                        if dpad_state[direction]:
                            pqueue.put(make_packet("release", f"D{direction}"))
                            dpad_state[direction] = False

        # These microscopic sleeps help keep Python from slamming the CPU
        sleep(0.00001)

if __name__ == "__main__":
    cli()