#include "reflex/ruby/event.h"


#include "defs.h"


RUCY_DEFINE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::KeyEvent)

#define THIS  to<Reflex::KeyEvent*>(self)

#define CHECK RUCY_CHECK_OBJ(Reflex::KeyEvent, self)


static
VALUE alloc(VALUE klass)
{
	return new_type<Reflex::KeyEvent>(klass);
}

static
VALUE initialize(VALUE self, VALUE action, VALUE chars, VALUE code, VALUE modifiers, VALUE repeat)
{
	CHECK;

	*THIS = Reflex::KeyEvent(
		(Reflex::KeyEvent::Action) to<uint>(action),
		chars.c_str(),
		to<int>(code),
		to<uint>(modifiers),
		to<int>(repeat));

	return rb_call_super(0, NULL);
}

static
VALUE initialize_copy(VALUE self, VALUE obj)
{
	CHECK;
	*THIS = to<Reflex::KeyEvent&>(obj).dup();
	return self;
}

static
VALUE get_action(VALUE self)
{
	CHECK;
	return value(THIS->action());
}

static
VALUE get_key(VALUE self)
{
	CHECK;
	switch (THIS->code())
	{
		#define CASE(key)         case Reflex::KEY_##key
		#define SYMBOL1(name)     SYMBOL2(_##name, #name)
		#define SYMBOL2(var, sym) {RUCY_SYMBOL(var, sym); return var.value();}

		CASE(A): SYMBOL1(a);
		CASE(B): SYMBOL1(b);
		CASE(C): SYMBOL1(c);
		CASE(D): SYMBOL1(d);
		CASE(E): SYMBOL1(e);
		CASE(F): SYMBOL1(f);
		CASE(G): SYMBOL1(g);
		CASE(H): SYMBOL1(h);
		CASE(I): SYMBOL1(i);
		CASE(J): SYMBOL1(j);
		CASE(K): SYMBOL1(k);
		CASE(L): SYMBOL1(l);
		CASE(M): SYMBOL1(m);
		CASE(N): SYMBOL1(n);
		CASE(O): SYMBOL1(o);
		CASE(P): SYMBOL1(p);
		CASE(Q): SYMBOL1(q);
		CASE(R): SYMBOL1(r);
		CASE(S): SYMBOL1(s);
		CASE(T): SYMBOL1(t);
		CASE(U): SYMBOL1(u);
		CASE(V): SYMBOL1(v);
		CASE(W): SYMBOL1(w);
		CASE(X): SYMBOL1(x);
		CASE(Y): SYMBOL1(y);
		CASE(Z): SYMBOL1(z);

		CASE(0):
		CASE(NUM_0): SYMBOL1(0);
		CASE(1):
		CASE(NUM_1): SYMBOL1(1);
		CASE(2):
		CASE(NUM_2): SYMBOL1(2);
		CASE(3):
		CASE(NUM_3): SYMBOL1(3);
		CASE(4):
		CASE(NUM_4): SYMBOL1(4);
		CASE(5):
		CASE(NUM_5): SYMBOL1(5);
		CASE(6):
		CASE(NUM_6): SYMBOL1(6);
		CASE(7):
		CASE(NUM_7): SYMBOL1(7);
		CASE(8):
		CASE(NUM_8): SYMBOL1(8);
		CASE(9):
		CASE(NUM_9): SYMBOL1(9);

		CASE(MINUS):      SYMBOL1(minus);
		CASE(EQUAL):      SYMBOL1(equal);
		CASE(COMMA):      SYMBOL1(comma);
		CASE(PERIOD):     SYMBOL1(period);
		CASE(SEMICOLON):  SYMBOL1(semicolon);
		CASE(QUOTE):      SYMBOL1(quote);
		CASE(SLASH):      SYMBOL1(slash);
		CASE(BACKSLASH):  SYMBOL1(backslash);
		CASE(UNDERSCORE): SYMBOL1(underscore);
		CASE(GRAVE):      SYMBOL1(grave);
		CASE(YEN):        SYMBOL1(yen);
		CASE(LBRACKET):   SYMBOL1(lbracket);
		CASE(RBRACKET):   SYMBOL1(rbracket);

#if defined(OSX) || defined(IOS) || defined(WIN32)
		CASE(ENTER):     SYMBOL1(enter);
#else
		CASE(ENTER):     SYMBOL1(enter);
		CASE(RETURN):    SYMBOL1(_return, "return");
#endif
		CASE(SPACE):     SYMBOL1(space);
		CASE(TAB):       SYMBOL1(tab);
		CASE(DELETE):    SYMBOL2(_delete, "delete");
		CASE(BACKSPACE): SYMBOL1(backspace);
		CASE(INSERT):    SYMBOL1(insert);
		CASE(ESCAPE):    SYMBOL1(escape);

		CASE(LEFT):     SYMBOL1(left);
		CASE(RIGHT):    SYMBOL1(right);
		CASE(UP):       SYMBOL1(up);
		CASE(DOWN):     SYMBOL1(down);
		CASE(HOME):     SYMBOL1(home);
		CASE(END):      SYMBOL1(end);
		CASE(PAGEUP):   SYMBOL1(pageup);
		CASE(PAGEDOWN): SYMBOL1(pagedown);

#if !defined(OSX) && !defined(IOS)
		CASE(SHIFT):
#endif
		CASE(LSHIFT):
		CASE(RSHIFT):   SYMBOL1(shift);
#if !defined(OSX) && !defined(IOS)
		CASE(CONTROL):
#endif
		CASE(LCONTROL):
		CASE(RCONTROL): SYMBOL1(control);
		CASE(ALT):
		CASE(LALT):
		CASE(RALT):     SYMBOL1(alt);
		CASE(LWIN):
		CASE(RWIN):     SYMBOL1(win);
		CASE(LCOMMAND):
		CASE(RCOMMAND): SYMBOL1(command);
		CASE(LOPTION):
		CASE(ROPTION):  SYMBOL1(option);
		CASE(FUNCTION): SYMBOL1(function);

		CASE(F1):  SYMBOL1(f1);
		CASE(F2):  SYMBOL1(f2);
		CASE(F3):  SYMBOL1(f3);
		CASE(F4):  SYMBOL1(f4);
		CASE(F5):  SYMBOL1(f5);
		CASE(F6):  SYMBOL1(f6);
		CASE(F7):  SYMBOL1(f7);
		CASE(F8):  SYMBOL1(f8);
		CASE(F9):  SYMBOL1(f9);
		CASE(F10): SYMBOL1(f10);
		CASE(F11): SYMBOL1(f11);
		CASE(F12): SYMBOL1(f12);
		CASE(F13): SYMBOL1(f13);
		CASE(F14): SYMBOL1(f14);
		CASE(F15): SYMBOL1(f15);
		CASE(F16): SYMBOL1(f16);
		CASE(F17): SYMBOL1(f17);
		CASE(F18): SYMBOL1(f18);
		CASE(F19): SYMBOL1(f19);
		CASE(F20): SYMBOL1(f20);
		CASE(F21): SYMBOL1(f21);
		CASE(F22): SYMBOL1(f22);
		CASE(F23): SYMBOL1(f23);
		CASE(F24): SYMBOL1(f24);

		CASE(NUM_PLUS):     SYMBOL1(plus);
		CASE(NUM_MINUS):    SYMBOL1(minus);
		CASE(NUM_MULTIPLY): SYMBOL1(multiply);
		CASE(NUM_DIVIDE):   SYMBOL1(divide);
		CASE(NUM_EQUAL):    SYMBOL1(equal);
		CASE(NUM_COMMA):    SYMBOL1(comma);
		CASE(NUM_DECIMAL):  SYMBOL1(decimal);
		CASE(NUM_CLEAR):    SYMBOL1(clear);
		CASE(NUM_ENTER):    SYMBOL1(enter);

		CASE(CAPSLOCK):   SYMBOL1(capslock);
		CASE(NUMLOCK):    SYMBOL1(numlock);
		CASE(SCROLLLOCK): SYMBOL1(scrolllock);

		CASE(PRINTSCREEN): SYMBOL1(printscreen);
		CASE(PAUSE):       SYMBOL1(pause);
		CASE(BREAK):       SYMBOL2(_break, "break");
		CASE(SECTION):     SYMBOL1(section);
		CASE(HELP):        SYMBOL1(help);

		CASE(EISU):           SYMBOL1(eisu);
		CASE(KANA):           SYMBOL1(kana);
		CASE(KANJI):          SYMBOL1(kanji);
		CASE(IME_ON):         SYMBOL1(ime_on);
		CASE(IME_OFF):        SYMBOL1(ime_off);
		CASE(IME_MODECHANGE): SYMBOL1(ime_mode_change);
		CASE(CONVERT):        SYMBOL1(convert);
		CASE(NONCONVERT):     SYMBOL1(nonconvert);
		CASE(ACCEPT):         SYMBOL1(accept);
		CASE(PROCESS):        SYMBOL1(process);

		CASE(VOLUME_UP):   SYMBOL1(volume_up);
		CASE(VOLUME_DOWN): SYMBOL1(volume_down);
		CASE(MUTE):        SYMBOL1(mute);

		CASE(SLEEP):  SYMBOL1(sleep);
		CASE(EXEC):   SYMBOL1(exec);
		CASE(PRINT):  SYMBOL1(print);
		CASE(APPS):   SYMBOL1(apps);
		CASE(SELECT): SYMBOL1(select);
		CASE(CLEAR):  SYMBOL1(clear);

		CASE(NAVIGATION_VIEW):   SYMBOL1(navigation_view);
		CASE(NAVIGATION_MENU):   SYMBOL1(navigation_menu);
		CASE(NAVIGATION_UP):     SYMBOL1(navigation_up);
		CASE(NAVIGATION_DOWN):   SYMBOL1(navigation_down);
		CASE(NAVIGATION_LEFT):   SYMBOL1(navigation_left);
		CASE(NAVIGATION_RIGHT):  SYMBOL1(navigation_right);
		CASE(NAVIGATION_ACCEPT): SYMBOL1(navigation_accept);
		CASE(NAVIGATION_CANCEL): SYMBOL1(navigation_cancel);

		CASE(BROWSER_BACK):      SYMBOL1(browser_back);
		CASE(BROWSER_FORWARD):   SYMBOL1(browser_forward);
		CASE(BROWSER_REFRESH):   SYMBOL1(browser_refresh);
		CASE(BROWSER_STOP):      SYMBOL1(browser_stop);
		CASE(BROWSER_SEARCH):    SYMBOL1(browser_search);
		CASE(BROWSER_FAVORITES): SYMBOL1(browser_favorites);
		CASE(BROWSER_HOME):      SYMBOL1(browser_home);

		CASE(MEDIA_PREV_TRACK): SYMBOL1(media_prev);
		CASE(MEDIA_NEXT_TRACK): SYMBOL1(media_next);
		CASE(MEDIA_PLAY_PAUSE): SYMBOL1(media_play_pause);
		CASE(MEDIA_STOP):       SYMBOL1(media_stop);

		CASE(LAUNCH_MAIL):         SYMBOL1(launch_mail);
		CASE(LAUNCH_MEDIA_SELECT): SYMBOL1(launch_media_select);
		CASE(LAUNCH_APP1):         SYMBOL1(launch_app1);
		CASE(LAUNCH_APP2):         SYMBOL1(launch_app2);

		#undef CASE
		#undef SYMBOL1
		#undef SYMBOL2
	}
	return nil();
}

static
VALUE get_chars(VALUE self)
{
	CHECK;
	const char* chars = THIS->chars();
	return chars ? value(chars) : nil();
}

static
VALUE get_code(VALUE self)
{
	CHECK;
	return value(THIS->code());
}

static
VALUE get_modifiers(VALUE self)
{
	CHECK;
	return value(THIS->modifiers());
}

static
VALUE get_repeat(VALUE self)
{
	CHECK;
	return value(THIS->repeat());
}

static
VALUE is_captured(VALUE self)
{
	CHECK;
	return value(THIS->is_captured());
}


static Class cKeyEvent;

void
Init_reflex_key_event ()
{
	Module mReflex = rb_define_module("Reflex");

	cKeyEvent = mReflex.define_class("KeyEvent", Reflex::event_class());
	rb_define_alloc_func(cKeyEvent, alloc);
	rb_define_private_method(cKeyEvent, "initialize", RUBY_METHOD_FUNC(initialize), 5);
	rb_define_private_method(cKeyEvent, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
	rb_define_method(cKeyEvent, "action", RUBY_METHOD_FUNC(get_action), 0);
	rb_define_method(cKeyEvent, "key", RUBY_METHOD_FUNC(get_key), 0);
	rb_define_method(cKeyEvent, "chars", RUBY_METHOD_FUNC(get_chars), 0);
	rb_define_method(cKeyEvent, "code", RUBY_METHOD_FUNC(get_code), 0);
	rb_define_method(cKeyEvent, "modifiers", RUBY_METHOD_FUNC(get_modifiers), 0);
	rb_define_method(cKeyEvent, "repeat", RUBY_METHOD_FUNC(get_repeat), 0);
	cKeyEvent.define_method("captured?", is_captured);

	cKeyEvent.define_const("ACTION_NONE", Reflex::KeyEvent::ACTION_NONE);
	cKeyEvent.define_const("DOWN",        Reflex::KeyEvent::DOWN);
	cKeyEvent.define_const("UP",          Reflex::KeyEvent::UP);
}


namespace Reflex
{


	Class
	key_event_class ()
	{
		return cKeyEvent;
	}


}// Reflex