#include "reflex/ruby/view.h"


#include <vector>
#include <rucy.h>
#include <rays/ruby/point.h>
#include <rays/ruby/bounds.h>
#include "reflex/ruby/window.h"
#include "reflex/ruby/selector.h"
#include "reflex/ruby/style.h"
#include "reflex/ruby/body.h"


using namespace Rucy;

using Reflex::coord;


RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(Reflex::View)

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

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

#define CALL(fun) RUCY_WRAPPER_CALL(Reflex::View, THIS, fun)


template <typename T>
static inline Value
array (T begin, T end)
{
	std::vector<Value> v;
	for (T it = begin; it != end; ++it) v.push_back(value(*it));
	return value(v.size(), &v[0]);
}


static
VALUE alloc(VALUE klass)
{
	return value(new Reflex::RubyView<Reflex::View>, 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 redraw(VALUE self)
{
	CHECK;
	THIS->redraw();
	return self;
}

static
VALUE add_child(VALUE self, VALUE child)
{
	CHECK;
	THIS->add_child(to<Reflex::View*>(child));
	return child;
}

static
VALUE remove_child(VALUE self, VALUE child)
{
	CHECK;
	THIS->remove_child(to<Reflex::View*>(child));
	return child;
}

static
VALUE find_children(VALUE self)
{
	CHECK;
	check_arg_count(__FILE__, __LINE__, "View#find_children", argc, 1, 2);

	bool recursive = (argc >= 2) ? to<bool>(argv[1]) : false;

	Reflex::View::ChildList children;
	THIS->find_children(&children, to<Reflex::Selector>(argv[0]), recursive);
	return array(children.begin(), children.end());
}

static
VALUE each_child(VALUE self)
{
	CHECK;

	Value ret;
	Reflex::View::child_iterator end = THIS->child_end();
	for (Reflex::View::child_iterator it = THIS->child_begin(); it != end; ++it)
		ret = rb_yield(value(it->get()));
	return ret;
}

static
VALUE add_style(VALUE self, VALUE style)
{
	CHECK;
	THIS->add_style(to<Reflex::Style&>(style));
	return style;
}

static
VALUE remove_style(VALUE self, VALUE style)
{
	CHECK;
	THIS->remove_style(to<Reflex::Style&>(style));
	return style;
}

static
VALUE get_style(VALUE self)
{
	CHECK;
	check_arg_count(__FILE__, __LINE__, "View#get_style", argc, 0, 1);

	if (argc == 0)
		return value(THIS->style());
	else
		return value(THIS->get_style(to<Reflex::Selector>(argv[0])));
}

static
VALUE find_styles(VALUE self)
{
	CHECK;
	check_arg_count(__FILE__, __LINE__, "View#find_styles", argc, 1, 2);

	bool recursive = (argc >= 2) ? to<bool>(argv[1]) : false;

	Reflex::View::StyleList styles;
	THIS->find_styles(&styles, to<Reflex::Selector>(argv[0]), recursive);
	return array(styles.begin(), styles.end());
}

static
VALUE each_style(VALUE self)
{
	CHECK;

	Value ret;
	Reflex::View::style_iterator end = THIS->style_end();
	for (Reflex::View::style_iterator it = THIS->style_begin(); it != end; ++it)
		ret = rb_yield(value(*it));
	return ret;
}

static
VALUE focus(VALUE self)
{
	CHECK;
	check_arg_count(__FILE__, __LINE__, "View#focus", argc, 0, 1);

	bool state = (argc >= 1) ? to<bool>(argv[0]) : true;

	THIS->focus(state);
	return self;
}

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

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

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

static
VALUE content_size(VALUE self)
{
	CHECK;
	return value(CALL(content_size()));
}

static
VALUE make_body(VALUE self)
{
	CHECK;
	CALL(make_body());
}

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

static
VALUE set_name(VALUE self, VALUE name)
{
	CHECK;
	THIS->set_name(name.is_nil() ? NULL : name.c_str());
}

static
VALUE get_name(VALUE self)
{
	CHECK;
	return THIS->name() ? value(THIS->name()) : nil();
}

static
VALUE add_tag(VALUE self, VALUE tag)
{
	CHECK;
	THIS->add_tag(tag.c_str());
}

static
VALUE remove_tag(VALUE self, VALUE tag)
{
	CHECK;
	THIS->remove_tag(tag.c_str());
}

static
VALUE each_tag(VALUE self)
{
	CHECK;

	Value ret;
	Reflex::View::tag_iterator end = THIS->tag_end();
	for (Reflex::View::tag_iterator it = THIS->tag_begin(); it != end; ++it)
		ret = rb_yield(value(*it));
	return ret;
}

static
VALUE set_selector(VALUE self, VALUE selector)
{
	CHECK;
	THIS->set_selector(to<Reflex::Selector>(selector));
}

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

static
VALUE set_frame(VALUE self, VALUE arg)
{
	CHECK;
	THIS->set_frame(to<Rays::Bounds>(arg));
}

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

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

static
VALUE set_capture(VALUE self, VALUE types)
{
	CHECK;
	THIS->set_capture(to<uint>(types));
}

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

static
VALUE scroll_to(VALUE self)
{
	CHECK;
	check_arg_count(__FILE__, __LINE__, "View#scroll_to", argc, 1, 2, 3);

	if (argv[0].is_kind_of(Rays::point_class()))
		THIS->scroll_to(to<Rays::Point&>(argv[0]));
	else
	{
		const Rays::Point& p = THIS->scroll();
		coord x = (argc >= 1 && argv[0]) ? to<coord>(argv[0]) : p.x;
		coord y = (argc >= 2 && argv[1]) ? to<coord>(argv[1]) : p.y;
		coord z = (argc >= 3 && argv[2]) ? to<coord>(argv[2]) : p.z;
		THIS->scroll_to(x, y, z);
	}

	return self;
}

static
VALUE scroll_by(VALUE self)
{
	CHECK;
	check_arg_count(__FILE__, __LINE__, "View#scroll_by", argc, 1, 2, 3);

	if (argv[0].is_kind_of(Rays::point_class()))
		THIS->scroll_by(to<Rays::Point&>(argv[0]));
	else
	{
		coord x = (argc >= 1 && argv[0]) ? to<coord>(argv[0]) : 0;
		coord y = (argc >= 2 && argv[1]) ? to<coord>(argv[1]) : 0;
		coord z = (argc >= 3 && argv[2]) ? to<coord>(argv[2]) : 0;
		THIS->scroll_by(x, y, z);
	}

	return self;
}

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

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

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

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

static
VALUE meter2pixel(VALUE self)
{
	CHECK;
	check_arg_count(__FILE__, __LINE__, "View#meter2pixel", argc, 0, 1, 2);

	float meter       = argc >= 1 ? argv[0].as_f(true) : 1;
	bool create_world = argc >= 2 ? (bool) argv[1]     : true;
	return value(THIS->meter2pixel(meter, create_world));
}

static
VALUE set_gravity(VALUE self, VALUE x, VALUE y)
{
	CHECK;
	THIS->set_gravity(x.as_f(true), y.as_f(true));
	return self;
}

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

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

static
VALUE set_debug(VALUE self, VALUE state)
{
	CHECK;
	THIS->set_debug(state);
	return state;
}

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

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

	RUCY_SYM(call_attach_block);
	self.call(call_attach_block);

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

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

static
VALUE on_show(VALUE self, VALUE event)
{
	CHECK;
	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_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_rotate(VALUE self, VALUE event)
{
	CHECK;
	CALL(on_rotate(to<Reflex::FrameEvent*>(event)));
}

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

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

static
VALUE on_blur(VALUE self, VALUE event)
{
	CHECK;
	CALL(on_blur(to<Reflex::FocusEvent*>(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_wheel(VALUE self, VALUE event)
{
	CHECK;
	CALL(on_wheel(to<Reflex::WheelEvent*>(event)));
}

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

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

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

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

static
RUCY_DEF_clear_override_flags(cof, Reflex::View);


static Class cView;

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

	cView = rb_define_class_under(mReflex, "View", rb_cObject);
	rb_define_alloc_func(cView, alloc);
	rb_define_method(cView, "show", RUBY_METHOD_FUNC(show), 0);
	rb_define_method(cView, "hide", RUBY_METHOD_FUNC(hide), 0);
	cView.define_method("hidden?", hidden);
	rb_define_method(cView, "redraw", RUBY_METHOD_FUNC(redraw), 0);
	rb_define_method(cView, "add_child", RUBY_METHOD_FUNC(add_child), 1);
	rb_define_method(cView, "remove_child", RUBY_METHOD_FUNC(remove_child), 1);
	rb_define_method(cView, "find_children", RUBY_METHOD_FUNC(find_children), -1);
	rb_define_method(cView, "each_child", RUBY_METHOD_FUNC(each_child), 0);
	rb_define_method(cView, "add_style", RUBY_METHOD_FUNC(add_style), 1);
	rb_define_method(cView, "remove_style", RUBY_METHOD_FUNC(remove_style), 1);
	rb_define_method(cView, "get_style", RUBY_METHOD_FUNC(get_style), -1);
	rb_define_method(cView, "find_styles", RUBY_METHOD_FUNC(find_styles), -1);
	rb_define_method(cView, "each_style", RUBY_METHOD_FUNC(each_style), 0);
	rb_define_method(cView, "focus", RUBY_METHOD_FUNC(focus), -1);
	rb_define_method(cView, "blur", RUBY_METHOD_FUNC(blur), 0);
	cView.define_method("focus?", has_focus);
	rb_define_method(cView, "resize_to_fit", RUBY_METHOD_FUNC(resize_to_fit), 0);
	rb_define_method(cView, "content_size", RUBY_METHOD_FUNC(content_size), 0);
	rb_define_method(cView, "make_body", RUBY_METHOD_FUNC(make_body), 0);
	rb_define_method(cView, "clear_body", RUBY_METHOD_FUNC(clear_body), 0);
	rb_define_method(cView, "name=", RUBY_METHOD_FUNC(set_name), 1);
	rb_define_method(cView, "name", RUBY_METHOD_FUNC(get_name), 0);
	rb_define_method(cView, "add_tag", RUBY_METHOD_FUNC(add_tag), 1);
	rb_define_method(cView, "remove_tag", RUBY_METHOD_FUNC(remove_tag), 1);
	rb_define_method(cView, "each_tag", RUBY_METHOD_FUNC(each_tag), 0);
	rb_define_method(cView, "selector=", RUBY_METHOD_FUNC(set_selector), 1);
	rb_define_method(cView, "selector", RUBY_METHOD_FUNC(get_selector), 0);
	rb_define_private_method(cView, "set_frame", RUBY_METHOD_FUNC(set_frame), 1);
	rb_define_private_method(cView, "get_frame", RUBY_METHOD_FUNC(get_frame), 0);
	rb_define_method(cView, "angle", RUBY_METHOD_FUNC(get_angle), 0);
	rb_define_method(cView, "scroll_to", RUBY_METHOD_FUNC(scroll_to), -1);
	rb_define_method(cView, "scroll_by", RUBY_METHOD_FUNC(scroll_by), -1);
	rb_define_method(cView, "scroll", RUBY_METHOD_FUNC(get_scroll), 0);
	rb_define_method(cView, "set_capture", RUBY_METHOD_FUNC(set_capture), 1);
	rb_define_method(cView, "get_capture", RUBY_METHOD_FUNC(get_capture), 0);
	rb_define_method(cView, "parent", RUBY_METHOD_FUNC(parent), 0);
	rb_define_method(cView, "window", RUBY_METHOD_FUNC(window), 0);
	rb_define_method(cView, "body", RUBY_METHOD_FUNC(body), 0);
	rb_define_method(cView, "meter2pixel", RUBY_METHOD_FUNC(meter2pixel), -1);
	rb_define_method(cView, "set_gravity", RUBY_METHOD_FUNC(set_gravity), 2);
	rb_define_method(cView, "gravity", RUBY_METHOD_FUNC(get_gravity), 0);
	rb_define_method(cView, "wall", RUBY_METHOD_FUNC(wall), 0);
	rb_define_method(cView, "debug=", RUBY_METHOD_FUNC(set_debug), 1);
	cView.define_method("debug?",     debugging);
	rb_define_method(cView, "on_attach", RUBY_METHOD_FUNC(on_attach), 1);
	rb_define_method(cView, "on_detach", RUBY_METHOD_FUNC(on_detach), 1);
	rb_define_method(cView, "on_show", RUBY_METHOD_FUNC(on_show), 1);
	rb_define_method(cView, "on_hide", RUBY_METHOD_FUNC(on_hide), 1);
	rb_define_method(cView, "on_update", RUBY_METHOD_FUNC(on_update), 1);
	rb_define_method(cView, "on_draw", RUBY_METHOD_FUNC(on_draw), 1);
	rb_define_method(cView, "on_move", RUBY_METHOD_FUNC(on_move), 1);
	rb_define_method(cView, "on_resize", RUBY_METHOD_FUNC(on_resize), 1);
	rb_define_method(cView, "on_rotate", RUBY_METHOD_FUNC(on_rotate), 1);
	rb_define_method(cView, "on_scroll", RUBY_METHOD_FUNC(on_scroll), 1);
	rb_define_method(cView, "on_focus", RUBY_METHOD_FUNC(on_focus), 1);
	rb_define_method(cView, "on_blur", RUBY_METHOD_FUNC(on_blur), 1);
	rb_define_method(cView, "on_key", RUBY_METHOD_FUNC(on_key), 1);
	rb_define_method(cView, "on_key_down", RUBY_METHOD_FUNC(on_key_down), 1);
	rb_define_method(cView, "on_key_up", RUBY_METHOD_FUNC(on_key_up), 1);
	rb_define_method(cView, "on_pointer", RUBY_METHOD_FUNC(on_pointer), 1);
	rb_define_method(cView, "on_pointer_down", RUBY_METHOD_FUNC(on_pointer_down), 1);
	rb_define_method(cView, "on_pointer_up", RUBY_METHOD_FUNC(on_pointer_up), 1);
	rb_define_method(cView, "on_pointer_move", RUBY_METHOD_FUNC(on_pointer_move), 1);
	rb_define_method(cView, "on_wheel", RUBY_METHOD_FUNC(on_wheel), 1);
	rb_define_method(cView, "on_capture", RUBY_METHOD_FUNC(on_capture), 1);
	rb_define_method(cView, "on_contact", RUBY_METHOD_FUNC(on_contact), 1);
	rb_define_method(cView, "on_contact_begin", RUBY_METHOD_FUNC(on_contact_begin), 1);
	rb_define_method(cView, "on_contact_end", RUBY_METHOD_FUNC(on_contact_end), 1);
	cView.define_const("CAPTURE_NONE",      Reflex::View::CAPTURE_NONE);
	cView.define_const("CAPTURE_KEY",       Reflex::View::CAPTURE_KEY);
	cView.define_const("CAPTURE_POINTER",   Reflex::View::CAPTURE_POINTER);
	cView.define_const("CAPTURE_ALL",       Reflex::View::CAPTURE_ALL);
	
}


namespace Reflex
{


	Class
	view_class ()
	{
		return cView;
	}


}// Reflex