/*
    SDL - Simple DirectMedia Layer
    Copyright (C) 1997-2006 Sam Lantinga

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    Sam Lantinga
    slouken@libsdl.org
*/
#include "SDL_config.h"

/* Handle the event stream, converting Amiga events into SDL events */
#include "SDL.h"

#include "SDL_syswm.h"
#include "../SDL_sysvideo.h"
#include "../../events/SDL_sysevents.h"
#include "../../events/SDL_events_c.h"
#include "SDL_cgxvideo.h"
#include "SDL_cgxmodes_c.h"
#include "SDL_cgximage_c.h"
#include "SDL_cgxwm_c.h"
#include "SDL_amigaevents_c.h"


/* The translation tables from an Amiga keysym to a SDL keysym */
static SDLKey MISC_keymap[256];
SDL_keysym *amiga_TranslateKey(int code, SDL_keysym * keysym);
struct IOStdReq *ConReq = NULL;
struct MsgPort *ConPort = NULL;

/* Note:  The X server buffers and accumulates mouse motion events, so
   the motion event generated by the warp may not appear exactly as we
   expect it to.  We work around this (and improve performance) by only
   warping the pointer when it reaches the edge, and then wait for it.
*/
#define MOUSE_FUDGE_FACTOR	8

#if 0

static inline int
amiga_WarpedMotion(_THIS, struct IntuiMessage *m)
{
    int w, h, i;
    int deltax, deltay;
    int posted;

    w = SDL_VideoSurface->w;
    h = SDL_VideoSurface->h;
    deltax = xevent->xmotion.x - mouse_last.x;
    deltay = xevent->xmotion.y - mouse_last.y;
#ifdef DEBUG_MOTION
    printf("Warped mouse motion: %d,%d\n", deltax, deltay);
#endif
    mouse_last.x = xevent->xmotion.x;
    mouse_last.y = xevent->xmotion.y;
    posted = SDL_PrivateMouseMotion(0, 1, deltax, deltay);

    if ((xevent->xmotion.x < MOUSE_FUDGE_FACTOR) ||
        (xevent->xmotion.x > (w - MOUSE_FUDGE_FACTOR)) ||
        (xevent->xmotion.y < MOUSE_FUDGE_FACTOR) ||
        (xevent->xmotion.y > (h - MOUSE_FUDGE_FACTOR))) {
        /* Get the events that have accumulated */
        while (XCheckTypedEvent(SDL_Display, MotionNotify, xevent)) {
            deltax = xevent->xmotion.x - mouse_last.x;
            deltay = xevent->xmotion.y - mouse_last.y;
#ifdef DEBUG_MOTION
            printf("Extra mouse motion: %d,%d\n", deltax, deltay);
#endif
            mouse_last.x = xevent->xmotion.x;
            mouse_last.y = xevent->xmotion.y;
            posted += SDL_PrivateMouseMotion(0, 1, deltax, deltay);
        }
        mouse_last.x = w / 2;
        mouse_last.y = h / 2;
        XWarpPointer(SDL_Display, None, SDL_Window, 0, 0, 0, 0,
                     mouse_last.x, mouse_last.y);
        for (i = 0; i < 10; ++i) {
            XMaskEvent(SDL_Display, PointerMotionMask, xevent);
            if ((xevent->xmotion.x >
                 (mouse_last.x - MOUSE_FUDGE_FACTOR)) &&
                (xevent->xmotion.x <
                 (mouse_last.x + MOUSE_FUDGE_FACTOR)) &&
                (xevent->xmotion.y >
                 (mouse_last.y - MOUSE_FUDGE_FACTOR)) &&
                (xevent->xmotion.y < (mouse_last.y + MOUSE_FUDGE_FACTOR))) {
                break;
            }
#ifdef DEBUG_XEVENTS
            printf("Lost mouse motion: %d,%d\n", xevent->xmotion.x,
                   xevent->xmotion.y);
#endif
        }
#ifdef DEBUG_XEVENTS
        if (i == 10) {
            printf("Warning: didn't detect mouse warp motion\n");
        }
#endif
    }
    return (posted);
}

#endif

static int
amiga_GetButton(int code)
{
    switch (code) {
    case IECODE_MBUTTON:
        return SDL_BUTTON_MIDDLE;
    case IECODE_RBUTTON:
        return SDL_BUTTON_RIGHT;
    default:
        return SDL_BUTTON_LEFT;
    }
}

static int
amiga_DispatchEvent(_THIS, struct IntuiMessage *msg)
{
    int class = msg->Class, code = msg->Code;
    int posted;

    posted = 0;
    switch (class) {
        /* Gaining mouse coverage? */
    case IDCMP_ACTIVEWINDOW:
        posted = SDL_PrivateAppActive(1, SDL_APPMOUSEFOCUS);
        break;

        /* Losing mouse coverage? */
    case IDCMP_INACTIVEWINDOW:
        posted = SDL_PrivateAppActive(0, SDL_APPMOUSEFOCUS);
        break;
#if 0
        /* Gaining input focus? */
    case IDCMP_ACTIVEWINDOW:
        posted = SDL_PrivateAppActive(1, SDL_APPINPUTFOCUS);

        /* Queue entry into fullscreen mode */
        switch_waiting = 0x01 | SDL_FULLSCREEN;
        switch_time = SDL_GetTicks() + 1500;
        break;

        /* Losing input focus? */
    case IDCMP_INACTIVEWINDOW:
        posted = SDL_PrivateAppActive(0, SDL_APPINPUTFOCUS);

        /* Queue leaving fullscreen mode */
        switch_waiting = 0x01;
        switch_time = SDL_GetTicks() + 200;
        break;
#endif
        /* Mouse motion? */
    case IDCMP_MOUSEMOVE:
        if (SDL_VideoSurface) {
            posted = SDL_PrivateMouseMotion(0, 0,
                                            msg->MouseX -
                                            SDL_Window->BorderLeft,
                                            msg->MouseY -
                                            SDL_Window->BorderTop);
        }
        break;

        /* Mouse button press? */
    case IDCMP_MOUSEBUTTONS:

        if (!(code & IECODE_UP_PREFIX)) {
            posted = SDL_PrivateMouseButton(SDL_PRESSED,
                                            amiga_GetButton(code), 0, 0);
        }
        /* Mouse button release? */
        else {
            code &= ~IECODE_UP_PREFIX;
            posted = SDL_PrivateMouseButton(SDL_RELEASED,
                                            amiga_GetButton(code), 0, 0);
        }
        break;

    case IDCMP_RAWKEY:

        /* Key press? */

        if (!(code & IECODE_UP_PREFIX)) {
            SDL_keysym keysym;
            posted = SDL_PrivateKeyboard(SDL_PRESSED,
                                         amiga_TranslateKey(code, &keysym));
        } else {
            /* Key release? */

            SDL_keysym keysym;
            code &= ~IECODE_UP_PREFIX;

            /* Check to see if this is a repeated key */
/*			if ( ! X11_KeyRepeat(SDL_Display, &xevent) )  */

            posted = SDL_PrivateKeyboard(SDL_RELEASED,
                                         amiga_TranslateKey(code, &keysym));
        }
        break;
        /* Have we been iconified? */
#if 0
    case UnmapNotify:
        {
#ifdef DEBUG_XEVENTS
            printf("UnmapNotify!\n");
#endif
            posted =
                SDL_PrivateAppActive(0, SDL_APPACTIVE | SDL_APPINPUTFOCUS);
        }
        break;

        /* Have we been restored? */

    case MapNotify:
        {
#ifdef DEBUG_XEVENTS
            printf("MapNotify!\n");
#endif

            posted = SDL_PrivateAppActive(1, SDL_APPACTIVE);

            if (SDL_VideoSurface &&
                (SDL_VideoSurface->flags & SDL_FULLSCREEN)) {
                CGX_EnterFullScreen(this);
            } else {
                X11_GrabInputNoLock(this, this->input_grab);
            }
            if (SDL_VideoSurface) {
                CGX_RefreshDisplay(this);
            }
        }
        break;
    case Expose:
        if (SDL_VideoSurface && (xevent.xexpose.count == 0)) {
            CGX_RefreshDisplay(this);
        }
        break;
#endif

        /* Have we been resized? */
    case IDCMP_NEWSIZE:
        SDL_PrivateResize(SDL_Window->Width - SDL_Window->BorderLeft -
                          SDL_Window->BorderRight,
                          SDL_Window->Height - SDL_Window->BorderTop -
                          SDL_Window->BorderBottom);

        break;

        /* Have we been requested to quit? */
    case IDCMP_CLOSEWINDOW:
        posted = SDL_PrivateQuit();
        break;

        /* Do we need to refresh ourselves? */

    default:
        {
            /* Only post the event if we're watching for it */
            if (SDL_ProcessEvents[SDL_SYSWMEVENT] == SDL_ENABLE) {
                SDL_SysWMmsg wmmsg;

                SDL_VERSION(&wmmsg.version);
#if 0
                wmmsg.subsystem = SDL_SYSWM_CGX;
                wmmsg.event.xevent = xevent;
#endif
                posted = SDL_PrivateSysWMEvent(&wmmsg);
            }
        }
        break;
    }
    ReplyMsg((struct Message *) msg);


    return (posted);
}

void
amiga_PumpEvents(_THIS)
{
    int pending;
    struct IntuiMessage *m;

    /* Keep processing pending events */
    pending = 0;
    while (m = (struct IntuiMessage *) GetMsg(SDL_Window->UserPort)) {
        amiga_DispatchEvent(this, m);
        ++pending;
    }
}

void
amiga_InitKeymap(void)
{
    int i;

    /* Map the miscellaneous keys */
    for (i = 0; i < SDL_arraysize(MISC_keymap); ++i)
        MISC_keymap[i] = SDLK_UNKNOWN;

    /* These X keysyms have 0xFF as the high byte */
    MISC_keymap[65] = SDLK_BACKSPACE;
    MISC_keymap[66] = SDLK_TAB;
    MISC_keymap[70] = SDLK_CLEAR;
    MISC_keymap[70] = SDLK_DELETE;
    MISC_keymap[68] = SDLK_RETURN;
//      MISC_keymap[XK_Pause&0xFF] = SDLK_PAUSE;
    MISC_keymap[69] = SDLK_ESCAPE;
    MISC_keymap[70] = SDLK_DELETE;
/*
	SDLK_SPACE		= 32,
	SDLK_MINUS		= 45,
	SDLK_LESS		= 60,
	SDLK_COMMA		= 44,
	SDLK_PERIOD		= 46,
	SDLK_0			= 48,
	SDLK_1			= 49,
	SDLK_2			= 50,
	SDLK_3			= 51,
	SDLK_4			= 52,
	SDLK_5			= 53,
	SDLK_6			= 54,
	SDLK_7			= 55,
	SDLK_8			= 56,
	SDLK_9			= 57,
	SDLK_BACKQUOTE		= 96,
	SDLK_BACKSLASH		= 92,
	SDLK_a			= 97,
	SDLK_b			= 98,
	SDLK_c			= 99,
	SDLK_d			= 100,
	SDLK_e			= 101,
	SDLK_f			= 102,
	SDLK_g			= 103,
	SDLK_h			= 104,
	SDLK_i			= 105,
	SDLK_j			= 106,
	SDLK_k			= 107,
	SDLK_l			= 108,
	SDLK_m			= 109,
	SDLK_n			= 110,
	SDLK_o			= 111,
	SDLK_p			= 112,
	SDLK_q			= 113,
	SDLK_r			= 114,
	SDLK_s			= 115,
	SDLK_t			= 116,
	SDLK_u			= 117,
	SDLK_v			= 118,
	SDLK_w			= 119,
	SDLK_x			= 120,
	SDLK_y			= 121,
	SDLK_z			= 122,
*/
    MISC_keymap[15] = SDLK_KP0; /* Keypad 0-9 */
    MISC_keymap[29] = SDLK_KP1;
    MISC_keymap[30] = SDLK_KP2;
    MISC_keymap[31] = SDLK_KP3;
    MISC_keymap[45] = SDLK_KP4;
    MISC_keymap[46] = SDLK_KP5;
    MISC_keymap[47] = SDLK_KP6;
    MISC_keymap[61] = SDLK_KP7;
    MISC_keymap[62] = SDLK_KP8;
    MISC_keymap[63] = SDLK_KP9;
    MISC_keymap[60] = SDLK_KP_PERIOD;
    MISC_keymap[92] = SDLK_KP_DIVIDE;
    MISC_keymap[93] = SDLK_KP_MULTIPLY;
    MISC_keymap[74] = SDLK_KP_MINUS;
    MISC_keymap[94] = SDLK_KP_PLUS;
    MISC_keymap[67] = SDLK_KP_ENTER;
//      MISC_keymap[XK_KP_Equal&0xFF] = SDLK_KP_EQUALS;

    MISC_keymap[76] = SDLK_UP;
    MISC_keymap[77] = SDLK_DOWN;
    MISC_keymap[78] = SDLK_RIGHT;
    MISC_keymap[79] = SDLK_LEFT;
/*
	MISC_keymap[XK_Insert&0xFF] = SDLK_INSERT;
	MISC_keymap[XK_Home&0xFF] = SDLK_HOME;
	MISC_keymap[XK_End&0xFF] = SDLK_END;
*/
// Mappati sulle parentesi del taastierino
    MISC_keymap[90] = SDLK_PAGEUP;
    MISC_keymap[91] = SDLK_PAGEDOWN;

    MISC_keymap[80] = SDLK_F1;
    MISC_keymap[81] = SDLK_F2;
    MISC_keymap[82] = SDLK_F3;
    MISC_keymap[83] = SDLK_F4;
    MISC_keymap[84] = SDLK_F5;
    MISC_keymap[85] = SDLK_F6;
    MISC_keymap[86] = SDLK_F7;
    MISC_keymap[87] = SDLK_F8;
    MISC_keymap[88] = SDLK_F9;
    MISC_keymap[89] = SDLK_F10;
//      MISC_keymap[XK_F11&0xFF] = SDLK_F11;
//      MISC_keymap[XK_F12&0xFF] = SDLK_F12;
//      MISC_keymap[XK_F13&0xFF] = SDLK_F13;
//      MISC_keymap[XK_F14&0xFF] = SDLK_F14;
//      MISC_keymap[XK_F15&0xFF] = SDLK_F15;

//      MISC_keymap[XK_Num_Lock&0xFF] = SDLK_NUMLOCK;
    MISC_keymap[98] = SDLK_CAPSLOCK;
//      MISC_keymap[XK_Scroll_Lock&0xFF] = SDLK_SCROLLOCK;
    MISC_keymap[97] = SDLK_RSHIFT;
    MISC_keymap[96] = SDLK_LSHIFT;
    MISC_keymap[99] = SDLK_LCTRL;
    MISC_keymap[99] = SDLK_LCTRL;
    MISC_keymap[101] = SDLK_RALT;
    MISC_keymap[100] = SDLK_LALT;
//      MISC_keymap[XK_Meta_R&0xFF] = SDLK_RMETA;
//      MISC_keymap[XK_Meta_L&0xFF] = SDLK_LMETA;
    MISC_keymap[103] = SDLK_LSUPER;     /* Left "Windows" */
    MISC_keymap[102] = SDLK_RSUPER;     /* Right "Windows */

    MISC_keymap[95] = SDLK_HELP;
}

SDL_keysym *
amiga_TranslateKey(int code, SDL_keysym * keysym)
{
#ifdef STORMC4_WOS
    static struct Library *KeymapBase = NULL;   /* Linking failed in WOS version if ConsoleDevice was used */
#else
    static struct Library *ConsoleDevice = NULL;
#endif

    /* Get the raw keyboard scancode */
    keysym->scancode = code;
    keysym->sym = MISC_keymap[code];

#ifdef DEBUG_KEYS
    fprintf(stderr, "Translating key 0x%.4x (%d)\n", xsym, xkey->keycode);
#endif
    /* Get the translated SDL virtual keysym */
    if (keysym->sym == SDLK_UNKNOWN) {
#ifdef STORMC4_WOS
        if (!KeymapBase)
#else
        if (!ConsoleDevice)
#endif
        {
#ifdef STORMC4_WOS
            KeymapBase = OpenLibrary("keymap.library", 0L);
#else
            if (ConPort = CreateMsgPort()) {
                if (ConReq =
                    CreateIORequest(ConPort, sizeof(struct IOStdReq))) {
                    if (!OpenDevice
                        ("console.device", -1,
                         (struct IORequest *) ConReq, 0))
                        ConsoleDevice = (struct Library *) ConReq->io_Device;
                    else {
                        DeleteIORequest(ConReq);
                        ConReq = NULL;
                    }
                } else {
                    DeleteMsgPort(ConPort);
                    ConPort = NULL;
                }
            }
#endif
        }
#ifdef STORMC4_WOS
        if (KeymapBase)
#else
        if (ConsoleDevice)
#endif
        {
            struct InputEvent event;
            long actual;
            char buffer[5];

            event.ie_Qualifier = 0;
            event.ie_Class = IECLASS_RAWKEY;
            event.ie_SubClass = 0L;
            event.ie_Code = code;
            event.ie_X = event.ie_Y = 0;
            event.ie_EventAddress = NULL;
            event.ie_NextEvent = NULL;
            event.ie_Prev1DownCode = event.ie_Prev1DownQual =
                event.ie_Prev2DownCode = event.ie_Prev2DownQual = 0;

#ifdef STORMC4_WOS
            if ((actual = MapRawKey(&event, buffer, 5, NULL)) >= 0)
#else
            if ((actual = RawKeyConvert(&event, buffer, 5, NULL)) >= 0)
#endif
            {
                if (actual > 1) {
                    D(bug("Warning (%ld) character conversion!\n", actual));
                } else if (actual == 1) {
                    keysym->sym = *buffer;
                    D(bug("Converted rawcode %ld to <%lc>\n", code, *buffer));
// Bufferizzo x le successive chiamate!
                    MISC_keymap[code] = *buffer;
                }
            }
        }

    }
    keysym->mod = KMOD_NONE;

    /* If UNICODE is on, get the UNICODE value for the key */
    keysym->unicode = 0;
    if (SDL_TranslateUNICODE) {
#if 0
        static XComposeStatus state;
        /* Until we handle the IM protocol, use XLookupString() */
        unsigned char keybuf[32];
        if (XLookupString(xkey, (char *) keybuf, sizeof(keybuf),
                          NULL, &state)) {
            keysym->unicode = keybuf[0];
        }
#endif
    }
    return (keysym);
}

void
amiga_InitOSKeymap(_THIS)
{
    amiga_InitKeymap();
}

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