/*
  Simple DirectMedia Layer
  Copyright (C) 1997-2015 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.
*/

/*
  Contributed by Brandon Schaefer, <brandon.schaefer@canonical.com>
*/

#include "../../SDL_internal.h"

#if SDL_VIDEO_DRIVER_MIR

#include "../../events/SDL_events_c.h"
#include "../../events/SDL_keyboard_c.h"
#include "../../events/SDL_touch_c.h"
#include "../../events/scancodes_xfree86.h"

#include "SDL_mirevents.h"
#include "SDL_mirwindow.h"
#include "SDL_log.h"
#include <xkbcommon/xkbcommon.h>

#include "SDL_mirdyn.h"


static void
HandleKeyText(int32_t key_code)
{
    char text[8];
    int size = 0;

    size = MIR_xkb_keysym_to_utf8(key_code, text, sizeof text);

    if (size > 0) {
        text[size] = '\0';
        SDL_SendKeyboardText(text);
    }
}

static void
CheckKeyboardFocus(SDL_Window* sdl_window)
{
    SDL_Window* keyboard_window = SDL_GetKeyboardFocus();

    if (keyboard_window != sdl_window)
        SDL_SetKeyboardFocus(sdl_window);
}


/* FIXME
   Mir still needs to implement its IM API, for now we assume
   a single key press produces a character.
*/
static void
HandleKeyEvent(MirKeyEvent const ev, SDL_Window* window)
{
    const uint32_t unsigned_ev_scan_code = ev.scan_code;
    uint32_t scancode = SDL_SCANCODE_UNKNOWN;
    Uint8 key_state = ev.action == mir_key_action_up ? SDL_RELEASED : SDL_PRESSED;

    CheckKeyboardFocus(window);

    if (unsigned_ev_scan_code < SDL_arraysize(xfree86_scancode_table2))
        scancode = xfree86_scancode_table2[ev.scan_code];

    if (scancode != SDL_SCANCODE_UNKNOWN)
        SDL_SendKeyboardKey(key_state, scancode);

    if (key_state == SDL_PRESSED)
        HandleKeyText(ev.key_code);
}

#define AMOTION_EVENT_ACTION_MASK                   0xff
#define AMOTION_EVENT_ACTION_POINTER_INDEX_MASK     0xff00
#define AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT    8

static int32_t
getActionMasked(MirMotionEvent const motion)
{
    return motion.action & AMOTION_EVENT_ACTION_MASK; 
}

static int32_t
getActionIndex(MirMotionEvent const motion) 
{
    return (motion.action & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK)
        >> AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
}

static uint32_t
mir_2_sdl_button_state(MirMotionButton button_state)
{
    static uint32_t last_sdl_button;
    uint32_t sdl_button;

    switch (button_state) {
        case mir_motion_button_primary:
            sdl_button = SDL_BUTTON_LEFT;
            break;
        case mir_motion_button_secondary:
            sdl_button = SDL_BUTTON_RIGHT;
            break;
        case mir_motion_button_tertiary:
            sdl_button = SDL_BUTTON_MIDDLE;
            break;
        case mir_motion_button_forward:
            sdl_button = SDL_BUTTON_X1;
            break;
        case mir_motion_button_back:
            sdl_button = SDL_BUTTON_X2;
            break;
        default:
            sdl_button = last_sdl_button;
            break;
    }

    last_sdl_button = sdl_button;
    return sdl_button;
}


// Very Similar to "Android_OnTouch" in the file "SDL_androidtouch.c"
static void
Mir_OnTouch(int touch_device_id_in, int pointer_finger_id_in, int action, float x, float y, float p,
        SDL_Window *sdl_window, MirMotionButton mmb)
{
    SDL_TouchID touchDeviceId = 0;
    SDL_FingerID fingerId = 0;
    int window_x, window_y;
    static SDL_FingerID pointerFingerID = 0;

    int mWidth = sdl_window->w;
    int mHeight = sdl_window->h;

    touchDeviceId = (SDL_TouchID)touch_device_id_in;
    if (SDL_AddTouch(touchDeviceId, "") < 0) {
        SDL_Log("error: can't add touch %s, %d", __FILE__, __LINE__);
    }

    fingerId = (SDL_FingerID)pointer_finger_id_in;

    switch (action) {

        case mir_motion_action_down:
            /* Primary pointer down */
            window_x = x * mWidth;
            window_y = y * mHeight;
            /* send moved event */
            SDL_SendMouseMotion(NULL, SDL_TOUCH_MOUSEID, 0, window_x, window_y);
            /* send mouse down event */
            SDL_SendMouseButton(NULL, SDL_TOUCH_MOUSEID, SDL_PRESSED, mir_2_sdl_button_state(mmb));
            pointerFingerID = fingerId;
        case mir_motion_action_pointer_down:
            /* Non primary pointer down */
            SDL_SendTouch(touchDeviceId, fingerId, SDL_TRUE, x, y, p);
            break;
            
        case mir_motion_action_hover_move: // ? Also this one ?
        case mir_motion_action_move:
            if (!pointerFingerID) {
                window_x = x * mWidth;
                window_y = y * mHeight;
                /* send moved event */
                SDL_SendMouseMotion(NULL, SDL_TOUCH_MOUSEID, 0, window_x, window_y);
            }
            SDL_SendTouchMotion(touchDeviceId, fingerId, x, y, p);
            break;
            
        case mir_motion_action_up:
            /* Primary pointer up */
            /* send mouse up */
            pointerFingerID = (SDL_FingerID) 0;
            SDL_SendMouseButton(NULL, SDL_TOUCH_MOUSEID, SDL_RELEASED, mir_2_sdl_button_state(mmb));
        case mir_motion_action_pointer_up:
            /* Non primary pointer up */
            SDL_SendTouch(touchDeviceId, fingerId, SDL_FALSE, x, y, p);
            break;
            
        default:
            SDL_Log("Not handled MirEvent action=%08x (Mir_OnTouch)", action);
            break;
    }
}



// Very Similar to "public boolean onTouch(View v, MotionEvent event)" in the file "SDLActivity.java"
static void
HandleMotionEvent(MirMotionEvent event, SDL_Window* sdl_window)
{
    /* Ref: http://developer.android.com/training/gestures/multi.html */
    const int touchDevId = event.device_id;
    const int pointerCount = event.pointer_count;
    const int action = getActionMasked(event);
    int pointerFingerId;
    int i = -1;
    float x,y,p;

    const int mWidth = sdl_window->w;
    const int mHeight = sdl_window->h;

    switch (action) {    

        case mir_motion_action_hover_move: // TODO  Also this one ?
        case mir_motion_action_move:
            for (i = 0; i < pointerCount; i++) {
                pointerFingerId = event.pointer_coordinates[i].id;
                x = event.pointer_coordinates[i].x / mWidth;
                y = event.pointer_coordinates[i].y / mHeight;
                p = event.pointer_coordinates[i].pressure;
                Mir_OnTouch(touchDevId, pointerFingerId, action, x, y, p, sdl_window, event.button_state);
            }
            break;

            /* 
             * http://developer.android.com/reference/android/view/MotionEvent.html
             *
             * The current gesture has been aborted. You will not receive any
             * more points in it. You should treat this as an up event, but not
             * perform any action that you normally would.
             */
        case mir_motion_action_cancel:
            for (i = 0; i < pointerCount; i++) {
                pointerFingerId = event.pointer_coordinates[i].id;
                x = event.pointer_coordinates[i].x / mWidth;
                y = event.pointer_coordinates[i].y / mHeight;
                p = event.pointer_coordinates[i].pressure;
                Mir_OnTouch(touchDevId, pointerFingerId, mir_motion_action_up, x, y, p, sdl_window, event.button_state);
            }
            break;

        case mir_motion_action_up:
        case mir_motion_action_down:
            // Primary pointer up/down, the index is always zero
            i = 0;
            pointerFingerId = event.pointer_coordinates[i].id;
            x = event.pointer_coordinates[i].x / mWidth;
            y = event.pointer_coordinates[i].y / mHeight;
            p = event.pointer_coordinates[i].pressure;
            Mir_OnTouch(touchDevId, pointerFingerId, action, x, y, p, sdl_window, event.button_state);
            break;

        case mir_motion_action_pointer_up:
            // BUG MIR = need to check all FingerId not to miss any FINGER_UP
            // this brings some duplicate FINGER_UP.
            for (i = 0; i < pointerCount; i++) {
                pointerFingerId = event.pointer_coordinates[i].id;
                x = event.pointer_coordinates[i].x / mWidth;
                y = event.pointer_coordinates[i].y / mHeight;
                p = event.pointer_coordinates[i].pressure;
                Mir_OnTouch(touchDevId, pointerFingerId, action, x, y, p, sdl_window, event.button_state);
            }
            break;

        case mir_motion_action_pointer_down:
            // Non primary pointer up/down
            i = getActionIndex(event);
            pointerFingerId = event.pointer_coordinates[i].id;
            x = event.pointer_coordinates[i].x / mWidth;
            y = event.pointer_coordinates[i].y / mHeight;
            p = event.pointer_coordinates[i].pressure;
            Mir_OnTouch(touchDevId, pointerFingerId, action, x, y, p, sdl_window, event.button_state);
            break;

        case mir_motion_action_outside:
            SDL_SetMouseFocus(NULL);
            break;

        case mir_motion_action_scroll:
            for (i = 0; i < pointerCount; i++) {
                SDL_SendMouseWheel(sdl_window, 0,
                    event.pointer_coordinates[i].hscroll,
                    event.pointer_coordinates[i].vscroll, 
                    SDL_MOUSEWHEEL_NORMAL
                    );
            } 

        case mir_motion_action_hover_enter:
            // TODO 
            break;

        case mir_motion_action_hover_exit:
            // TODO 
            break;

        default:
            SDL_Log("Nandled MirMotionEvent action=%08x", action);
            break;
    }    

    return;
}

static void 
HandleSurfaceEvent(MirSurfaceEvent event, SDL_Window * sdl_window)
{
    switch (event.attrib) {
        case mir_surface_attrib_type:
            SDL_Log("Not Handled MirSurfaceEvent Type id=%d value=%d", event.id, event.value);
            break;
        case mir_surface_attrib_state:
            SDL_Log("Not Handled MirSurfaceEvent State id=%d value=%d", event.id, event.value);
            break;
        case mir_surface_attrib_swapinterval:
            SDL_Log("Not Handled MirSurfaceEvent SwapInterval id=%d value=%d", event.id, event.value);
            break;
        case mir_surface_attrib_focus:
            if (event.value) {
                SDL_SetMouseFocus(sdl_window);
            } else {
                SDL_SetMouseFocus(NULL);
            }
            break;
        case mir_surface_attribs:
            SDL_Log("Not Handled MirSurfaceEvent Attribs id=%d value=%d", event.id, event.value);
            break;
        default:
            SDL_Log("Not Handled MirSurfaceEvent Unkown id=%d value=%d", event.id, event.value);
            break;
    }

    return;
}

static void
HandleResizeEvent(MirResizeEvent event, SDL_Window *sdl_window)
{
    SDL_Log("Not Handled MirResizeEvent surface_id=%d width=%d height=%d", event.surface_id, event.width, event.height);
    return;
}
 

void
MIR_HandleInput(MirSurface* surface, MirEvent const* ev, void* context)
{
    SDL_Window* window = (SDL_Window*)context;
    switch (ev->type) {
        case mir_event_type_key:
            HandleKeyEvent(ev->key, window);
            break;
        case mir_event_type_motion:
            HandleMotionEvent(ev->motion, window);
            break;
        case mir_event_type_surface:
            HandleSurfaceEvent(ev->surface, window);
            break;
        case mir_event_type_resize:
            HandleResizeEvent(ev->resize, window);
            break;
        default:
            SDL_Log("Not handled MirEvent type=%08x", ev->type);
            break;
    }
}

#endif /* SDL_VIDEO_DRIVER_MIR */

/* vi: set ts=4 sw=4 expandtab: */