#include "reflex/ruby/window.h"


#include <rays/ruby/bounds.h>
#include <rays/ruby/painter.h>
#include "reflex/ruby/screen.h"
#include "reflex/ruby/view.h"
#include "defs.h"


RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::Window)

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

#define CHECK     RUCY_CHECK_OBJECT(Reflex::Window, self)

#define CALL(fun) RUCY_CALL_SUPER(THIS, fun)


static
VALUE alloc(VALUE klass)
{
	return value(new Reflex::RubyWindow<Reflex::Window>, klass);
}

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

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

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

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

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

static
VALUE from_screen(VALUE self, VALUE point)
{
	CHECK;
	return value(THIS->from_screen(to<Rays::Point>(point)));
}

static
VALUE to_screen(VALUE self, VALUE point)
{
	CHECK;
	return value(THIS->to_screen(to<Rays::Point>(point)));
}

static
VALUE set_title(VALUE self, VALUE title)
{
	CHECK;
	THIS->set_title(title.c_str());
	return title;
}

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

static
VALUE set_frame(VALUE self)
{
	CHECK;
	THIS->set_frame(to<Rays::Bounds>(argc, argv));
	return value(THIS->frame());
}

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

static
VALUE set_closable(VALUE self, VALUE state)
{
	CHECK;

	if (state)
		THIS->   add_flag(Reflex::Window::FLAG_CLOSABLE);
	else
		THIS->remove_flag(Reflex::Window::FLAG_CLOSABLE);

	return state;
}

static
VALUE is_closable(VALUE self)
{
	CHECK;
	return value(THIS->has_flag(Reflex::Window::FLAG_CLOSABLE));
}

static
VALUE set_minimizable(VALUE self, VALUE state)
{
	CHECK;

	if (state)
		THIS->   add_flag(Reflex::Window::FLAG_MINIMIZABLE);
	else
		THIS->remove_flag(Reflex::Window::FLAG_MINIMIZABLE);

	return state;
}

static
VALUE is_minimizable(VALUE self)
{
	CHECK;
	return value(THIS->has_flag(Reflex::Window::FLAG_MINIMIZABLE));
}

static
VALUE set_resizable(VALUE self, VALUE state)
{
	CHECK;

	if (state)
		THIS->   add_flag(Reflex::Window::FLAG_RESIZABLE);
	else
		THIS->remove_flag(Reflex::Window::FLAG_RESIZABLE);

	return state;
}

static
VALUE is_resizable(VALUE self)
{
	CHECK;
	return value(THIS->has_flag(Reflex::Window::FLAG_RESIZABLE));
}

static
VALUE set_fullscreen(VALUE self, VALUE state)
{
	CHECK;

	if (state)
		THIS->   add_flag(Reflex::Window::FLAG_FULLSCREEN);
	else
		THIS->remove_flag(Reflex::Window::FLAG_FULLSCREEN);

	return state;
}

static
VALUE is_fullscreen(VALUE self)
{
	CHECK;
	return value(THIS->has_flag(Reflex::Window::FLAG_FULLSCREEN));
}

static const uint ORIENTATION_MASK =
	Reflex::Window::FLAG_PORTRAIT | Reflex::Window::FLAG_LANDSCAPE;

static
VALUE set_orientations(VALUE self, VALUE orientations)
{
	using namespace Reflex;

	CHECK;

	uint flags = to<uint>(orientations);
	THIS->set_flag(
		(      flags   &  ORIENTATION_MASK) |
		(THIS->flags() & ~ORIENTATION_MASK));
}

static
VALUE get_orientations(VALUE self)
{
	using namespace Reflex;

	CHECK;
	return value(THIS->flags() & ORIENTATION_MASK);
}

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

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

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

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

static
VALUE on_activate(VALUE self, VALUE event)
{
	CHECK;
	CALL(on_activate(to<Reflex::Event*>(event)));
}

static
VALUE on_deactivate(VALUE self, VALUE event)
{
	CHECK;
	CALL(on_deactivate(to<Reflex::Event*>(event)));
}

static
VALUE on_show(VALUE self, VALUE event)
{
	CHECK;

	RUCY_SYM(call_show_block);
	self.call(call_show_block);

	CALL(on_show(to<Reflex::Event*>(event)));
}

static
VALUE on_hide(VALUE self, VALUE event)
{
	CHECK;
	CALL(on_hide(to<Reflex::Event*>(event)));
}

static
VALUE on_close(VALUE self, VALUE event)
{
	CHECK;
	CALL(on_close(to<Reflex::Event*>(event)));
}

static
VALUE on_update(VALUE self, VALUE event)
{
	CHECK;
	CALL(on_update(to<Reflex::UpdateEvent*>(event)));
}

static
VALUE on_draw(VALUE self, VALUE event)
{
	CHECK;
	CALL(on_draw(to<Reflex::DrawEvent*>(event)));
}

static
VALUE on_move(VALUE self, VALUE event)
{
	CHECK;
	CALL(on_move(to<Reflex::FrameEvent*>(event)));
}

static
VALUE on_resize(VALUE self, VALUE event)
{
	CHECK;
	CALL(on_resize(to<Reflex::FrameEvent*>(event)));
}

static
VALUE on_key(VALUE self, VALUE event)
{
	CHECK;
	CALL(on_key(to<Reflex::KeyEvent*>(event)));
}

static
VALUE on_key_down(VALUE self, VALUE event)
{
	CHECK;
	CALL(on_key_down(to<Reflex::KeyEvent*>(event)));
}

static
VALUE on_key_up(VALUE self, VALUE event)
{
	CHECK;
	CALL(on_key_up(to<Reflex::KeyEvent*>(event)));
}

static
VALUE on_pointer(VALUE self, VALUE event)
{
	CHECK;
	CALL(on_pointer(to<Reflex::PointerEvent*>(event)));
}

static
VALUE on_pointer_down(VALUE self, VALUE event)
{
	CHECK;
	CALL(on_pointer_down(to<Reflex::PointerEvent*>(event)));
}

static
VALUE on_pointer_up(VALUE self, VALUE event)
{
	CHECK;
	CALL(on_pointer_up(to<Reflex::PointerEvent*>(event)));
}

static
VALUE on_pointer_move(VALUE self, VALUE event)
{
	CHECK;
	CALL(on_pointer_move(to<Reflex::PointerEvent*>(event)));
}

static
VALUE on_pointer_cancel(VALUE self, VALUE event)
{
	CHECK;
	CALL(on_pointer_cancel(to<Reflex::PointerEvent*>(event)));
}

static
VALUE on_wheel(VALUE self, VALUE event)
{
	CHECK;
	CALL(on_wheel(to<Reflex::WheelEvent*>(event)));
}


static Class cWindow;

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

	cWindow = rb_define_class_under(mReflex, "Window", rb_cObject);
	rb_define_alloc_func(cWindow, alloc);
	rb_define_method(cWindow, "show", RUBY_METHOD_FUNC(show), 0);
	rb_define_method(cWindow, "hide", RUBY_METHOD_FUNC(hide), 0);
	rb_define_method(cWindow, "close", RUBY_METHOD_FUNC(close), 0);
	rb_define_method(cWindow, "redraw", RUBY_METHOD_FUNC(redraw), 0);
	rb_define_method(cWindow, "from_screen", RUBY_METHOD_FUNC(from_screen), 1);
	rb_define_method(cWindow, "to_screen", RUBY_METHOD_FUNC(to_screen), 1);
	rb_define_method(cWindow, "title=", RUBY_METHOD_FUNC(set_title), 1);
	rb_define_method(cWindow, "title", RUBY_METHOD_FUNC(get_title), 0);
	rb_define_method(cWindow, "frame=", RUBY_METHOD_FUNC(set_frame), -1);
	rb_define_method(cWindow, "frame", RUBY_METHOD_FUNC(get_frame), 0);
	rb_define_method(cWindow, "closable=", RUBY_METHOD_FUNC(set_closable), 1);
	cWindow.define_method("closable?",     is_closable);
	rb_define_method(cWindow, "minimizable=", RUBY_METHOD_FUNC(set_minimizable), 1);
	cWindow.define_method("minimizable?",  is_minimizable);
	rb_define_method(cWindow, "resizable=", RUBY_METHOD_FUNC(set_resizable), 1);
	cWindow.define_method("resizable?",    is_resizable);
	rb_define_method(cWindow, "fullscreen=", RUBY_METHOD_FUNC(set_fullscreen), 1);
	cWindow.define_method("fullscreen?",   is_fullscreen);
	rb_define_method(cWindow, "orientations=", RUBY_METHOD_FUNC(set_orientations), 1);
	rb_define_method(cWindow, "orientations", RUBY_METHOD_FUNC(get_orientations), 0);
	rb_define_method(cWindow, "hidden", RUBY_METHOD_FUNC(hidden), 0);
	rb_define_method(cWindow, "screen", RUBY_METHOD_FUNC(get_screen), 0);
	rb_define_method(cWindow, "root", RUBY_METHOD_FUNC(get_root), 0);
	rb_define_method(cWindow, "focus", RUBY_METHOD_FUNC(get_focus), 0);
	rb_define_method(cWindow, "painter", RUBY_METHOD_FUNC(get_painter), 0);
	rb_define_method(cWindow, "on_activate", RUBY_METHOD_FUNC(on_activate), 1);
	rb_define_method(cWindow, "on_deactivate", RUBY_METHOD_FUNC(on_deactivate), 1);
	rb_define_method(cWindow, "on_show", RUBY_METHOD_FUNC(on_show), 1);
	rb_define_method(cWindow, "on_hide", RUBY_METHOD_FUNC(on_hide), 1);
	rb_define_method(cWindow, "on_close", RUBY_METHOD_FUNC(on_close), 1);
	rb_define_method(cWindow, "on_update", RUBY_METHOD_FUNC(on_update), 1);
	rb_define_method(cWindow, "on_draw", RUBY_METHOD_FUNC(on_draw), 1);
	rb_define_method(cWindow, "on_move", RUBY_METHOD_FUNC(on_move), 1);
	rb_define_method(cWindow, "on_resize", RUBY_METHOD_FUNC(on_resize), 1);
	rb_define_method(cWindow, "on_key", RUBY_METHOD_FUNC(on_key), 1);
	rb_define_method(cWindow, "on_key_down", RUBY_METHOD_FUNC(on_key_down), 1);
	rb_define_method(cWindow, "on_key_up", RUBY_METHOD_FUNC(on_key_up), 1);
	rb_define_method(cWindow, "on_pointer", RUBY_METHOD_FUNC(on_pointer), 1);
	rb_define_method(cWindow, "on_pointer_down", RUBY_METHOD_FUNC(on_pointer_down), 1);
	rb_define_method(cWindow, "on_pointer_up", RUBY_METHOD_FUNC(on_pointer_up), 1);
	rb_define_method(cWindow, "on_pointer_move", RUBY_METHOD_FUNC(on_pointer_move), 1);
	rb_define_method(cWindow, "on_pointer_cancel", RUBY_METHOD_FUNC(on_pointer_cancel), 1);
	rb_define_method(cWindow, "on_wheel", RUBY_METHOD_FUNC(on_wheel), 1);

	cWindow.define_const("ORIENTATION_PORTRAIT",  Reflex::Window::FLAG_PORTRAIT);
	cWindow.define_const("ORIENTATION_LANDSCAPE", Reflex::Window::FLAG_LANDSCAPE);
}


namespace Reflex
{


	Class
	window_class ()
	{
		return cWindow;
	}


}// Reflex