/*
    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 photon events into SDL events */

#include <stdio.h>
#include <setjmp.h>
#include <sys/time.h>

#include <Ph.h>
#include <photon/PkKeyDef.h>

#include "SDL.h"
#include "SDL_syswm.h"
#include "../SDL_sysvideo.h"
#include "../../events/SDL_sysevents.h"
#include "../../events/SDL_events_c.h"
#include "SDL_ph_video.h"
#include "SDL_ph_modes_c.h"
#include "SDL_ph_image_c.h"
#include "SDL_ph_events_c.h"
#include "SDL_phyuv_c.h"

/* The translation tables from a photon keysym to a SDL keysym */
static SDLKey ODD_keymap[256];
static SDLKey MISC_keymap[0xFF + 1];
SDL_keysym *ph_TranslateKey(PhKeyEvent_t *key, SDL_keysym *keysym);

/* Check to see if this is a repeated key.
   (idea shamelessly lifted from GII -- thanks guys! :) */
static int ph_WarpedMotion(_THIS, PhEvent_t *winEvent)
{
    PhRect_t *rect = PhGetRects( winEvent );

    int centre_x, centre_y;
    int dx, dy;
    short abs_x, abs_y;
    int posted;

    centre_x = SDL_VideoSurface->w / 2;
    centre_y = SDL_VideoSurface->h / 2;

    dx = rect->ul.x - centre_x;
    dy = rect->ul.y - centre_y;

    posted = SDL_PrivateMouseMotion( 0, 1, dx, dy );

    /* Move mouse cursor to middle of the window */
    PtGetAbsPosition( window, &abs_x, &abs_y );
    PhMoveCursorAbs(PhInputGroup(NULL), abs_x + centre_x, abs_y + centre_y);

    return (posted);
}

/* Control which motion flags the window has set, a flags value of -1 sets
 * MOTION_BUTTON and MOTION_NOBUTTON */

static void set_motion_sensitivity(_THIS, unsigned int flags)
{
    int rid;
    int fields = Ph_EV_PTR_MOTION_BUTTON | Ph_EV_PTR_MOTION_NOBUTTON;
    PhRegion_t region;

    if( window )
    {
        rid = PtWidgetRid(window);
        if( rid != 0 && PhRegionQuery(rid, &region, NULL, NULL, 0) == 0 )
        {
            region.events_sense=(region.events_sense & ~fields)|(flags & fields);
            PhRegionChange(Ph_REGION_EV_SENSE, 0, &region, NULL, NULL);
        }
    }
}

/* Convert the photon button state value to an SDL value */
static Uint8 ph2sdl_mousebutton(unsigned short button_state)
{
    Uint8 mouse_button = 0;

    if (button_state & Ph_BUTTON_SELECT)
        mouse_button |= SDL_BUTTON_LEFT;
    if (button_state & Ph_BUTTON_MENU)
        mouse_button |= SDL_BUTTON_RIGHT;
    if (button_state & Ph_BUTTON_ADJUST)
        mouse_button |= SDL_BUTTON_MIDDLE;

    return (mouse_button);
}

static int ph_DispatchEvent(_THIS)
{
    int posted;
    PhRect_t* rect;
    PhPointerEvent_t* pointerEvent;
    PhKeyEvent_t* keyEvent;
    PhWindowEvent_t* winEvent;
    int i, buttons;
    SDL_Rect sdlrects[PH_SDL_MAX_RECTS];
	
    posted = 0;
	
    switch (event->type)
    {
        case Ph_EV_BOUNDARY:
        {
            if (event->subtype == Ph_EV_PTR_ENTER)
            {
                posted = SDL_PrivateAppActive(1, SDL_APPMOUSEFOCUS);
            }
            else if (event->subtype ==Ph_EV_PTR_LEAVE)
            {
                posted = SDL_PrivateAppActive(0, SDL_APPMOUSEFOCUS);	
            }
        }
        break;

        case Ph_EV_PTR_MOTION_BUTTON:
        case Ph_EV_PTR_MOTION_NOBUTTON:
        {
            if (SDL_VideoSurface)
            {
                pointerEvent = PhGetData(event);
                rect = PhGetRects(event);

                if (mouse_relative)
                {
                    posted = ph_WarpedMotion(this, event);
                }
                else
                {
                    posted = SDL_PrivateMouseMotion(0, 0, rect->ul.x, rect->ul.y);
                }
            }
        }
        break;

        case Ph_EV_BUT_PRESS:
        {
            pointerEvent = PhGetData( event );
            buttons = ph2sdl_mousebutton( pointerEvent->buttons );
            if (buttons != 0)
            {
                posted = SDL_PrivateMouseButton(SDL_PRESSED, buttons, 0, 0);
            }
        }
        break;

        case Ph_EV_BUT_RELEASE:
        {
            pointerEvent = PhGetData(event);
            buttons = ph2sdl_mousebutton(pointerEvent->buttons);
            if (event->subtype == Ph_EV_RELEASE_REAL && buttons != 0)
            {
                posted = SDL_PrivateMouseButton(SDL_RELEASED, buttons, 0, 0);
            }
            else if(event->subtype == Ph_EV_RELEASE_PHANTOM)
            {
                /* If the mouse is outside the window,
                 * only a phantom release event is sent, so
                 * check if the window doesn't have mouse focus.
                 * Not perfect, maybe checking the mouse button
                 * state for Ph_EV_BOUNDARY events would be
                 * better. */
                if ((SDL_GetAppState() & SDL_APPMOUSEFOCUS) == 0)
		{
                    posted = SDL_PrivateMouseButton(SDL_RELEASED, buttons, 0, 0);
                }
            }
        }
        break;

        case Ph_EV_WM:
        {
            winEvent = PhGetData(event);

            /* losing focus */
            if ((winEvent->event_f==Ph_WM_FOCUS) && (winEvent->event_state==Ph_WM_EVSTATE_FOCUSLOST))
            {
                set_motion_sensitivity(this, Ph_EV_PTR_MOTION_BUTTON);
                posted = SDL_PrivateAppActive(0, SDL_APPINPUTFOCUS);	
            }
            /* gaining focus */
            else if ((winEvent->event_f==Ph_WM_FOCUS) && (winEvent->event_state==Ph_WM_EVSTATE_FOCUS))
            {
                set_motion_sensitivity(this, -1);
                posted = SDL_PrivateAppActive(1, SDL_APPINPUTFOCUS);
            }
            /* request quit */
            else if (winEvent->event_f==Ph_WM_CLOSE)
            {
                posted = SDL_PrivateQuit();
            }
            /* request hide/unhide */
            else if (winEvent->event_f==Ph_WM_HIDE)
            {
                if (currently_hided)
                {
                   /* got unhide window event                                */
                   /* TODO: restore application's palette if in palette mode */
                   currently_hided=0;
                }
                else
                {
                   /* got hide window event                                  */
                   /* TODO: restore original palette if in palette mode      */
                   currently_hided=1;
                }
            }
            /* request to resize */
            else if (winEvent->event_f==Ph_WM_RESIZE)
            {
                currently_maximized=0;
                #if (_NTO_VERSION < 630)
                   SDL_PrivateResize(winEvent->size.w+1, winEvent->size.h+1);
                #else
                   /* QNX 6.3.0 have this bug fixed */
                   SDL_PrivateResize(winEvent->size.w, winEvent->size.h);
                #endif /* _NTO_VERSION */
            }
            /* request to move */
            else if (winEvent->event_f==Ph_WM_MOVE)
            {
                if (current_overlay!=NULL)
                {
                   int lockedstate=current_overlay->hwdata->locked;
                   int chromastate=current_overlay->hwdata->ischromakey;
                   int error;
                   SDL_Rect target;

                   current_overlay->hwdata->locked=1;
                   target.x=current_overlay->hwdata->CurrentViewPort.pos.x;
                   target.y=current_overlay->hwdata->CurrentViewPort.pos.y;
                   target.w=current_overlay->hwdata->CurrentViewPort.size.w;
                   target.h=current_overlay->hwdata->CurrentViewPort.size.h;
                   current_overlay->hwdata->ischromakey=0;
                   error=ph_DisplayYUVOverlay(this, current_overlay, &target);
                   if (!error)
                   {
                       current_overlay->hwdata->ischromakey=chromastate;
                       current_overlay->hwdata->locked=lockedstate;
                   }
                }
            }
            /* maximize request */
            else if (winEvent->event_f==Ph_WM_MAX)
            {
                /* window already moved and resized here */
                currently_maximized=1;
            }
            /* restore request */
            else if (winEvent->event_f==Ph_WM_RESTORE)
            {
                /* window already moved and resized here */
                currently_maximized=0;
            }
        }
        break;

        /* window has been resized, moved or removed */
        case Ph_EV_EXPOSE:
        {
            if (event->num_rects!=0)
            {
                int numrects;

                if (SDL_VideoSurface)
                {
                    rect = PhGetRects(event);
                    if (event->num_rects>PH_SDL_MAX_RECTS)
                    {
                       /* sorry, buffers underrun, we'll update only first PH_SDL_MAX_RECTS rects */
                       numrects=PH_SDL_MAX_RECTS;
                    }

                    for(i=0; i<event->num_rects; i++)
                    {
                        sdlrects[i].x = rect[i].ul.x;
                        sdlrects[i].y = rect[i].ul.y;
                        sdlrects[i].w = rect[i].lr.x - rect[i].ul.x + 1;
                        sdlrects[i].h = rect[i].lr.y - rect[i].ul.y + 1;
                    }

                    this->UpdateRects(this, event->num_rects, sdlrects);

                    if (current_overlay!=NULL)
                    {
                        int lockedstate=current_overlay->hwdata->locked;
                        int error;
                        SDL_Rect target;

                        current_overlay->hwdata->locked=1;
                        target.x=current_overlay->hwdata->CurrentViewPort.pos.x;
                        target.y=current_overlay->hwdata->CurrentViewPort.pos.y;
                        target.w=current_overlay->hwdata->CurrentViewPort.size.w;
                        target.h=current_overlay->hwdata->CurrentViewPort.size.h;
                        current_overlay->hwdata->forcedredraw=1;
                        error=ph_DisplayYUVOverlay(this, current_overlay, &target);
                        if (!error)
                        {
                            current_overlay->hwdata->forcedredraw=0;
                            current_overlay->hwdata->locked=lockedstate;
                        }
                    }
                }
            }
        }
	break;

        case Ph_EV_KEY:
        {
            SDL_keysym keysym;

            posted = 0;

            keyEvent = PhGetData( event );

            if (Pk_KF_Key_Down & keyEvent->key_flags)
            {
                /* split the wheel events from real key events */
                if ((keyEvent->key_cap==Pk_Up) && (keyEvent->key_scan==0) && ((keyEvent->key_flags & Pk_KF_Scan_Valid)==Pk_KF_Scan_Valid))
                {
                   posted = SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_WHEELUP, 0, 0);
                   break;
                }
                if ((keyEvent->key_cap==Pk_Down) && (keyEvent->key_scan==0) && ((keyEvent->key_flags & Pk_KF_Scan_Valid)==Pk_KF_Scan_Valid))
                {
                   posted = SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_WHEELDOWN, 0, 0);
                   break;
                }
                posted = SDL_PrivateKeyboard(SDL_PRESSED, ph_TranslateKey(keyEvent, &keysym));
            }
            else /* must be key release */
            {
                /* split the wheel events from real key events */
                if ((keyEvent->key_cap==Pk_Up) && (keyEvent->key_scan==0) && ((keyEvent->key_flags & Pk_KF_Scan_Valid)==Pk_KF_Scan_Valid))
                {
                   posted = SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_WHEELUP, 0, 0);
                   break;
                }
                if ((keyEvent->key_cap==Pk_Down) && (keyEvent->key_scan==0) && ((keyEvent->key_flags & Pk_KF_Scan_Valid)==Pk_KF_Scan_Valid))
                {
                   posted = SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_WHEELDOWN, 0, 0);
                   break;
                }
                posted = SDL_PrivateKeyboard(SDL_RELEASED, ph_TranslateKey( keyEvent, &keysym));
            }
        }
        break;
        
        case Ph_EV_INFO:
        {
           if (event->subtype==Ph_OFFSCREEN_INVALID)
           {
              unsigned long* EvInfoData;

              EvInfoData=(unsigned long*)PhGetData(event);

              switch (*EvInfoData)
              {
                 case Pg_VIDEO_MODE_SWITCHED:
                      {
                      }
                      break;
                 case Pg_ENTERED_DIRECT:
                      {
                      }
                      break;
                 case Pg_EXITED_DIRECT:
                      {
                      }
                      break;
                 case Pg_DRIVER_STARTED:
                      {
                      }
                      break;
              }
           }
        }
        break;
    }

    return(posted);
}

/* perform a blocking read if no events available */
int ph_Pending(_THIS)
{
    /* Flush the display connection and look to see if events are queued */
    PgFlush();

    while (1)
    {
        switch(PhEventPeek(event, EVENT_SIZE))
        {
            case Ph_EVENT_MSG:
                 return 1;
            case -1:
                 SDL_SetError("ph_Pending(): PhEventNext failed.\n");
                 return 0;
            default:
                 return 0;
        }
    }

    /* Oh well, nothing is ready .. */
    return(0);
}

void ph_PumpEvents(_THIS)
{
    /* Flush the display connection and look to see if events are queued */
    PgFlush();

    while (ph_Pending(this))
    {
        PtEventHandler(event);
        ph_DispatchEvent(this);
    }
}

void ph_InitKeymap(void)
{
    int i;

    /* Odd keys used in international keyboards */
    for (i=0; i<SDL_arraysize(ODD_keymap); ++i)
    {
        ODD_keymap[i] = SDLK_UNKNOWN;
    }

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

    MISC_keymap[Pk_BackSpace&0xFF] = SDLK_BACKSPACE;
    MISC_keymap[Pk_Tab&0xFF] = SDLK_TAB;
    MISC_keymap[Pk_Clear&0xFF] = SDLK_CLEAR;
    MISC_keymap[Pk_Return&0xFF] = SDLK_RETURN;
    MISC_keymap[Pk_Pause&0xFF] = SDLK_PAUSE;
    MISC_keymap[Pk_Escape&0xFF] = SDLK_ESCAPE;
    MISC_keymap[Pk_Delete&0xFF] = SDLK_DELETE;

    MISC_keymap[Pk_KP_0&0xFF] = SDLK_KP0;
    MISC_keymap[Pk_KP_1&0xFF] = SDLK_KP1;
    MISC_keymap[Pk_KP_2&0xFF] = SDLK_KP2;
    MISC_keymap[Pk_KP_3&0xFF] = SDLK_KP3;
    MISC_keymap[Pk_KP_4&0xFF] = SDLK_KP4;
    MISC_keymap[Pk_KP_5&0xFF] = SDLK_KP5;
    MISC_keymap[Pk_KP_6&0xFF] = SDLK_KP6;
    MISC_keymap[Pk_KP_7&0xFF] = SDLK_KP7;
    MISC_keymap[Pk_KP_8&0xFF] = SDLK_KP8;
    MISC_keymap[Pk_KP_9&0xFF] = SDLK_KP9;

    MISC_keymap[Pk_KP_Decimal&0xFF] = SDLK_KP_PERIOD;
    MISC_keymap[Pk_KP_Divide&0xFF] = SDLK_KP_DIVIDE;
    MISC_keymap[Pk_KP_Multiply&0xFF] = SDLK_KP_MULTIPLY;
    MISC_keymap[Pk_KP_Subtract&0xFF] = SDLK_KP_MINUS;
    MISC_keymap[Pk_KP_Add&0xFF] = SDLK_KP_PLUS;
    MISC_keymap[Pk_KP_Enter&0xFF] = SDLK_KP_ENTER;
    MISC_keymap[Pk_KP_Equal&0xFF] = SDLK_KP_EQUALS;

    MISC_keymap[Pk_Up&0xFF] = SDLK_UP;
    MISC_keymap[Pk_Down&0xFF] = SDLK_DOWN;
    MISC_keymap[Pk_Right&0xFF] = SDLK_RIGHT;
    MISC_keymap[Pk_Left&0xFF] = SDLK_LEFT;
    MISC_keymap[Pk_Insert&0xFF] = SDLK_INSERT;
    MISC_keymap[Pk_Home&0xFF] = SDLK_HOME;
    MISC_keymap[Pk_End&0xFF] = SDLK_END;
    MISC_keymap[Pk_Pg_Up&0xFF] = SDLK_PAGEUP;
    MISC_keymap[Pk_Pg_Down&0xFF] = SDLK_PAGEDOWN;

    MISC_keymap[Pk_F1&0xFF] = SDLK_F1;
    MISC_keymap[Pk_F2&0xFF] = SDLK_F2;
    MISC_keymap[Pk_F3&0xFF] = SDLK_F3;
    MISC_keymap[Pk_F4&0xFF] = SDLK_F4;
    MISC_keymap[Pk_F5&0xFF] = SDLK_F5;
    MISC_keymap[Pk_F6&0xFF] = SDLK_F6;
    MISC_keymap[Pk_F7&0xFF] = SDLK_F7;
    MISC_keymap[Pk_F8&0xFF] = SDLK_F8;
    MISC_keymap[Pk_F9&0xFF] = SDLK_F9;
    MISC_keymap[Pk_F10&0xFF] = SDLK_F10;
    MISC_keymap[Pk_F11&0xFF] = SDLK_F11;
    MISC_keymap[Pk_F12&0xFF] = SDLK_F12;
    MISC_keymap[Pk_F13&0xFF] = SDLK_F13;
    MISC_keymap[Pk_F14&0xFF] = SDLK_F14;
    MISC_keymap[Pk_F15&0xFF] = SDLK_F15;

    MISC_keymap[Pk_Num_Lock&0xFF] = SDLK_NUMLOCK;
    MISC_keymap[Pk_Caps_Lock&0xFF] = SDLK_CAPSLOCK;
    MISC_keymap[Pk_Scroll_Lock&0xFF] = SDLK_SCROLLOCK;
    MISC_keymap[Pk_Shift_R&0xFF] = SDLK_RSHIFT;
    MISC_keymap[Pk_Shift_L&0xFF] = SDLK_LSHIFT;
    MISC_keymap[Pk_Control_R&0xFF] = SDLK_RCTRL;
    MISC_keymap[Pk_Control_L&0xFF] = SDLK_LCTRL;
    MISC_keymap[Pk_Alt_R&0xFF] = SDLK_RALT;
    MISC_keymap[Pk_Alt_L&0xFF] = SDLK_LALT;
    MISC_keymap[Pk_Meta_R&0xFF] = SDLK_RMETA;
    MISC_keymap[Pk_Meta_L&0xFF] = SDLK_LMETA;
    MISC_keymap[Pk_Super_L&0xFF] = SDLK_LSUPER;
    MISC_keymap[Pk_Super_R&0xFF] = SDLK_RSUPER;
    MISC_keymap[Pk_Mode_switch&0xFF] = SDLK_MODE; /* "Alt Gr" key    */

    MISC_keymap[Pk_Help&0xFF] = SDLK_HELP;
    MISC_keymap[Pk_Print&0xFF] = SDLK_PRINT;
    MISC_keymap[Pk_Break&0xFF] = SDLK_BREAK;
    MISC_keymap[Pk_Menu&0xFF] = SDLK_MENU;        /* Windows "Menu" key */

    MISC_keymap[Pk_Hyper_R&0xFF] = SDLK_RSUPER;   /* Right "Windows" */

    /* Left "Windows" key, but it can't be catched by application */
    MISC_keymap[Pk_Hyper_L&0xFF] = SDLK_LSUPER;
}

static unsigned long cap;

SDL_keysym *ph_TranslateKey(PhKeyEvent_t *key, SDL_keysym *keysym)
{
    /* 'sym' is set to the value of the key with modifiers applied to it.
       This member is valid only if Pk_KF_Sym_Valid is set in the key_flags.
       We will assume it is valid. */

    /* FIXME: This needs to check whether the cap & scancode is valid */

    cap = key->key_cap;

    switch (cap>>8)
    {
        case 0x00:  /* Latin 1 */
        case 0x01:  /* Latin 2 */
        case 0x02:  /* Latin 3 */
        case 0x03:  /* Latin 4 */
        case 0x04:  /* Katakana */
        case 0x05:  /* Arabic */
        case 0x06:  /* Cyrillic */
        case 0x07:  /* Greek */
        case 0x08:  /* Technical */
        case 0x0A:  /* Publishing */
        case 0x0C:  /* Hebrew */
        case 0x0D:  /* Thai */
                   keysym->sym = (SDLKey)(cap&0xFF);
                   /* Map capital letter syms to lowercase */
                   if ((keysym->sym >= 'A')&&(keysym->sym <= 'Z'))
                       keysym->sym += ('a'-'A');
                   break;
        case 0xF0:
                   keysym->sym = MISC_keymap[cap&0xFF];
                   break;
        default:
                   keysym->sym = SDLK_UNKNOWN;                
                   break;
    }

    keysym->scancode = key->key_scan;
    keysym->unicode = 0;

    if (SDL_TranslateUNICODE)
    {
        char utf8[MB_CUR_MAX];
        int utf8len;
        wchar_t unicode;

        switch (keysym->scancode)
        {
           /* Esc key */
           case 0x01: keysym->unicode = 27;
                      break;
           /* BackSpace key */
           case 0x0E: keysym->unicode = 127;
                      break;
           /* Enter key */
           case 0x1C: keysym->unicode = 10;
                      break;
           default:
                      utf8len = PhKeyToMb(utf8, key);
                      if (utf8len > 0)
                      {
                         utf8len = mbtowc(&unicode, utf8, utf8len);
                         if (utf8len > 0)
                         {
                             keysym->unicode = unicode;
                         }
                      }
                      break;
        }

    }

    return (keysym);
}

void ph_InitOSKeymap(_THIS)
{
    ph_InitKeymap();
}