#include "reflex/ruby/event.h"


#include <rucy.h>
#include <rays/ruby/point.h>
#include "defs.h"


using namespace Rucy;

using Reflex::coord;


RUCY_DEFINE_VALUE_FROM_TO(Reflex::PointerEvent)

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

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


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

static
VALUE initialize(VALUE self)
{
	CHECK;
	check_arg_count(__FILE__, __LINE__, "PointerEvent#initialize", argc, 0, 1, 2, 3, 4, 5, 6, 7);

	THIS->type         = (argc >= 1) ? (Reflex::PointerEvent::Type) to<int>(argv[0]) : Reflex::PointerEvent::NONE;
	THIS->pointer_type = (argc >= 2) ? to<uint>(argv[1])  : Reflex::POINTER_NONE;
	THIS->x            = (argc >= 3) ? to<coord>(argv[2]) : 0;
	THIS->y            = (argc >= 4) ? to<coord>(argv[3]) : 0;
	THIS->size         = 1;
	THIS->modifiers    = (argc >= 5) ? to<uint>(argv[4])  : (uint) Reflex::MOD_NONE;
	THIS->count        = (argc >= 6) ? to<uint>(argv[5])  : 0;
	THIS->drag         = (argc >= 7) ? to<bool>(argv[6])  : false;

	return rb_call_super(0, NULL);
}

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

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

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

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

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

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

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

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

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

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

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

	size_t index = argc >= 1 ? to<int>(argv[0]) : 0;
	return value(THIS->position(index));
}

static
VALUE array_get(VALUE self, VALUE index)
{
	CHECK;
	return value((*THIS)[index.to_i()]);
}


static Class cPointerEvent;

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

	cPointerEvent = mReflex.define_class("PointerEvent", Reflex::event_class());
	rb_define_alloc_func(cPointerEvent, alloc);
	rb_define_private_method(cPointerEvent, "initialize", RUBY_METHOD_FUNC(initialize), -1);
	rb_define_private_method(cPointerEvent, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
	rb_define_method(cPointerEvent, "get_type", RUBY_METHOD_FUNC(get_type), 0);
	rb_define_method(cPointerEvent, "get_pointer_type", RUBY_METHOD_FUNC(get_pointer_type), 0);
	rb_define_method(cPointerEvent, "size", RUBY_METHOD_FUNC(size), 0);
	rb_define_method(cPointerEvent, "modifiers", RUBY_METHOD_FUNC(modifiers), 0);
	rb_define_method(cPointerEvent, "count", RUBY_METHOD_FUNC(count), 0);
	cPointerEvent.define_method("drag?", drag);
	cPointerEvent.define_method("capture?", capture);
	rb_define_method(cPointerEvent, "x", RUBY_METHOD_FUNC(x), 0);
	rb_define_method(cPointerEvent, "y", RUBY_METHOD_FUNC(y), 0);
	rb_define_method(cPointerEvent, "position", RUBY_METHOD_FUNC(position), -1);
	cPointerEvent.define_method("[]", array_get);
	cPointerEvent.define_const("TYPE_NONE", Reflex::PointerEvent::NONE);
	cPointerEvent.define_const("TYPE_DOWN", Reflex::PointerEvent::DOWN);
	cPointerEvent.define_const("TYPE_UP",   Reflex::PointerEvent::UP);
	cPointerEvent.define_const("TYPE_MOVE", Reflex::PointerEvent::MOVE);
	cPointerEvent.define_const("POINTER_NONE",         Reflex::POINTER_NONE);
	cPointerEvent.define_const("POINTER_MOUSE_LEFT",   Reflex::POINTER_MOUSE_LEFT);
	cPointerEvent.define_const("POINTER_MOUSE_RIGHT",  Reflex::POINTER_MOUSE_RIGHT);
	cPointerEvent.define_const("POINTER_MOUSE_MIDDLE", Reflex::POINTER_MOUSE_MIDDLE);
	cPointerEvent.define_const("POINTER_TOUCH",        Reflex::POINTER_TOUCH);
	cPointerEvent.define_const("POINTER_PEN",          Reflex::POINTER_PEN);
	cPointerEvent.define_const("POINTER_TYPE_LAST",    Reflex::POINTER_TYPE_LAST);
}


namespace Reflex
{


	Class
	pointer_event_class ()
	{
		return cPointerEvent;
	}


}// Reflex