#include "rays/ruby/image.h"


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


using namespace Rucy;

using Rays::coord;


namespace Rays
{


	static Class cImage;

	Class
	image_class ()
	{
		return cImage;
	}


}// Rays


namespace Rucy
{


	Value
	value (const Rays::Image& image)
	{
		return new_type<Rays::Image>(
			Rays::image_class(), new Rays::Image(image));
	}


}// Rucy


#define this to<Rays::Image*>(self)

#define CHECK CHECK_OBJECT(self, Rays::Image, Rays::image_class())


static
VALUE alloc(VALUE klass)
{
	return new_type<Rays::Image>(klass, new Rays::Image);
}

static
VALUE initialize(VALUE self)
{
	CHECK_OBJ(self, Rays::Image, Rays::image_class());
	if (argc != 0 && argc != 1 && argc != 2 && argc != 3)
		arg_count_error("Image#initialize", argc, 0, 1, 2, 3);

	if (argc == 0) return self;

	if (argv[1].is_kind_of(Rays::bitmap_class()))
	{
		if (argc != 1 && argc != 2)
			arg_count_error("Image#initialize", argc, 0, 1, 2, 3);

		const Rays::Bitmap& bitmap = *to<Rays::Bitmap*>(argv[1]);
		bool alphaonly = (argc == 2) ? to<bool>(argv[2]) : false;
		*this = Rays::Image(bitmap, alphaonly);
	}
	else
	{
		int width  = to<int>(argv[0]);
		int height = to<int>(argv[1]);
		uint colorspace = (argc == 3) ? to<uint>(argv[2]) : (uint) Rays::RGBA;
		*this = Rays::Image(width, height, (Rays::ColorSpaceType) colorspace);
	}

	return self;
}

static
VALUE width(VALUE self)
{
	CHECK;

	return value(this->width());
}

static
VALUE height(VALUE self)
{
	CHECK;

	return value(this->height());
}

static
VALUE color_space(VALUE self)
{
	CHECK;

	return value(this->color_space().type());
}

static
VALUE bitmap(VALUE self)
{
	CHECK;

	return value(this->bitmap());
}

static
VALUE texture(VALUE self)
{
	CHECK;

	return value(this->texture());
}


static
VALUE load(VALUE self)
{
	if (argc != 1 && argc != 2) arg_count_error("Image.load", argc, 1, 2);

	Rays::String path = argv[0].c_str();
	bool alphaonly = (argc == 2) ? to<bool>(argv[1]) : false;

	Rays::Image img;
	if (!Rays::load_image(&img, path.c_str(), alphaonly))
	{
		error(
			"Image.load('%s', %s) failed.",
			path.c_str(), alphaonly ? "true" : "false");
	}

	return value(img);
}


void
Init_image ()
{
	Module m = rb_define_module("Rays");

	Class c = rb_define_class_under(m, "Image", rb_cObject);
	Rays::cImage = c;

	rb_define_alloc_func(c, alloc);
	rb_define_method(c, "initialize", RUBY_METHOD_FUNC(initialize), -1);
	rb_define_method(c, "width", RUBY_METHOD_FUNC(width), 0);
	rb_define_method(c, "height", RUBY_METHOD_FUNC(height), 0);
	rb_define_method(c, "color_space", RUBY_METHOD_FUNC(color_space), 0);
	rb_define_method(c, "bitmap", RUBY_METHOD_FUNC(bitmap), 0);
	rb_define_method(c, "texture", RUBY_METHOD_FUNC(texture), 0);
	rb_define_function(c, "load", RUBY_METHOD_FUNC(load), -1);
}