/*************************************************************************/
/*  animation_tree_player.h                                              */
/*************************************************************************/
/*                       This file is part of:                           */
/*                           GODOT ENGINE                                */
/*                    http://www.godotengine.org                         */
/*************************************************************************/
/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur.                 */
/*                                                                       */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the       */
/* "Software"), to deal in the Software without restriction, including   */
/* without limitation the rights to use, copy, modify, merge, publish,   */
/* distribute, sublicense, and/or sell copies of the Software, and to    */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions:                                             */
/*                                                                       */
/* The above copyright notice and this permission notice shall be        */
/* included in all copies or substantial portions of the Software.       */
/*                                                                       */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
/*************************************************************************/
#ifndef ANIMATION_TREE_PLAYER_H
#define ANIMATION_TREE_PLAYER_H

#include "animation_player.h"
#include "scene/3d/skeleton.h"
#include "scene/3d/spatial.h"
#include "scene/resources/animation.h"

class AnimationTreePlayer : public Node {

	OBJ_TYPE(AnimationTreePlayer, Node);
	OBJ_CATEGORY("Animation Nodes");

public:
	enum AnimationProcessMode {
		ANIMATION_PROCESS_FIXED,
		ANIMATION_PROCESS_IDLE,
	};

	enum NodeType {

		NODE_OUTPUT,
		NODE_ANIMATION,
		NODE_ONESHOT,
		NODE_MIX,
		NODE_BLEND2,
		NODE_BLEND3,
		NODE_BLEND4,
		NODE_TIMESCALE,
		NODE_TIMESEEK,
		NODE_TRANSITION,

		NODE_MAX,
	};

	enum ConnectError {

		CONNECT_OK,
		CONNECT_INCOMPLETE,
		CONNECT_CYCLE
	};

private:
	enum {

		DISCONNECTED = -1,
	};

	struct TrackKey {

		uint32_t id;
		StringName property;
		int bone_idx;

		inline bool operator<(const TrackKey &p_right) const {

			if (id == p_right.id) {
				if (bone_idx == p_right.bone_idx) {
					return property < p_right.property;
				} else
					return bone_idx < p_right.bone_idx;
			} else
				return id < p_right.id;
		}
	};

	struct Track {
		uint32_t id;
		Object *object;
		Spatial *spatial;
		Skeleton *skeleton;
		int bone_idx;
		StringName property;

		Vector3 loc;
		Quat rot;
		Vector3 scale;

		Variant value;

		bool skip;
	};

	typedef Map<TrackKey, Track> TrackMap;

	TrackMap track_map;

	struct Input {

		StringName node;
		//Input() { node=-1;  }
	};

	struct NodeBase {

		bool cycletest;

		NodeType type;
		Point2 pos;

		Vector<Input> inputs;

		NodeBase() { cycletest = false; };
		virtual ~NodeBase() { cycletest = false; }
	};

	struct NodeOut : public NodeBase {

		NodeOut() {
			type = NODE_OUTPUT;
			inputs.resize(1);
		}
	};

	struct AnimationNode : public NodeBase {

		Ref<Animation> animation;

		struct TrackRef {
			int local_track;
			Track *track;
			float weight;
		};

		uint64_t last_version;
		List<TrackRef> tref;
		AnimationNode *next;
		float time;
		float step;
		String from;
		bool skip;

		HashMap<NodePath, bool> filter;

		AnimationNode() {
			type = NODE_ANIMATION;
			next = NULL;
			last_version = 0;
			skip = false;
		}
	};

	struct OneShotNode : public NodeBase {

		bool active;
		bool start;
		float fade_in;
		float fade_out;

		bool autorestart;
		float autorestart_delay;
		float autorestart_random_delay;
		bool mix;

		float time;
		float remaining;
		float autorestart_remaining;

		HashMap<NodePath, bool> filter;

		OneShotNode() {
			type = NODE_ONESHOT;
			fade_in = 0;
			fade_out = 0;
			inputs.resize(2);
			autorestart = false;
			autorestart_delay = 1;
			autorestart_remaining = 0;
			mix = false;
			active = false;
			start = false;
		}
	};

	struct MixNode : public NodeBase {

		float amount;
		MixNode() {
			type = NODE_MIX;
			inputs.resize(2);
		}
	};

	struct Blend2Node : public NodeBase {

		float value;
		HashMap<NodePath, bool> filter;
		Blend2Node() {
			type = NODE_BLEND2;
			value = 0;
			inputs.resize(2);
		}
	};

	struct Blend3Node : public NodeBase {

		float value;
		Blend3Node() {
			type = NODE_BLEND3;
			value = 0;
			inputs.resize(3);
		}
	};

	struct Blend4Node : public NodeBase {

		Point2 value;
		Blend4Node() {
			type = NODE_BLEND4;
			inputs.resize(4);
		}
	};

	struct TimeScaleNode : public NodeBase {

		float scale;
		TimeScaleNode() {
			type = NODE_TIMESCALE;
			scale = 1;
			inputs.resize(1);
		}
	};

	struct TimeSeekNode : public NodeBase {

		float seek_pos;

		TimeSeekNode() {
			type = NODE_TIMESEEK;
			inputs.resize(1);
			seek_pos = -1;
		}
	};

	struct TransitionNode : public NodeBase {

		struct InputData {

			bool auto_advance;
			InputData() { auto_advance = false; }
		};

		Vector<InputData> input_data;

		float prev_time;
		float prev_xfading;
		int prev;
		bool switched;

		float time;
		int current;

		float xfade;

		TransitionNode() {
			type = NODE_TRANSITION;
			xfade = 0;
			inputs.resize(1);
			input_data.resize(1);
			current = 0;
			prev = -1;
			prev_time = 0;
			prev_xfading = 0;
			switched = false;
		}
		void set_current(int p_current);
	};

	void _update_sources();

	StringName out_name;
	NodeOut *out;

	NodePath base_path;
	NodePath master;

	ConnectError last_error;
	AnimationNode *active_list;
	AnimationProcessMode animation_process_mode;
	bool processing;
	bool active;
	bool dirty_caches;
	Map<StringName, NodeBase *> node_map;

	// return time left to finish animation
	float _process_node(const StringName &p_node, AnimationNode **r_prev_anim, float p_step, bool p_seek = false, float p_fallback_weight = 1.0, HashMap<NodePath, float> *p_weights = NULL);
	void _process_animation(float p_delta);
	bool reset_request;

	ConnectError _cycle_test(const StringName &p_at_node);

	Track *_find_track(const NodePath &p_path);
	void _recompute_caches();
	void _recompute_caches(const StringName &p_node);
	DVector<String> _get_node_list();

	void _compute_weights(float *p_fallback_weight, HashMap<NodePath, float> *p_weights, float p_coeff, const HashMap<NodePath, bool> *p_filter = NULL, float p_filtered_coeff = 0);

protected:
	bool _set(const StringName &p_name, const Variant &p_value);
	bool _get(const StringName &p_name, Variant &r_ret) const;
	void _get_property_list(List<PropertyInfo> *p_list) const;
	void _notification(int p_what);

	static void _bind_methods();

public:
	void add_node(NodeType p_type, const StringName &p_node); // nodes must be >0 node 0 is built-in (exit)
	bool node_exists(const StringName &p_name) const;

	Error node_rename(const StringName &p_node, const StringName &p_new_name);
	int node_get_input_count(const StringName &p_node) const;
	StringName node_get_input_source(const StringName &p_node, int p_input) const;

	/* ANIMATION NODE */
	void animation_node_set_animation(const StringName &p_node, const Ref<Animation> &p_animation);
	Ref<Animation> animation_node_get_animation(const StringName &p_node) const;
	void animation_node_set_master_animation(const StringName &p_node, const String &p_master_animation);
	String animation_node_get_master_animation(const StringName &p_node) const;

	void animation_node_set_filter_path(const StringName &p_node, const NodePath &p_filter, bool p_enable);
	void animation_node_set_get_filtered_paths(const StringName &p_node, List<NodePath> *r_paths) const;
	bool animation_node_is_path_filtered(const StringName &p_node, const NodePath &p_path) const;

	/* ONE SHOT NODE */

	void oneshot_node_set_fadein_time(const StringName &p_node, float p_time);
	void oneshot_node_set_fadeout_time(const StringName &p_node, float p_time);

	float oneshot_node_get_fadein_time(const StringName &p_node) const;
	float oneshot_node_get_fadeout_time(const StringName &p_node) const;

	void oneshot_node_set_autorestart(const StringName &p_node, bool p_active);
	void oneshot_node_set_autorestart_delay(const StringName &p_node, float p_time);
	void oneshot_node_set_autorestart_random_delay(const StringName &p_node, float p_time);

	bool oneshot_node_has_autorestart(const StringName &p_node) const;
	float oneshot_node_get_autorestart_delay(const StringName &p_node) const;
	float oneshot_node_get_autorestart_random_delay(const StringName &p_node) const;

	void oneshot_node_set_mix_mode(const StringName &p_node, bool p_enabled);
	bool oneshot_node_get_mix_mode(const StringName &p_node) const;

	void oneshot_node_start(const StringName &p_node);
	void oneshot_node_stop(const StringName &p_node);
	bool oneshot_node_is_active(const StringName &p_node) const;

	void oneshot_node_set_filter_path(const StringName &p_node, const NodePath &p_filter, bool p_enable);
	void oneshot_node_set_get_filtered_paths(const StringName &p_node, List<NodePath> *r_paths) const;
	bool oneshot_node_is_path_filtered(const StringName &p_node, const NodePath &p_path) const;

	/* MIX/BLEND NODES */

	void mix_node_set_amount(const StringName &p_node, float p_amount);
	float mix_node_get_amount(const StringName &p_node) const;

	void blend2_node_set_amount(const StringName &p_node, float p_amount);
	float blend2_node_get_amount(const StringName &p_node) const;
	void blend2_node_set_filter_path(const StringName &p_node, const NodePath &p_filter, bool p_enable);
	void blend2_node_set_get_filtered_paths(const StringName &p_node, List<NodePath> *r_paths) const;
	bool blend2_node_is_path_filtered(const StringName &p_node, const NodePath &p_path) const;

	void blend3_node_set_amount(const StringName &p_node, float p_amount);
	float blend3_node_get_amount(const StringName &p_node) const;

	void blend4_node_set_amount(const StringName &p_node, const Point2 &p_amount);
	Point2 blend4_node_get_amount(const StringName &p_node) const;

	/* TIMESCALE/TIMESEEK NODES */

	void timescale_node_set_scale(const StringName &p_node, float p_scale);
	float timescale_node_get_scale(const StringName &p_node) const;

	void timeseek_node_seek(const StringName &p_node, float p_pos);

	/* TRANSITION NODE */

	void transition_node_set_input_count(const StringName &p_node, int p_inputs); // used for transition node
	int transition_node_get_input_count(const StringName &p_node) const;
	void transition_node_delete_input(const StringName &p_node, int p_input); // used for transition node

	void transition_node_set_input_auto_advance(const StringName &p_node, int p_input, bool p_auto_advance); // used for transition node
	bool transition_node_has_input_auto_advance(const StringName &p_node, int p_input) const;

	void transition_node_set_xfade_time(const StringName &p_node, float p_time); // used for transition node
	float transition_node_get_xfade_time(const StringName &p_node) const;

	void transition_node_set_current(const StringName &p_node, int p_current);
	int transition_node_get_current(const StringName &p_node) const;

	void node_set_pos(const StringName &p_node, const Vector2 &p_pos); //for display

	/* GETS */
	Point2 node_get_pos(const StringName &p_node) const; //for display

	NodeType node_get_type(const StringName &p_node) const;

	void get_node_list(List<StringName> *p_node_list) const;
	void remove_node(const StringName &p_node);

	Error connect(const StringName &p_src_node, const StringName &p_dst_node, int p_dst_input);
	bool is_connected(const StringName &p_src_node, const StringName &p_dst_node, int p_input) const;
	void disconnect(const StringName &p_src_node, int p_input);

	void set_base_path(const NodePath &p_path);
	NodePath get_base_path() const;

	void set_master_player(const NodePath &p_path);
	NodePath get_master_player() const;

	struct Connection {

		StringName src_node;
		StringName dst_node;
		int dst_input;
	};

	void get_connection_list(List<Connection> *p_connections) const;

	/* playback */

	void set_active(bool p_active);
	bool is_active() const;

	void reset();

	void recompute_caches();

	ConnectError get_last_error() const;

	void set_animation_process_mode(AnimationProcessMode p_mode);
	AnimationProcessMode get_animation_process_mode() const;

	void _set_process(bool p_process, bool p_force = false);

	void advance(float p_time);

	AnimationTreePlayer();
	~AnimationTreePlayer();
};

VARIANT_ENUM_CAST(AnimationTreePlayer::NodeType);
VARIANT_ENUM_CAST(AnimationTreePlayer::AnimationProcessMode);

#endif // ANIMATION_TREE_PLAYER_H