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

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 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
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    Sam Lantinga
    slouken@libsdl.org
*/

#ifdef SAVE_RCSID
static char rcsid =
 "@(#) $Id$";
#endif

#ifndef _SDL_BWin_h
#define _SDL_BWin_h

#include <stdio.h>
#include <AppKit.h>
#include <InterfaceKit.h>
#include <be/game/DirectWindow.h>
#ifdef HAVE_OPENGL
#include <be/opengl/GLView.h>
#endif
#include <support/UTF8.h>

#include "SDL_BeApp.h"
#include "SDL_events.h"
#include "SDL_BView.h"

extern "C" {
#include "SDL_events_c.h"
};

class SDL_BWin : public BDirectWindow
{
public:
	SDL_BWin(BRect bounds) :
			BDirectWindow(bounds, "Untitled", B_TITLED_WINDOW, 0) {
		InitKeyboard();
		last_buttons = 0;

		the_view = NULL;
#ifdef HAVE_OPENGL
		SDL_GLView = NULL;
#endif
		SDL_View = NULL;
		Unlock();
		shown = false;
		inhibit_resize = false;
	}

	virtual ~SDL_BWin() {
		Lock();
		if ( the_view ) {
#ifdef HAVE_OPENGL
			if ( the_view == SDL_GLView ) {
				SDL_GLView->UnlockGL();
			}
#endif
			RemoveChild(the_view);
			the_view = NULL;
		}
		Unlock();
#ifdef HAVE_OPENGL
		if ( SDL_GLView ) {
			delete SDL_GLView;
		}
#endif
		if ( SDL_View ) {
			delete SDL_View;
		}
	}
	
	virtual void InitKeyboard(void) {
		for ( uint i=0; i<SDL_TABLESIZE(keymap); ++i )
			keymap[i] = SDLK_UNKNOWN;

		keymap[0x01]		= SDLK_ESCAPE;
		keymap[B_F1_KEY]	= SDLK_F1;
		keymap[B_F2_KEY]	= SDLK_F2;
		keymap[B_F3_KEY]	= SDLK_F3;
		keymap[B_F4_KEY]	= SDLK_F4;
		keymap[B_F5_KEY]	= SDLK_F5;
		keymap[B_F6_KEY]	= SDLK_F6;
		keymap[B_F7_KEY]	= SDLK_F7;
		keymap[B_F8_KEY]	= SDLK_F8;
		keymap[B_F9_KEY]	= SDLK_F9;
		keymap[B_F10_KEY]	= SDLK_F10;
		keymap[B_F11_KEY]	= SDLK_F11;
		keymap[B_F12_KEY]	= SDLK_F12;
		keymap[B_PRINT_KEY]	= SDLK_PRINT;
		keymap[B_SCROLL_KEY]	= SDLK_SCROLLOCK;
		keymap[B_PAUSE_KEY]	= SDLK_PAUSE;
		keymap[0x11]		= SDLK_BACKQUOTE;
		keymap[0x12]		= SDLK_1;
		keymap[0x13]		= SDLK_2;
		keymap[0x14]		= SDLK_3;
		keymap[0x15]		= SDLK_4;
		keymap[0x16]		= SDLK_5;
		keymap[0x17]		= SDLK_6;
		keymap[0x18]		= SDLK_7;
		keymap[0x19]		= SDLK_8;
		keymap[0x1a]		= SDLK_9;
		keymap[0x1b]		= SDLK_0;
		keymap[0x1c]		= SDLK_MINUS;
		keymap[0x1d]		= SDLK_EQUALS;
		keymap[0x1e]		= SDLK_BACKSPACE;
		keymap[0x1f]		= SDLK_INSERT;
		keymap[0x20]		= SDLK_HOME;
		keymap[0x21]		= SDLK_PAGEUP;
		keymap[0x22]		= SDLK_NUMLOCK;
		keymap[0x23]		= SDLK_KP_DIVIDE;
		keymap[0x24]		= SDLK_KP_MULTIPLY;
		keymap[0x25]		= SDLK_KP_MINUS;
		keymap[0x26]		= SDLK_TAB;
		keymap[0x27]		= SDLK_q;
		keymap[0x28]		= SDLK_w;
		keymap[0x29]		= SDLK_e;
		keymap[0x2a]		= SDLK_r;
		keymap[0x2b]		= SDLK_t;
		keymap[0x2c]		= SDLK_y;
		keymap[0x2d]		= SDLK_u;
		keymap[0x2e]		= SDLK_i;
		keymap[0x2f]		= SDLK_o;
		keymap[0x30]		= SDLK_p;
		keymap[0x31]		= SDLK_LEFTBRACKET;
		keymap[0x32]		= SDLK_RIGHTBRACKET;
		keymap[0x33]		= SDLK_BACKSLASH;
		keymap[0x34]		= SDLK_DELETE;
		keymap[0x35]		= SDLK_END;
		keymap[0x36]		= SDLK_PAGEDOWN;
		keymap[0x37]		= SDLK_KP7;
		keymap[0x38]		= SDLK_KP8;
		keymap[0x39]		= SDLK_KP9;
		keymap[0x3a]		= SDLK_KP_PLUS;
		keymap[0x3b]		= SDLK_CAPSLOCK;
		keymap[0x3c]		= SDLK_a;
		keymap[0x3d]		= SDLK_s;
		keymap[0x3e]		= SDLK_d;
		keymap[0x3f]		= SDLK_f;
		keymap[0x40]		= SDLK_g;
		keymap[0x41]		= SDLK_h;
		keymap[0x42]		= SDLK_j;
		keymap[0x43]		= SDLK_k;
		keymap[0x44]		= SDLK_l;
		keymap[0x45]		= SDLK_SEMICOLON;
		keymap[0x46]		= SDLK_QUOTE;
		keymap[0x47]		= SDLK_RETURN;
		keymap[0x48]		= SDLK_KP4;
		keymap[0x49]		= SDLK_KP5;
		keymap[0x4a]		= SDLK_KP6;
		keymap[0x4b]		= SDLK_LSHIFT;
		keymap[0x4c]		= SDLK_z;
		keymap[0x4d]		= SDLK_x;
		keymap[0x4e]		= SDLK_c;
		keymap[0x4f]		= SDLK_v;
		keymap[0x50]		= SDLK_b;
		keymap[0x51]		= SDLK_n;
		keymap[0x52]		= SDLK_m;
		keymap[0x53]		= SDLK_COMMA;
		keymap[0x54]		= SDLK_PERIOD;
		keymap[0x55]		= SDLK_SLASH;
		keymap[0x56]		= SDLK_RSHIFT;
		keymap[0x57]		= SDLK_UP;
		keymap[0x58]		= SDLK_KP1;
		keymap[0x59]		= SDLK_KP2;
		keymap[0x5a]		= SDLK_KP3;
		keymap[0x5b]		= SDLK_KP_ENTER;
		keymap[0x5c]		= SDLK_LCTRL;
		keymap[0x5d]		= SDLK_LALT;
		keymap[0x5e]		= SDLK_SPACE;
		keymap[0x5f]		= SDLK_RALT;
		keymap[0x60]		= SDLK_RCTRL;
		keymap[0x61]		= SDLK_LEFT;
		keymap[0x62]		= SDLK_DOWN;
		keymap[0x63]		= SDLK_RIGHT;
		keymap[0x64]		= SDLK_KP0;
		keymap[0x65]		= SDLK_KP_PERIOD;
		keymap[0x66]		= SDLK_LMETA;
		keymap[0x67]		= SDLK_RMETA;
		keymap[0x68]		= SDLK_MENU;
		keymap[0x69]		= SDLK_EURO;
		keymap[0x6a]		= SDLK_KP_EQUALS;
		keymap[0x6b]		= SDLK_POWER;
	}

	/* Override the Show() method so we can tell when we've been shown */
	virtual void Show(void) {
		BWindow::Show();
		shown = true;
	}
	virtual bool Shown(void) {
		return (shown);
	}
	/* If called, the next resize event will not be forwarded to SDL. */
	virtual void InhibitResize(void) {
		inhibit_resize=true;
	}
	/* Handle resizing of the window */
	virtual void FrameResized(float width, float height) {
		if(inhibit_resize)
			inhibit_resize = false;
		else 
			SDL_PrivateResize((int)width, (int)height);
	}
	virtual int CreateView(Uint32 flags, Uint32 gl_flags) {
		int retval;

		retval = 0;
		Lock();
		if ( flags & SDL_OPENGL ) {
#ifdef HAVE_OPENGL
			if ( SDL_GLView == NULL ) {
				SDL_GLView = new BGLView(Bounds(), "SDL GLView",
					 	B_FOLLOW_ALL_SIDES, (B_WILL_DRAW|B_FRAME_EVENTS),
					 	gl_flags);
			}
			if ( the_view != SDL_GLView ) {
				if ( the_view ) {
					RemoveChild(the_view);
				}
				AddChild(SDL_GLView);
				SDL_GLView->LockGL();
				the_view = SDL_GLView;
			}
#else
			SDL_SetError("OpenGL support not enabled");
			retval = -1;
#endif
		} else {
			if ( SDL_View == NULL ) {
				SDL_View = new SDL_BView(Bounds());
			}
			if ( the_view != SDL_View ) {
				if ( the_view ) {
#ifdef HAVE_OPENGL
					if ( the_view == SDL_GLView ) {
						SDL_GLView->UnlockGL();
					}
#endif
					RemoveChild(the_view);
				}
				AddChild(SDL_View);
				the_view = SDL_View;
			}
		}
		Unlock();
		return(retval);
	}
	virtual void SetBitmap(BBitmap *bitmap) {
		SDL_View->SetBitmap(bitmap);
	}
	virtual void SetXYOffset(int x, int y) {
#ifdef HAVE_OPENGL
		if ( the_view == SDL_GLView ) {
			return;
		}
#endif
		SDL_View->SetXYOffset(x, y);		
	}
	virtual void GetXYOffset(int &x, int &y) {
#ifdef HAVE_OPENGL
		if ( the_view == SDL_GLView ) {
			x = 0;
			y = 0;
			return;
		}
#endif
		SDL_View->GetXYOffset(x, y);
	}
	virtual bool BeginDraw(void) {
		return(Lock());
	}
	virtual void DrawAsync(BRect updateRect) {
		SDL_View->DrawAsync(updateRect);
	}
	virtual void EndDraw(void) {
		SDL_View->Sync();
		Unlock();
	}
#ifdef HAVE_OPENGL
	virtual void SwapBuffers(void) {
		SDL_GLView->UnlockGL();
		SDL_GLView->LockGL();
		SDL_GLView->SwapBuffers();
	}
#endif
	virtual BView *View(void) {
		return(the_view);
	}

	/* Hook functions -- overridden */
	virtual void Minimize(bool minimize) {
		/* This is only called when mimimized, not when restored */
		//SDL_PrivateAppActive(minimize, SDL_APPACTIVE);
		BWindow::Minimize(minimize);
	}
	virtual void WindowActivated(bool active) {
		SDL_PrivateAppActive(active, SDL_APPINPUTFOCUS);
	}
	virtual bool QuitRequested(void) {
		if ( SDL_BeAppActive > 0 ) {
			SDL_PrivateQuit();
			/* We don't ever actually close the window here because
			   the application should respond to the quit request,
			   or ignore it as desired.
			 */
			return(false);
		}
		return(true);	/* Close the app window */
	}
	virtual void Quit() {
		if (!IsLocked())
			Lock();
		BDirectWindow::Quit();
	}

	virtual int16 Translate2Unicode(const char *buf) {
		int32 state, srclen, dstlen;
		unsigned char destbuf[2];
		Uint16 unicode = 0;

		if ((uchar)buf[0] > 127) {
			state = 0;
			srclen = strlen(buf);
			dstlen = sizeof(destbuf);
			convert_from_utf8(B_UNICODE_CONVERSION, buf, &srclen, (char *)destbuf, &dstlen, &state);
			unicode = destbuf[0];
			unicode <<= 8;
			unicode |= destbuf[1];
		} else
			unicode = buf[0];

		/* For some reason function keys map to control characters */
# define CTRL(X)	((X)-'@')
		switch (unicode) {
		    case CTRL('A'):
		    case CTRL('B'):
		    case CTRL('C'):
		    case CTRL('D'):
		    case CTRL('E'):
		    case CTRL('K'):
		    case CTRL('L'):
		    case CTRL('P'):
			if ( ! (SDL_GetModState() & KMOD_CTRL) )
				unicode = 0;
			break;
			/* Keyboard input maps newline to carriage return */
			case '\n':
				unicode = '\r';
			break;
		    default:
			break;
		}

		return unicode;
	}

	virtual void DispatchMessage(BMessage *msg, BHandler *target) {
		switch (msg->what) {
			case B_MOUSE_MOVED:
			{
				BPoint where;
				int32 transit;
				if (msg->FindPoint("where", &where) == B_OK && msg->FindInt32("be:transit", &transit) == B_OK) {
					if (transit == B_EXITED_VIEW) {
						if ( SDL_GetAppState() & SDL_APPMOUSEFOCUS ) {
							SDL_PrivateAppActive(0, SDL_APPMOUSEFOCUS);
							be_app->SetCursor(B_HAND_CURSOR);
						}
					} else {
						int x, y;
						if ( ! (SDL_GetAppState() & SDL_APPMOUSEFOCUS) ) {
							SDL_PrivateAppActive(1, SDL_APPMOUSEFOCUS);
							SDL_SetCursor(NULL);
						}
						GetXYOffset(x, y);
						x = (int)where.x - x;
						y = (int)where.y - y;
						SDL_PrivateMouseMotion(0, 0, x, y);
					}
				}
				break;
			}

			case B_MOUSE_DOWN:
			{
				/*	it looks like mouse down is send only for first clicked
					button, each next is not send while last one is holded */
				int32 buttons;
				int sdl_buttons = 0;
				if (msg->FindInt32("buttons", &buttons) == B_OK) {
					/* Add any mouse button events */
					if (buttons & B_PRIMARY_MOUSE_BUTTON) {
						sdl_buttons |= SDL_BUTTON_LEFT;
					}
					if (buttons & B_SECONDARY_MOUSE_BUTTON) {
						sdl_buttons |= SDL_BUTTON_RIGHT;
					}
					if (buttons & B_TERTIARY_MOUSE_BUTTON) {
						sdl_buttons |= SDL_BUTTON_MIDDLE;
					}
					SDL_PrivateMouseButton(SDL_PRESSED, sdl_buttons, 0, 0);

					last_buttons = buttons;
				}
				break;
			}

			case B_MOUSE_UP:
			{
				/*	mouse up doesn't give which button was released,
					only state of buttons (after release, so it's always = 0),
					which is is not what we need ;]
					So we need to store button in mouse down, and restore
					in mouse up :(
					mouse up is (similarly to mouse down) send only when
					no more buttons are down */
				int32 buttons;
				int sdl_buttons = 0;
				if (msg->FindInt32("buttons", &buttons) == B_OK) {
					/* Add any mouse button events */
					if ((buttons ^ B_PRIMARY_MOUSE_BUTTON) & last_buttons) {
						sdl_buttons |= SDL_BUTTON_LEFT;
					}
					if ((buttons ^ B_SECONDARY_MOUSE_BUTTON) & last_buttons) {
						sdl_buttons |= SDL_BUTTON_RIGHT;
					}
					if ((buttons ^ B_TERTIARY_MOUSE_BUTTON) & last_buttons) {
						sdl_buttons |= SDL_BUTTON_MIDDLE;
					}
					SDL_PrivateMouseButton(SDL_RELEASED, sdl_buttons, 0, 0);

					last_buttons = buttons;
				}
				break;
			}

			case B_MOUSE_WHEEL_CHANGED:
			{
				float x, y;
				x = y = 0;
				if (msg->FindFloat("be:wheel_delta_x", &x) == B_OK && msg->FindFloat("be:wheel_delta_y", &y) == B_OK) {
					if (x < 0 || y < 0) {
						SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_WHEELDOWN, 0, 0);
						SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_WHEELDOWN, 0, 0);
					} else if (x > 0 || y > 0) {
						SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_WHEELUP, 0, 0);
						SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_WHEELUP, 0, 0);
					}
				}
				break;
			}

			case B_KEY_DOWN:
			case B_UNMAPPED_KEY_DOWN: /* modifier keys are unmapped */
			{
				int32 key;
				int32 modifiers;
				if (msg->FindInt32("key", &key) == B_OK && msg->FindInt32("modifiers", &modifiers) == B_OK) {
					SDL_keysym keysym;
					keysym.scancode = key;
					if (key < 128) {
						keysym.sym = keymap[key];
					} else {
						keysym.sym = SDLK_UNKNOWN;
					}
					/*	FIX THIS?
						it seems SDL_PrivateKeyboard() changes mod value
						anyway, and doesn't care about what we setup here */
					keysym.mod = KMOD_NONE;
					keysym.unicode = 0;
					if (SDL_TranslateUNICODE) {
						const char *bytes;
						if (msg->FindString("bytes", &bytes) == B_OK) {
							/*	FIX THIS?
								this cares only about first "letter",
								so if someone maps some key to print
								"BeOS rulez!" only "B" will be used. */
							keysym.unicode = Translate2Unicode(bytes);
						}
					}
					SDL_PrivateKeyboard(SDL_PRESSED, &keysym);
				}
				break;
			}

			case B_KEY_UP:
			case B_UNMAPPED_KEY_UP: /* modifier keys are unmapped */
			{
				int32 key;
				int32 modifiers;
				if (msg->FindInt32("key", &key) == B_OK && msg->FindInt32("modifiers", &modifiers) == B_OK) {
					SDL_keysym keysym;
					keysym.scancode = key;
					if (key < 128) {
						keysym.sym = keymap[key];
					} else {
						keysym.sym = SDLK_UNKNOWN;
					}
					keysym.mod = KMOD_NONE; /* FIX THIS? */
					keysym.unicode = 0;
					if (SDL_TranslateUNICODE) {
						const char *bytes;
						if (msg->FindString("bytes", &bytes) == B_OK) {
							keysym.unicode = Translate2Unicode(bytes);
						}
					}
					SDL_PrivateKeyboard(SDL_RELEASED, &keysym);
				}
				break;
			}

			default:
				/* move it after switch{} so it's always handled
					that way we keep BeOS feautures like:
					- CTRL+Q to close window (and other shortcuts)
					- PrintScreen to make screenshot into /boot/home
					- etc.. */
				//BDirectWindow::DispatchMessage(msg, target);
				break;
		}
		BDirectWindow::DispatchMessage(msg, target);
	}

private:
#ifdef HAVE_OPENGL
	BGLView *SDL_GLView;
#endif
	SDL_BView *SDL_View;
	BView *the_view;

	bool shown;
	bool inhibit_resize;

	int32 last_buttons;
	SDLKey keymap[128];
};

#endif /* _SDL_BWin_h */