/*

  Simple DirectMedia Layer

  Copyright (C) 1997-2016 Sam Lantinga <slouken@libsdl.org>

  This software is provided 'as-is', without any express or implied

  warranty.  In no event will the authors be held liable for any damages

  arising from the use of this software.

  Permission is granted to anyone to use this software for any purpose,

  including commercial applications, and to alter it and redistribute it

  freely, subject to the following restrictions:

  1. The origin of this software must not be misrepresented; you must not

     claim that you wrote the original software. If you use this software

     in a product, an acknowledgment in the product documentation would be

     appreciated but is not required.

  2. Altered source versions must be plainly marked as such, and must not be

     misrepresented as being the original software.

  3. This notice may not be removed or altered from any source distribution.

*/

#include "../SDL_internal.h"

/* This is the game controller API for Simple DirectMedia Layer */

#include "SDL_events.h"

#include "SDL_assert.h"

#include "SDL_sysjoystick.h"

#include "SDL_hints.h"

#include "SDL_gamecontrollerdb.h"

#if !SDL_EVENTS_DISABLED

#include "../events/SDL_events_c.h"

#endif

#define ABS(_x) ((_x) < 0 ? -(_x) : (_x))

#define SDL_CONTROLLER_PLATFORM_FIELD "platform:"

/* a list of currently opened game controllers */

static SDL_GameController *SDL_gamecontrollers = NULL;

/* keep track of the hat and mask value that transforms this hat movement into a button/axis press */

struct _SDL_HatMapping

{

    int hat;

    Uint8 mask;

};

#define k_nMaxReverseEntries 20

/**

 * We are encoding the "HAT" as 0xhm. where h == hat ID and m == mask

 * MAX 4 hats supported

 */

#define k_nMaxHatEntries 0x3f + 1

/* our in memory mapping db between joystick objects and controller mappings */

struct _SDL_ControllerMapping

{

    SDL_JoystickGUID guid;

    const char *name;

    /* mapping of axis/button id to controller version */

    int axes[SDL_CONTROLLER_AXIS_MAX];

    int buttonasaxis[SDL_CONTROLLER_AXIS_MAX];

    int buttons[SDL_CONTROLLER_BUTTON_MAX];

    int axesasbutton[SDL_CONTROLLER_BUTTON_MAX];

    struct _SDL_HatMapping hatasbutton[SDL_CONTROLLER_BUTTON_MAX];

    /* reverse mapping, joystick indices to buttons */

    SDL_GameControllerAxis raxes[k_nMaxReverseEntries];

    SDL_GameControllerAxis rbuttonasaxis[k_nMaxReverseEntries];

    SDL_GameControllerButton rbuttons[k_nMaxReverseEntries];

    SDL_GameControllerButton raxesasbutton[k_nMaxReverseEntries];

    SDL_GameControllerButton rhatasbutton[k_nMaxHatEntries];

};

/* our hard coded list of mapping support */

typedef struct _ControllerMapping_t

{

    SDL_JoystickGUID guid;

    char *name;

    char *mapping;

    struct _ControllerMapping_t *next;

} ControllerMapping_t;

static ControllerMapping_t *s_pSupportedControllers = NULL;

static ControllerMapping_t *s_pXInputMapping = NULL;

static ControllerMapping_t *s_pEmscriptenMapping = NULL;

/* The SDL game controller structure */

struct _SDL_GameController

{

    SDL_Joystick *joystick; /* underlying joystick device */

    int ref_count;

    Uint8 hatState[4]; /* the current hat state for this controller */

    struct _SDL_ControllerMapping mapping; /* the mapping object for this controller */

    struct _SDL_GameController *next; /* pointer to next game controller we have allocated */

};

int SDL_PrivateGameControllerAxis(SDL_GameController * gamecontroller, SDL_GameControllerAxis axis, Sint16 value);

int SDL_PrivateGameControllerButton(SDL_GameController * gamecontroller, SDL_GameControllerButton button, Uint8 state);

/*

 * Event filter to fire controller events from joystick ones

 */

int SDL_GameControllerEventWatcher(void *userdata, SDL_Event * event)

{

    switch(event->type) {

    case SDL_JOYAXISMOTION:

        {

            SDL_GameController *controllerlist;

            if (event->jaxis.axis >= k_nMaxReverseEntries) break;

            controllerlist = SDL_gamecontrollers;

            while (controllerlist) {

                if (controllerlist->joystick->instance_id == event->jaxis.which) {

                    if (controllerlist->mapping.raxes[event->jaxis.axis] >= 0) /* simple axis to axis, send it through */ {

                        SDL_GameControllerAxis axis = controllerlist->mapping.raxes[event->jaxis.axis];

                        Sint16 value = event->jaxis.value;

                        switch (axis) {

                            case SDL_CONTROLLER_AXIS_TRIGGERLEFT:

                            case SDL_CONTROLLER_AXIS_TRIGGERRIGHT:

                                /* Shift it to be 0 - 32767. */

                                value = value / 2 + 16384;

                            default:

                                break;

                        }

                        SDL_PrivateGameControllerAxis(controllerlist, axis, value);

                    } else if (controllerlist->mapping.raxesasbutton[event->jaxis.axis] >= 0) { /* simulate an axis as a button */

                        SDL_PrivateGameControllerButton(controllerlist, controllerlist->mapping.raxesasbutton[event->jaxis.axis], ABS(event->jaxis.value) > 32768/2 ? SDL_PRESSED : SDL_RELEASED);

                    }

                    break;

                }

                controllerlist = controllerlist->next;

            }

        }

        break;

    case SDL_JOYBUTTONDOWN:

    case SDL_JOYBUTTONUP:

        {

            SDL_GameController *controllerlist;

            if (event->jbutton.button >= k_nMaxReverseEntries) break;

            controllerlist = SDL_gamecontrollers;

            while (controllerlist) {

                if (controllerlist->joystick->instance_id == event->jbutton.which) {

                    if (controllerlist->mapping.rbuttons[event->jbutton.button] >= 0) { /* simple button as button */

                        SDL_PrivateGameControllerButton(controllerlist, controllerlist->mapping.rbuttons[event->jbutton.button], event->jbutton.state);

                    } else if (controllerlist->mapping.rbuttonasaxis[event->jbutton.button] >= 0) { /* an button pretending to be an axis */

                        SDL_PrivateGameControllerAxis(controllerlist, controllerlist->mapping.rbuttonasaxis[event->jbutton.button], event->jbutton.state > 0 ? 32767 : 0);

                    }

                    break;

                }

                controllerlist = controllerlist->next;

            }

        }

        break;

    case SDL_JOYHATMOTION:

        {

            SDL_GameController *controllerlist;

            if (event->jhat.hat >= 4) break;

            controllerlist = SDL_gamecontrollers;

            while (controllerlist) {

                if (controllerlist->joystick->instance_id == event->jhat.which) {

                    Uint8 bSame = controllerlist->hatState[event->jhat.hat] & event->jhat.value;

                    /* Get list of removed bits (button release) */

                    Uint8 bChanged = controllerlist->hatState[event->jhat.hat] ^ bSame;

                    /* the hat idx in the high nibble */

                    int bHighHat = event->jhat.hat << 4;

                    if (bChanged & SDL_HAT_DOWN)

                        SDL_PrivateGameControllerButton(controllerlist, controllerlist->mapping.rhatasbutton[bHighHat | SDL_HAT_DOWN], SDL_RELEASED);

                    if (bChanged & SDL_HAT_UP)

                        SDL_PrivateGameControllerButton(controllerlist, controllerlist->mapping.rhatasbutton[bHighHat | SDL_HAT_UP], SDL_RELEASED);

                    if (bChanged & SDL_HAT_LEFT)

                        SDL_PrivateGameControllerButton(controllerlist, controllerlist->mapping.rhatasbutton[bHighHat | SDL_HAT_LEFT], SDL_RELEASED);

                    if (bChanged & SDL_HAT_RIGHT)

                        SDL_PrivateGameControllerButton(controllerlist, controllerlist->mapping.rhatasbutton[bHighHat | SDL_HAT_RIGHT], SDL_RELEASED);

                    /* Get list of added bits (button press) */

                    bChanged = event->jhat.value ^ bSame;

                    if (bChanged & SDL_HAT_DOWN)

                        SDL_PrivateGameControllerButton(controllerlist, controllerlist->mapping.rhatasbutton[bHighHat | SDL_HAT_DOWN], SDL_PRESSED);

                    if (bChanged & SDL_HAT_UP)

                        SDL_PrivateGameControllerButton(controllerlist, controllerlist->mapping.rhatasbutton[bHighHat | SDL_HAT_UP], SDL_PRESSED);

                    if (bChanged & SDL_HAT_LEFT)

                        SDL_PrivateGameControllerButton(controllerlist, controllerlist->mapping.rhatasbutton[bHighHat | SDL_HAT_LEFT], SDL_PRESSED);

                    if (bChanged & SDL_HAT_RIGHT)

                        SDL_PrivateGameControllerButton(controllerlist, controllerlist->mapping.rhatasbutton[bHighHat | SDL_HAT_RIGHT], SDL_PRESSED);

                    /* update our state cache */

                    controllerlist->hatState[event->jhat.hat] = event->jhat.value;

                    break;

                }

                controllerlist = controllerlist->next;

            }

        }

        break;

    case SDL_JOYDEVICEADDED:

        {

            if (SDL_IsGameController(event->jdevice.which)) {

                SDL_Event deviceevent;

                deviceevent.type = SDL_CONTROLLERDEVICEADDED;

                deviceevent.cdevice.which = event->jdevice.which;

                SDL_PushEvent(&deviceevent);

            }

        }

        break;

    case SDL_JOYDEVICEREMOVED:

        {

            SDL_GameController *controllerlist = SDL_gamecontrollers;

            while (controllerlist) {

                if (controllerlist->joystick->instance_id == event->jdevice.which) {

                    SDL_Event deviceevent;

                    deviceevent.type = SDL_CONTROLLERDEVICEREMOVED;

                    deviceevent.cdevice.which = event->jdevice.which;

                    SDL_PushEvent(&deviceevent);

                    break;

                }

                controllerlist = controllerlist->next;

            }

        }

        break;

    default:

        break;

    }

    return 1;

}

/*

 * Helper function to scan the mappings database for a controller with the specified GUID

 */

ControllerMapping_t *SDL_PrivateGetControllerMappingForGUID(SDL_JoystickGUID *guid)

{

    ControllerMapping_t *pSupportedController = s_pSupportedControllers;

    while (pSupportedController) {

        if (SDL_memcmp(guid, &pSupportedController->guid, sizeof(*guid)) == 0) {

            return pSupportedController;

        }

        pSupportedController = pSupportedController->next;

    }

    return NULL;

}

static const char* map_StringForControllerAxis[] = {

    "leftx",

    "lefty",

    "rightx",

    "righty",

    "lefttrigger",

    "righttrigger",

    NULL

};

/*

 * convert a string to its enum equivalent

 */

SDL_GameControllerAxis SDL_GameControllerGetAxisFromString(const char *pchString)

{

    int entry;

    if (!pchString || !pchString[0])

        return SDL_CONTROLLER_AXIS_INVALID;

    for (entry = 0; map_StringForControllerAxis[entry]; ++entry) {

        if (!SDL_strcasecmp(pchString, map_StringForControllerAxis[entry]))

            return entry;

    }

    return SDL_CONTROLLER_AXIS_INVALID;

}

/*

 * convert an enum to its string equivalent

 */

const char* SDL_GameControllerGetStringForAxis(SDL_GameControllerAxis axis)

{

    if (axis > SDL_CONTROLLER_AXIS_INVALID && axis < SDL_CONTROLLER_AXIS_MAX) {

        return map_StringForControllerAxis[axis];

    }

    return NULL;

}

static const char* map_StringForControllerButton[] = {

    "a",

    "b",

    "x",

    "y",

    "back",

    "guide",

    "start",

    "leftstick",

    "rightstick",

    "leftshoulder",

    "rightshoulder",

    "dpup",

    "dpdown",

    "dpleft",

    "dpright",

    NULL

};

/*

 * convert a string to its enum equivalent

 */

SDL_GameControllerButton SDL_GameControllerGetButtonFromString(const char *pchString)

{

    int entry;

    if (!pchString || !pchString[0])

        return SDL_CONTROLLER_BUTTON_INVALID;

    for (entry = 0; map_StringForControllerButton[entry]; ++entry) {

        if (SDL_strcasecmp(pchString, map_StringForControllerButton[entry]) == 0)

            return entry;

    }

    return SDL_CONTROLLER_BUTTON_INVALID;

}

/*

 * convert an enum to its string equivalent

 */

const char* SDL_GameControllerGetStringForButton(SDL_GameControllerButton axis)

{

    if (axis > SDL_CONTROLLER_BUTTON_INVALID && axis < SDL_CONTROLLER_BUTTON_MAX) {

        return map_StringForControllerButton[axis];

    }

    return NULL;

}

/*

 * given a controller button name and a joystick name update our mapping structure with it

 */

void SDL_PrivateGameControllerParseButton(const char *szGameButton, const char *szJoystickButton, struct _SDL_ControllerMapping *pMapping)

{

    int iSDLButton = 0;

    SDL_GameControllerButton button;

    SDL_GameControllerAxis axis;

    button = SDL_GameControllerGetButtonFromString(szGameButton);

    axis = SDL_GameControllerGetAxisFromString(szGameButton);

    iSDLButton = SDL_atoi(&szJoystickButton[1]);

    if (szJoystickButton[0] == 'a') {

        if (iSDLButton >= k_nMaxReverseEntries) {

            SDL_SetError("Axis index too large: %d", iSDLButton);

            return;

        }

        if (axis != SDL_CONTROLLER_AXIS_INVALID) {

            pMapping->axes[ axis ] = iSDLButton;

            pMapping->raxes[ iSDLButton ] = axis;

        } else if (button != SDL_CONTROLLER_BUTTON_INVALID) {

            pMapping->axesasbutton[ button ] = iSDLButton;

            pMapping->raxesasbutton[ iSDLButton ] = button;

        } else {

            SDL_assert(!"How did we get here?");

        }

    } else if (szJoystickButton[0] == 'b') {

        if (iSDLButton >= k_nMaxReverseEntries) {

            SDL_SetError("Button index too large: %d", iSDLButton);

            return;

        }

        if (button != SDL_CONTROLLER_BUTTON_INVALID) {

            pMapping->buttons[ button ] = iSDLButton;

            pMapping->rbuttons[ iSDLButton ] = button;

        } else if (axis != SDL_CONTROLLER_AXIS_INVALID) {

            pMapping->buttonasaxis[ axis ] = iSDLButton;

            pMapping->rbuttonasaxis[ iSDLButton ] = axis;

        } else {

            SDL_assert(!"How did we get here?");

        }

    } else if (szJoystickButton[0] == 'h') {

        int hat = SDL_atoi(&szJoystickButton[1]);

        int mask = SDL_atoi(&szJoystickButton[3]);

        if (hat >= 4) {

            SDL_SetError("Hat index too large: %d", iSDLButton);

        }

        if (button != SDL_CONTROLLER_BUTTON_INVALID) {

            int ridx;

            pMapping->hatasbutton[ button ].hat = hat;

            pMapping->hatasbutton[ button ].mask = mask;

            ridx = (hat << 4) | mask;

            pMapping->rhatasbutton[ ridx ] = button;

        } else if (axis != SDL_CONTROLLER_AXIS_INVALID) {

            SDL_assert(!"Support hat as axis");

        } else {

            SDL_assert(!"How did we get here?");

        }

    }

}

/*

 * given a controller mapping string update our mapping object

 */

static void

SDL_PrivateGameControllerParseControllerConfigString(struct _SDL_ControllerMapping *pMapping, const char *pchString)

{

    char szGameButton[20];

    char szJoystickButton[20];

    SDL_bool bGameButton = SDL_TRUE;

    int i = 0;

    const char *pchPos = pchString;

    SDL_memset(szGameButton, 0x0, sizeof(szGameButton));

    SDL_memset(szJoystickButton, 0x0, sizeof(szJoystickButton));

    while (pchPos && *pchPos) {

        if (*pchPos == ':') {

            i = 0;

            bGameButton = SDL_FALSE;

        } else if (*pchPos == ' ') {

        } else if (*pchPos == ',') {

            i = 0;

            bGameButton = SDL_TRUE;

            SDL_PrivateGameControllerParseButton(szGameButton, szJoystickButton, pMapping);

            SDL_memset(szGameButton, 0x0, sizeof(szGameButton));

            SDL_memset(szJoystickButton, 0x0, sizeof(szJoystickButton));

        } else if (bGameButton) {

            if (i >= sizeof(szGameButton)) {

                SDL_SetError("Button name too large: %s", szGameButton);

                return;

            }

            szGameButton[i] = *pchPos;

            i++;

        } else {

            if (i >= sizeof(szJoystickButton)) {

                SDL_SetError("Joystick button name too large: %s", szJoystickButton);

                return;

            }

            szJoystickButton[i] = *pchPos;

            i++;

        }

        pchPos++;

    }

    SDL_PrivateGameControllerParseButton(szGameButton, szJoystickButton, pMapping);

}

/*

 * Make a new button mapping struct

 */

void SDL_PrivateLoadButtonMapping(struct _SDL_ControllerMapping *pMapping, SDL_JoystickGUID guid, const char *pchName, const char *pchMapping)

{