/*
 * Copyright 2002-2008, Marcus Overhagen, Stefano Ceccherini, Fredrik Modéen.
 * All rights reserved.
 * Distributed under the terms of the MIT License.
 */


#include <Joystick.h>
#include <JoystickTweaker.h>

#include <new>
#include <stdio.h>
#include <sys/ioctl.h>

#include <Debug.h>
#include <Directory.h>
#include <List.h>
#include <Path.h>
#include <String.h>


#if DEBUG
static FILE *sLogFile = NULL;

inline void
LOG(const char *fmt, ...)
{
        char buf[1024];
        va_list ap;
        va_start(ap, fmt);
        vsprintf(buf, fmt, ap);
        va_end(ap);
        fputs(buf, sLogFile); fflush(sLogFile);
}

#       define LOG_ERR(text...) LOG(text)

#else
#       define LOG(text...)
#       define LOG_ERR(text...) fprintf(stderr, text)
#endif

#define CALLED() LOG("%s\n", __PRETTY_FUNCTION__)


BJoystick::BJoystick()
        :
        // legacy members for standard mode
        timestamp(0),
        horizontal(0),
        vertical(0),
        button1(true),
        button2(true),

        fBeBoxMode(false),
        fFD(-1),
        fDevices(new(std::nothrow) BList),
        fJoystickInfo(new(std::nothrow) joystick_info),
        fJoystickData(new(std::nothrow) BList)
{
#if DEBUG
        sLogFile = fopen("/var/log/joystick.log", "a");
#endif

        if (fJoystickInfo != NULL) {
                memset(&fJoystickInfo->module_info, 0, sizeof(joystick_module_info));
                fJoystickInfo->calibration_enable = false;
                fJoystickInfo->max_latency = 0;
        }

        RescanDevices();
}


BJoystick::~BJoystick()
{
        if (fFD >= 0)
                close(fFD);

        if (fDevices != NULL) {
                for (int32 i = 0; i < fDevices->CountItems(); i++)
                        delete (BString *)fDevices->ItemAt(i);

                delete fDevices;
        }

        delete fJoystickInfo;

        if (fJoystickData != NULL) {
                for (int32 i = 0; i < fJoystickData->CountItems(); i++) {
                        variable_joystick *variableJoystick
                                = (variable_joystick *)fJoystickData->ItemAt(i);
                        if (variableJoystick == NULL)
                                continue;

                        free(variableJoystick->data);
                        delete variableJoystick;
                }

                delete fJoystickData;
        }
}


status_t
BJoystick::Open(const char *portName)
{
        CALLED();
        return Open(portName, true);
}


status_t
BJoystick::Open(const char *portName, bool enhanced)
{
        CALLED();

        if (portName == NULL)
                return B_BAD_VALUE;

        if (fJoystickInfo == NULL || fJoystickData == NULL)
                return B_NO_INIT;

        fBeBoxMode = !enhanced;

        char nameBuffer[64];
        if (portName[0] != '/') {
                snprintf(nameBuffer, sizeof(nameBuffer), DEVICE_BASE_PATH"/%s",
                        portName);
        } else
                snprintf(nameBuffer, sizeof(nameBuffer), "%s", portName);

        if (fFD >= 0)
                close(fFD);

        // TODO: BeOS don't use O_EXCL, and this seems to lead to some issues. I
        // added this flag having read some comments by Marco Nelissen on the
        // annotated BeBook. I think BeOS uses O_RDWR | O_NONBLOCK here.
        fFD = open(nameBuffer, O_RDWR | O_NONBLOCK | O_EXCL);
        if (fFD < 0)
                return B_ERROR;

        // read the Joystick Description file for this port/joystick
        _BJoystickTweaker joystickTweaker(*this);
        joystickTweaker.GetInfo(fJoystickInfo, portName);

        // signal that we support variable reads
        fJoystickInfo->module_info.flags |= js_flag_variable_size_reads;

        LOG("ioctl - %d\n", fJoystickInfo->module_info.num_buttons);
        ioctl(fFD, B_JOYSTICK_SET_DEVICE_MODULE, &fJoystickInfo->module_info,
                sizeof(joystick_module_info));
        ioctl(fFD, B_JOYSTICK_GET_DEVICE_MODULE, &fJoystickInfo->module_info,
                sizeof(joystick_module_info));
        LOG("ioctl - %d\n", fJoystickInfo->module_info.num_buttons);

        // Allocate the variable_joystick structures to hold the info for each
        // "stick". Note that the whole num_sticks thing seems a bit bogus, as
        // all sticks would be required to have exactly the same attributes,
        // i.e. axis, hat and button counts, since there is only one global
        // joystick_info for the whole device. What's implemented here is a
        // "best guess", using the read position in Update() to select the
        // stick for which data shall be returned.
        bool supportsVariable
                = (fJoystickInfo->module_info.flags & js_flag_variable_size_reads) != 0;
        for (uint16 i = 0; i < fJoystickInfo->module_info.num_sticks; i++) {
                variable_joystick *variableJoystick
                        = new(std::nothrow) variable_joystick;
                if (variableJoystick == NULL)
                        return B_NO_MEMORY;

                status_t result;
                if (supportsVariable) {
                        // The driver supports arbitrary controls.
                        result = variableJoystick->initialize(
                                fJoystickInfo->module_info.num_axes,
                                fJoystickInfo->module_info.num_hats,
                                fJoystickInfo->module_info.num_buttons);
                } else {
                        // The driver doesn't support our variable requests so we construct
                        // a data structure that is compatible with extended_joystick and
                        // just use that in reads. This allows us to use a single data
                        // format internally but be compatible with both inputs.
                        result = variableJoystick->initialize_to_extended_joystick();

                        // Also ensure that we don't read over those boundaries.
                        if (fJoystickInfo->module_info.num_axes > MAX_AXES)
                                fJoystickInfo->module_info.num_axes = MAX_AXES;
                        if (fJoystickInfo->module_info.num_hats > MAX_HATS)
                                fJoystickInfo->module_info.num_hats = MAX_HATS;
                        if (fJoystickInfo->module_info.num_buttons > MAX_BUTTONS)
                                fJoystickInfo->module_info.num_buttons = MAX_BUTTONS;
                }

                if (result != B_OK) {
                        delete variableJoystick;
                        return result;
                }

                if (!fJoystickData->AddItem(variableJoystick)) {
                        free(variableJoystick->data);
                        delete variableJoystick;
                        return B_NO_MEMORY;
                }
        }

        return fFD;
}


void
BJoystick::Close(void)
{
        CALLED();
        if (fFD >= 0) {
                close(fFD);
                fFD = -1;
        }
}


status_t
BJoystick::Update()
{
        CALLED();
        if (fJoystickInfo == NULL || fJoystickData == NULL || fFD < 0)
                return B_NO_INIT;

        for (uint16 i = 0; i < fJoystickInfo->module_info.num_sticks; i++) {
                variable_joystick *values
                        = (variable_joystick *)fJoystickData->ItemAt(i);
                if (values == NULL)
                        return B_NO_INIT;

                ssize_t result = read_pos(fFD, i, values->data,
                        values->data_size);
                if (result < 0)
                        return result;

                if ((size_t)result != values->data_size)
                        return B_ERROR;

                if (i > 0)
                        continue;

                // fill in the legacy values for the first stick
                timestamp = *values->timestamp;

                if (values->axis_count >= 1)
                        horizontal = values->axes[0];
                else
                        horizontal = 0;

                if (values->axis_count >= 2)
                        vertical = values->axes[1];
                else
                        vertical = 0;

                if (values->button_blocks > 0) {
                        button1 = (*values->buttons & 1) == 0;
                        button2 = (*values->buttons & 2) == 0;
                } else {
                        button1 = true;
                        button2 = true;
                }
        }

        return B_OK;
}


status_t
BJoystick::SetMaxLatency(bigtime_t maxLatency)
{
        CALLED();
        if (fJoystickInfo == NULL || fFD < 0)
                return B_NO_INIT;

        status_t result = ioctl(fFD, B_JOYSTICK_SET_MAX_LATENCY, &maxLatency,
                sizeof(maxLatency));
        if (result == B_OK)
                fJoystickInfo->max_latency = maxLatency;

        return result;
}


int32
BJoystick::CountDevices()
{
        CALLED();

        if (fDevices == NULL)
                return 0;

        int32 count = fDevices->CountItems();

        LOG("Count = %d\n", count);
        return count;
}


status_t
BJoystick::GetDeviceName(int32 index, char *name, size_t bufSize)
{
        CALLED();
        if (fDevices == NULL)
                return B_NO_INIT;

        if (index >= fDevices->CountItems())
                return B_BAD_INDEX;

        if (name == NULL)
                return B_BAD_VALUE;

        BString *deviceName = (BString *)fDevices->ItemAt(index);
        if (deviceName->Length() > (int32)bufSize)
                return B_NAME_TOO_LONG;

        strlcpy(name, deviceName->String(), bufSize);
        LOG("Device Name = %s\n", name);
        return B_OK;
}


status_t
BJoystick::RescanDevices()
{
        CALLED();

        if (fDevices == NULL)
                return B_NO_INIT;

        ScanDevices(true);
        return B_OK;
}


bool
BJoystick::EnterEnhancedMode(const entry_ref *ref)
{
        CALLED();
        fBeBoxMode = false;
        return !fBeBoxMode;
}


int32
BJoystick::CountSticks()
{
        CALLED();
        if (fJoystickInfo == NULL)
                return 0;

        return fJoystickInfo->module_info.num_sticks;
}


int32
BJoystick::CountAxes()
{
        CALLED();
        if (fJoystickInfo == NULL)
                return 0;

        return fJoystickInfo->module_info.num_axes;
}


status_t
BJoystick::GetAxisValues(int16 *outValues, int32 forStick)
{
        CALLED();

        if (fJoystickInfo == NULL || fJoystickData == NULL)
                return B_NO_INIT;

        if (forStick < 0
                || forStick >= (int32)fJoystickInfo->module_info.num_sticks)
                return B_BAD_INDEX;

        variable_joystick *variableJoystick
                = (variable_joystick *)fJoystickData->ItemAt(forStick);
        if (variableJoystick == NULL)
                return B_NO_INIT;

        memcpy(outValues, variableJoystick->axes,
                fJoystickInfo->module_info.num_axes * sizeof(uint16));
        return B_OK;
}


status_t
BJoystick::GetAxisNameAt(int32 index, BString *outName)
{
        CALLED();

        if (index >= CountAxes())
                return B_BAD_INDEX;

        if (outName == NULL)
                return B_BAD_VALUE;

        // TODO: actually retrieve the name from the driver (via a new ioctl)
        *outName = "Axis ";
        *outName << index;
        return B_OK;
}


int32
BJoystick::CountHats()
{
        CALLED();
        if (fJoystickInfo == NULL)
                return 0;

        return fJoystickInfo->module_info.num_hats;
}


status_t
BJoystick::GetHatValues(uint8 *outHats, int32 forStick)
{
        CALLED();

        if (fJoystickInfo == NULL || fJoystickData == NULL)
                return B_NO_INIT;

        if (forStick < 0
                || forStick >= (int32)fJoystickInfo->module_info.num_sticks)
                return B_BAD_INDEX;

        variable_joystick *variableJoystick
                = (variable_joystick *)fJoystickData->ItemAt(forStick);
        if (variableJoystick == NULL)
                return B_NO_INIT;

        memcpy(outHats, variableJoystick->hats,
                fJoystickInfo->module_info.num_hats);
        return B_OK;
}


status_t
BJoystick::GetHatNameAt(int32 index, BString *outName)
{
        CALLED();

        if (index >= CountHats())
                return B_BAD_INDEX;

        if (outName == NULL)
                return B_BAD_VALUE;

        // TODO: actually retrieve the name from the driver (via a new ioctl)
        *outName = "Hat ";
        *outName << index;
        return B_OK;
}


int32
BJoystick::CountButtons()
{
        CALLED();
        if (fJoystickInfo == NULL)
                return 0;

        return fJoystickInfo->module_info.num_buttons;
}


uint32
BJoystick::ButtonValues(int32 forStick)
{
        CALLED();

        if (fJoystickInfo == NULL || fJoystickData == NULL)
                return 0;

        if (forStick < 0
                || forStick >= (int32)fJoystickInfo->module_info.num_sticks)
                return 0;

        variable_joystick *variableJoystick
                = (variable_joystick *)fJoystickData->ItemAt(forStick);
        if (variableJoystick == NULL || variableJoystick->button_blocks == 0)
                return 0;

        return *variableJoystick->buttons;
}


status_t
BJoystick::GetButtonValues(bool *outButtons, int32 forStick)
{
        CALLED();

        if (fJoystickInfo == NULL || fJoystickData == NULL)
                return B_NO_INIT;

        if (forStick < 0
                || forStick >= (int32)fJoystickInfo->module_info.num_sticks)
                return B_BAD_INDEX;

        variable_joystick *variableJoystick
                = (variable_joystick *)fJoystickData->ItemAt(forStick);
        if (variableJoystick == NULL)
                return B_NO_INIT;

        int16 buttonCount = fJoystickInfo->module_info.num_buttons;
        for (int16 i = 0; i < buttonCount; i++) {
                outButtons[i]
                        = (variableJoystick->buttons[i / 32] & (1 << (i % 32))) != 0;
        }

        return B_OK;
}


status_t
BJoystick::GetButtonNameAt(int32 index, BString *outName)
{
        CALLED();

        if (index >= CountButtons())
                return B_BAD_INDEX;

        if (outName == NULL)
                return B_BAD_VALUE;

        // TODO: actually retrieve the name from the driver (via a new ioctl)
        *outName = "Button ";
        *outName << index;
        return B_OK;
}


status_t
BJoystick::GetControllerModule(BString *outName)
{
        CALLED();
        if (fJoystickInfo == NULL || fFD < 0)
                return B_NO_INIT;

        if (outName == NULL)
                return B_BAD_VALUE;

        outName->SetTo(fJoystickInfo->module_info.module_name);
        return B_OK;
}


status_t
BJoystick::GetControllerName(BString *outName)
{
        CALLED();
        if (fJoystickInfo == NULL || fFD < 0)
                return B_NO_INIT;

        if (outName == NULL)
                return B_BAD_VALUE;

        outName->SetTo(fJoystickInfo->module_info.device_name);
        return B_OK;
}


bool
BJoystick::IsCalibrationEnabled()
{
        CALLED();
        if (fJoystickInfo == NULL)
                return false;

        return fJoystickInfo->calibration_enable;
}


status_t
BJoystick::EnableCalibration(bool calibrates)
{
        CALLED();
        if (fJoystickInfo == NULL || fFD < 0)
                return B_NO_INIT;

        status_t result = ioctl(fFD, B_JOYSTICK_SET_RAW_MODE, &calibrates,
                sizeof(calibrates));
        if (result == B_OK)
                fJoystickInfo->calibration_enable = calibrates;

        return result;
}


void
BJoystick::Calibrate(struct _extended_joystick *reading)
{
        CALLED();
}


void
BJoystick::ScanDevices(bool useDisabled)
{
        CALLED();
        if (useDisabled) {
                _BJoystickTweaker joystickTweaker(*this);
                joystickTweaker.scan_including_disabled();
        }
}


//      #pragma mark - FBC protection


void BJoystick::_ReservedJoystick1() {}
void BJoystick::_ReservedJoystick2() {}
void BJoystick::_ReservedJoystick3() {}
status_t BJoystick::_Reserved_Joystick_4(void*, ...) { return B_ERROR; }
status_t BJoystick::_Reserved_Joystick_5(void*, ...) { return B_ERROR; }
status_t BJoystick::_Reserved_Joystick_6(void*, ...) { return B_ERROR; }