#include <jstick.hpp>

#ifdef UNIX
#include <linux/joystick.h>
#include <unistd.h>
#include <bits/fs_fwd.h>
#endif

#ifdef WIN32
//#include <joystickapi.h>
#endif

#include <cstddef>
#include <cstdio>
#include <fcntl.h>
#include <format>
#include <filesystem>
#include <iostream>

#include <J3ML/LinearAlgebra/Vector2i.hpp>

struct axis_state {
    short x, y;
};

int js_handle;
bool js_connected;
struct js_event event;
struct axis_state axes[3] = {0};
bool btn_state[10] = {false};
size_t axis;
Vector2 l_thumb;
Vector2 r_thumb;
short l_trigger;
short r_trigger;
Vector2 dpad;
jstick::ControllerType device_type;


/// Reads a joystick event from the joystick device.
/// @returns 0 on success. Otherwise -1 is returned.
int read_event(int fd, struct js_event *event) {
    ssize_t bytes;

    bytes = read(fd, event, sizeof(*event));

    if (bytes == sizeof(*event))
        return 0;

    /// Error, could not read full event.
    return -1;
}

std::string js_device_file(int hwid) {
    return std::format("/dev/input/js{}", hwid);
}

bool jstick::JoystickDetected(int jsHandle) {
    return std::filesystem::exists(js_device_file(jsHandle));
}

int jstick::NumJoysticksDetected() {
    int max = 4;
    for (int i = 0; i < max; i++) {
        if (!JoystickDetected(i))
            return i;
    }
    return max;
}

bool jstick::Connected(int hwid) {
    return js_connected && js_handle == hwid;
}

std::string jstick::GetDeviceName(int hwid) {
    char name_buf[128];
    if (ioctl(hwid, JSIOCGNAME(sizeof(name_buf)), name_buf) < 0)
        strncpy(name_buf, "Unknown", sizeof(name_buf));
    return std::string(name_buf);
}

bool jstick::GetDPadIsAxisOrButtons() { return true; }

int jstick::Connect(int hwid) {
    if (js_connected) {
        std::cerr << "Joystick already connected! Support for multiple joysticks is in-progress!" << std::endl;
        return false;
    }
    js_handle = open(js_device_file(hwid).c_str(), O_NONBLOCK);

    if (js_handle == -1) {
        perror("Could not open joystick");
        return false;
    }

    js_connected = true;
    device_type = GetDeviceTypeFromName(GetDeviceName(js_handle));
    JoystickConnected.Invoke(js_handle);
    return js_handle;
}

bool jstick::Disconnect(int hwid) {
    if (!js_connected || js_handle == -1) {
        std::cerr << "Joystick is already disconnected! Support for multiple joysticks is in-progrss!" << std::endl;
        return false;
    }
    close(js_handle);
    JoystickDisconnected.Invoke(js_handle);
    js_connected = false;
    return true;
}

void jstick::JoystickServiceUpdate() {

    int device_count = NumJoysticksDetected();

    bool has = JoystickDetected();

    if (has && !js_connected)
        Connect();

}



void ProcessButtonEvent(uint8_t button_index, bool value) {

    jstick::XBoxButton btn = (jstick::XBoxButton)button_index;

    btn_state[button_index] = value;

    if (value) {
        jstick::ButtonPressed.Invoke(btn);

    } else {
        jstick::ButtonReleased.Invoke(btn);
    }


}

void ProcessAxisEvent(uint8_t axis, short value) {
    // TODO: Handle all single-axis changes, and then invoke the axis event with the new vectors.

    Vector2 prev_lthumb = l_thumb;
    Vector2 prev_rthumb = r_thumb;
    Vector2 prev_dp = dpad;
    short prev_ltrigger = l_trigger;
    short prev_rtrigger = r_trigger;

    if (device_type == jstick::ControllerType::XBox)
    {
        if (axis == 0) l_thumb.x = value;
        if (axis == 1) l_thumb.y = value;
        if (axis == 2) l_trigger = value;
        if (axis == 3) r_thumb.x = value;
        if (axis == 4) r_thumb.y = value;
        if (axis == 5) r_trigger = value;
        if (axis == 6) dpad.x = value;
        if (axis == 7) dpad.y = value;

    }

    if (device_type == jstick::ControllerType::PS3) {
        if (axis == 0) l_thumb.x = value;
        if (axis == 1) l_thumb.y = value;
        if (axis == 2) r_thumb.x = value;
        if (axis == 3) r_thumb.y = value;
        if (axis == 4) l_trigger = value;
        if (axis == 5) r_trigger = value;
    }

    if (device_type == jstick::ControllerType::PS4) {
        if (axis == 0) l_thumb.x = value;
        if (axis == 1) l_thumb.y = value;
        if (axis == 2) r_thumb.x = value;
        if (axis == 3) r_thumb.y = value;
        if (axis == 4) l_trigger = value;
        if (axis == 5) r_trigger = value;
        if (axis == 6) dpad.x = value;
        if (axis == 7) dpad.y = value;
    }

    // TODO: Compare against the l_thumb from the last time the event was called.
    if (l_thumb.DistanceSq(prev_lthumb) > 0.1f)
        jstick::LeftThumbstickMoved.Invoke(l_thumb);
    if (r_thumb.DistanceSq(prev_rthumb) > 0.1f)
        jstick::RightThumbstickMoved.Invoke(r_thumb);
    if (dpad.DistanceSq(prev_dp) > 0.1f)
        jstick::DPadMoved.Invoke(dpad);

    if (Math::Abs(l_trigger) - Math::Abs(prev_ltrigger) > 1.f)
        jstick::LeftTriggerMoved.Invoke(l_trigger);

    if (Math::Abs(r_trigger) - Math::Abs(prev_rtrigger) > 1.f)
        jstick::RightTriggerMoved.Invoke(r_trigger);

}

void jstick::ReadEventLoop() {
    while (read_event(js_handle, &event) == 0) {
        switch (event.type) {
            case JS_EVENT_BUTTON:
                ProcessButtonEvent(event.number, event.value != 0);
                break;
            case JS_EVENT_AXIS:
                ProcessAxisEvent(event.number, event.value);
                break;
            case JS_EVENT_INIT:
            default:
                break;

        }
        fflush(stdout);
    }
}

bool jstick::IsButtonDown(const XBoxButton &btn) {
    return btn_state[(uint8_t)btn];
}

Vector2 jstick::GetLeftThumbstickAxis(float deadzone) { return l_thumb;}
Vector2 jstick::GetRightThumbstickAxis(float deadzone) { return  r_thumb; }
Vector2 jstick::GetDPadAxis(float deadzone) { return dpad; }


short jstick::GetRightTrigger() { return r_trigger;}
short jstick::GetLeftTrigger() { return l_trigger; }

constexpr float short_range =  32768.f;

Vector2 jstick::GetLeftThumbstickAxisNormalized(float deadzone) {
    return l_thumb / short_range;
}

Vector2 jstick::GetRightThumbstickAxisNormalized(float deadzone) {
    return r_thumb / short_range;
}

Vector2 jstick::GetDPadAxisNormalized(float deadzone) {
    return dpad / short_range;
}

float jstick::GetLeftTriggerNormalized() {
    return l_trigger / short_range;
}

float jstick::GetRightTriggerNormalized() {
    return r_trigger / short_range;
}

jstick::ControllerType jstick::GetDeviceTypeFromName(const std::string &name) {
    if (name == "Microsoft X-Box 360 pad")
        return ControllerType::XBox;


    return ControllerType::Unknown;
}