#include "prop_2d_data_sprite.h"

#include "prop_2d_data.h"

#include "scene/2d/sprite.h"

Ref<Texture> Prop2DDataSprite::get_texture() const {
	return _texture;
}
void Prop2DDataSprite::set_texture(const Ref<Texture> &value) {
	_texture = value;
}

Ref<Texture> Prop2DDataSprite::get_normal_map() const {
	return _normal_map;
}
void Prop2DDataSprite::set_normal_map(const Ref<Texture> &value) {
	_normal_map = value;
}

bool Prop2DDataSprite::get_centered() const {
	return _centered;
}
void Prop2DDataSprite::set_centered(const bool value) {
	_centered = value;
}

Vector2 Prop2DDataSprite::get_offset() const {
	return _offset;
}
void Prop2DDataSprite::set_offset(const Vector2 &value) {
	_offset = value;
}

bool Prop2DDataSprite::get_flip_h() const {
	return _flip_h;
}
void Prop2DDataSprite::set_flip_h(const bool value) {
	_flip_h = value;
}

bool Prop2DDataSprite::get_flip_v() const {
	return _flip_v;
}
void Prop2DDataSprite::set_flip_v(const bool value) {
	_flip_v = value;
}

int Prop2DDataSprite::get_animation_h_frames() const {
	return _animation_h_frames;
}
void Prop2DDataSprite::set_animation_h_frames(const int value) {
	_animation_h_frames = value;
}

int Prop2DDataSprite::get_animation_v_frames() const {
	return _animation_v_frames;
}
void Prop2DDataSprite::set_animation_v_frames(const int value) {
	_animation_v_frames = value;
}

int Prop2DDataSprite::get_animation_frame() const {
	return _animation_frame;
}
void Prop2DDataSprite::set_animation_frame(const int value) {
	_animation_frame = value;
}

Vector2 Prop2DDataSprite::get_animation_frame_coords() const {
	return _animation_frame_coords;
}
void Prop2DDataSprite::set_animation_frame_coords(const Vector2 &value) {
	_animation_frame_coords = value;
}

bool Prop2DDataSprite::get_region_enabled() const {
	return _region_enabled;
}
void Prop2DDataSprite::set_region_enabled(const bool value) {
	_region_enabled = value;
}

Rect2 Prop2DDataSprite::get_region() const {
	return _region;
}
void Prop2DDataSprite::set_region(const Rect2 &value) {
	_region = value;
}

bool Prop2DDataSprite::get_filter_clip() const {
	return _filter_clip;
}
void Prop2DDataSprite::set_filter_clip(const bool value) {
	_filter_clip = value;
}

bool Prop2DDataSprite::_processor_handles(Node *node) {
	Sprite *s = Object::cast_to<Sprite>(node);

	return s;
}

void Prop2DDataSprite::_processor_process(Ref<Prop2DData> prop_data, Node *node, const Transform2D &transform, Ref<Prop2DDataEntry> entry) {
	Sprite *s = Object::cast_to<Sprite>(node);

	ERR_FAIL_COND(!s);

	Ref<Prop2DDataSprite> l;

	if (entry.is_valid()) {
		l = entry;
	} else {
		l.instance();
	}

	l->set_texture(s->get_texture());
	l->set_normal_map(s->get_normal_map());

	l->set_centered(s->is_centered());
	l->set_offset(s->get_offset());

	l->set_flip_h(s->is_flipped_h());
	l->set_flip_v(s->is_flipped_v());

	l->set_animation_h_frames(s->get_hframes());
	l->set_animation_v_frames(s->get_vframes());
	l->set_animation_frame(s->get_frame());
	l->set_animation_frame_coords(s->get_frame_coords());

	l->set_region_enabled(s->is_region());
	l->set_region(s->get_region_rect());
	l->set_filter_clip(s->is_region_filter_clip_enabled());

	Prop2DDataEntry::_processor_process(prop_data, node, transform, l);
}

Node *Prop2DDataSprite::_processor_get_node_for(const Transform2D &transform, Node *node) {
	Sprite *n;

	if (node) {
		n = Object::cast_to<Sprite>(node);
	} else {
		n = memnew(Sprite());
	}

	n->set_texture(get_texture());
	n->set_normal_map(get_normal_map());
	n->set_centered(get_centered());
	n->set_offset(get_offset());

	n->set_flip_h(get_flip_h());
	n->set_flip_v(get_flip_v());

	n->set_hframes(get_animation_h_frames());
	n->set_vframes(get_animation_v_frames());
	n->set_frame(get_animation_frame());
	n->set_frame_coords(get_animation_frame_coords());

	n->set_region(get_region_enabled());
	n->set_region_rect(get_region());
	n->set_region_filter_clip(get_filter_clip());

	return Prop2DDataEntry::_processor_get_node_for(transform, n);
}

Prop2DDataSprite::Prop2DDataSprite() {
	_centered = false;
	_flip_h = false;
	_flip_v = false;

	_animation_h_frames = 0;
	_animation_v_frames = 0;
	_animation_frame = 0;

	_region_enabled = false;

	_filter_clip = false;
}
Prop2DDataSprite::~Prop2DDataSprite() {
}

#ifndef DISABLE_DEPRECATED
// TODO REMOVE AFTER NEXT RELEASE
bool Prop2DDataSprite::_set(const StringName &p_name, const Variant &p_value) {
	if (p_name == "get_flip_v") {
		set_flip_v(p_value);

		return true;
	} else if (p_name == "get_animation_h_frames") {
		set_animation_h_frames(p_value);

		return true;
	} else if (p_name == "set_animation_v_frames") {
		set_animation_v_frames(p_value);

		return true;
	} else if (p_name == "get_animation_frame") {
		set_animation_frame(p_value);

		return true;
	} else if (p_name == "get_animation_frame_coords") {
		set_animation_frame_coords(p_value);

		return true;
	} else if (p_name == "set_region_enabled") {
		set_region_enabled(p_value);

		return true;
	} else if (p_name == "get_region") {
		set_region(p_value);

		return true;
	} else if (p_name == "get_filter_clip") {
		set_filter_clip(p_value);

		return true;
	}

	return false;
}
#endif

void Prop2DDataSprite::_bind_methods() {
	ClassDB::bind_method(D_METHOD("get_texture"), &Prop2DDataSprite::get_texture);
	ClassDB::bind_method(D_METHOD("set_texture", "value"), &Prop2DDataSprite::set_texture);
	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "texture"), "set_texture", "get_texture");

	ClassDB::bind_method(D_METHOD("get_normal_map"), &Prop2DDataSprite::get_normal_map);
	ClassDB::bind_method(D_METHOD("set_normal_map", "value"), &Prop2DDataSprite::set_normal_map);
	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "normal_map"), "set_normal_map", "get_normal_map");

	ClassDB::bind_method(D_METHOD("get_centered"), &Prop2DDataSprite::get_centered);
	ClassDB::bind_method(D_METHOD("set_centered", "value"), &Prop2DDataSprite::set_centered);
	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "centered"), "set_centered", "get_centered");

	ClassDB::bind_method(D_METHOD("get_offset"), &Prop2DDataSprite::get_offset);
	ClassDB::bind_method(D_METHOD("set_offset", "value"), &Prop2DDataSprite::set_offset);
	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "offset"), "set_offset", "get_offset");

	ClassDB::bind_method(D_METHOD("get_flip_h"), &Prop2DDataSprite::get_flip_h);
	ClassDB::bind_method(D_METHOD("set_flip_h", "value"), &Prop2DDataSprite::set_flip_h);
	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "flip_h"), "set_flip_h", "get_flip_h");

	ClassDB::bind_method(D_METHOD("get_flip_v"), &Prop2DDataSprite::get_flip_v);
	ClassDB::bind_method(D_METHOD("set_flip_v", "value"), &Prop2DDataSprite::set_flip_v);
	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "flip_v"), "set_flip_v", "get_flip_v");

	ClassDB::bind_method(D_METHOD("get_animation_h_frames"), &Prop2DDataSprite::get_animation_h_frames);
	ClassDB::bind_method(D_METHOD("set_animation_h_frames", "value"), &Prop2DDataSprite::set_animation_h_frames);
	ADD_PROPERTY(PropertyInfo(Variant::INT, "animation_h_frames"), "set_animation_h_frames", "get_animation_h_frames");

	ClassDB::bind_method(D_METHOD("get_animation_v_frames"), &Prop2DDataSprite::get_animation_v_frames);
	ClassDB::bind_method(D_METHOD("set_animation_v_frames", "value"), &Prop2DDataSprite::set_animation_v_frames);
	ADD_PROPERTY(PropertyInfo(Variant::INT, "animation_v_frames"), "set_animation_v_frames", "get_animation_v_frames");

	ClassDB::bind_method(D_METHOD("get_animation_frame"), &Prop2DDataSprite::get_animation_frame);
	ClassDB::bind_method(D_METHOD("set_animation_frame", "value"), &Prop2DDataSprite::set_animation_frame);
	ADD_PROPERTY(PropertyInfo(Variant::INT, "animation_frame"), "set_animation_frame", "get_animation_frame");

	ClassDB::bind_method(D_METHOD("get_animation_frame_coords"), &Prop2DDataSprite::get_animation_frame_coords);
	ClassDB::bind_method(D_METHOD("set_animation_frame_coords", "value"), &Prop2DDataSprite::set_animation_frame_coords);
	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "animation_frame_coords"), "set_animation_frame_coords", "get_animation_frame_coords");

	ClassDB::bind_method(D_METHOD("get_region_enabled"), &Prop2DDataSprite::get_region_enabled);
	ClassDB::bind_method(D_METHOD("set_region_enabled", "value"), &Prop2DDataSprite::set_region_enabled);
	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "region_enabled"), "set_region_enabled", "get_region_enabled");

	ClassDB::bind_method(D_METHOD("get_region"), &Prop2DDataSprite::get_region);
	ClassDB::bind_method(D_METHOD("set_region", "value"), &Prop2DDataSprite::set_region);
	ADD_PROPERTY(PropertyInfo(Variant::RECT2, "region"), "set_region", "get_region");

	ClassDB::bind_method(D_METHOD("get_filter_clip"), &Prop2DDataSprite::get_filter_clip);
	ClassDB::bind_method(D_METHOD("set_filter_clip", "value"), &Prop2DDataSprite::set_filter_clip);
	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "filter_clip"), "set_filter_clip", "get_filter_clip");
}