/*************************************************************************/
/*  collada.h                                                            */
/*************************************************************************/
/*                       This file is part of:                           */
/*                           GODOT ENGINE                                */
/*                    http://www.godotengine.org                         */
/*************************************************************************/
/* Copyright (c) 2007-2014 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.                */
/*************************************************************************/
#ifdef TOOLS_ENABLED

#ifndef COLLADA_H
#define COLLADA_H


#include "scene/resources/material.h"
#include "globals.h"
#include "io/xml_parser.h"
#include "map.h"

class Collada {
public:

	enum ImportFlags {
		IMPORT_FLAG_SCENE=1,
		IMPORT_FLAG_ANIMATION=2
	};


	struct Image {

		String path;
	};

	struct Material {

		String name;
		String instance_effect;
	};


	struct Effect {

		String name;
		Map<String, Variant> params;

		struct Channel {

			int uv_idx;
			String texture;
			Color color;
			Channel() { uv_idx=0; }
		};

		Channel diffuse,specular,emission,bump;
		float shininess;
		bool found_double_sided;
		bool double_sided;

		String get_texture_path(const String& p_source,Collada& state) const;

		Effect() {
			diffuse.color=Color(1,1,1,1);
			double_sided=true;
			found_double_sided=false;
			shininess=40;

		}
	};

	struct CameraData {

		enum Mode {
			MODE_PERSPECTIVE,
			MODE_ORTHOGONAL
		};

		Mode mode;

		union {
			struct {
				float x_fov;
				float y_fov;
			} perspective;
			struct {
				float x_mag;
				float y_mag;
			} orthogonal;
		};

		float aspect;
		float z_near;
		float z_far;

		CameraData() {

			mode=MODE_PERSPECTIVE;
			perspective.y_fov=0;
			perspective.x_fov=0;
			aspect=1;
			z_near=0.1;
			z_far=100;
		}
	};

	struct LightData {

		enum Mode {
			MODE_AMBIENT,
			MODE_DIRECTIONAL,
			MODE_OMNI,
			MODE_SPOT
		};

		Mode mode;

		Color color;

		float constant_att;
		float linear_att;
		float quad_att;

		float spot_angle;
		float spot_exp;

		LightData() {

			mode=MODE_AMBIENT;
			color=Color(1,1,1,1);
			constant_att=0;
			linear_att=0;
			quad_att=0;

			spot_angle=45;
			spot_exp=1;
		}
	};


	struct MeshData {


		String name;
		struct Source {

			Vector<float> array;
			int stride;

		};

		Map<String,Source> sources;

		struct Vertices {

			Map<String,String> sources;
		};

		Map<String,Vertices> vertices;

		struct Primitives {

			struct SourceRef {

				String source;
				int offset;


			};

			String material;
			Map<String,SourceRef> sources;
			Vector<float> polygons;
			Vector<float> indices;
			int count;
			int vertex_size;
		};

		Vector<Primitives> primitives;

		bool found_double_sided;
		bool double_sided;

		MeshData() { found_double_sided=false; double_sided=true; }
	};

	struct CurveData {


		String name;
		bool closed;

		struct Source {

			Vector<String> sarray;
			Vector<float> array;
			int stride;
		};

		Map<String,Source> sources;


		Map<String,String> control_vertices;

		CurveData() {

			closed=false;
		}

	};
	struct SkinControllerData {

		String base;
		bool use_idrefs;

		Transform bind_shape;

		struct Source {

			Vector<String> sarray; //maybe for names
			Vector<float> array;
			int stride;
			Source() {
				stride=1;
			}
		};

		Map<String,Source> sources;

		struct Joints {

			Map<String,String> sources;
		} joints;

		struct Weights {

			struct SourceRef {

				String source;
				int offset;


			};

			String material;
			Map<String,SourceRef> sources;
			Vector<float> sets;
			Vector<float> indices;
			int count;
		} weights;

		Map<String,Transform> bone_rest_map;

		SkinControllerData() { use_idrefs=false; }
	};


	struct MorphControllerData {

		String mesh;
		String mode;

		struct Source {

			int stride;
			Vector<String> sarray; //maybe for names
			Vector<float> array;
			Source() { stride=1; }
		};

		Map<String,Source> sources;

		Map<String,String> targets;
		MorphControllerData() {  }
	};


	struct Vertex {

		int idx;
		Vector3 vertex;
		Vector3	normal;
		Vector3 uv;
		Vector3 uv2;
		Plane tangent;
		Color color;
		struct Weight {
			int bone_idx;
			float weight;
			bool operator<(const Weight w) const { return weight>w.weight; } //heaviest first

		};

		Vector<Weight> weights;

		void fix_weights() {

			weights.sort();
			if (weights.size()>4) {
				//cap to 4 and make weights add up 1
				weights.resize(4);
				float total=0;
				for(int i=0;i<4;i++)
					total+=weights[i].weight;
				if (total)
					for(int i=0;i<4;i++)
						weights[i].weight/=total;

			}
		}

		void fix_unit_scale(Collada &state);

		bool operator<(const Vertex& p_vert) const {

			if (vertex==p_vert.vertex) {
				if(normal==p_vert.normal) {
					if(uv==p_vert.uv) {
						if(uv2==p_vert.uv2) {
							return (color<p_vert.color);
						} else
							return (uv2<p_vert.uv2);
					} else
						return (uv<p_vert.uv);
				} else
					return (normal<p_vert.normal);
			} else
				return vertex<p_vert.vertex;

		}
	};
	struct Node {

		enum Type {

			TYPE_NODE,
			TYPE_JOINT,
			TYPE_SKELETON, //this bone is not collada, it's added afterwards as optimization
			TYPE_LIGHT,
			TYPE_CAMERA,
			TYPE_GEOMETRY
		};


		struct XForm {

			enum Op {
				OP_ROTATE,
				OP_SCALE,
				OP_TRANSLATE,
				OP_MATRIX,
				OP_VISIBILITY
			};

			String id;
			Op op;
			Vector<float> data;
		};

		Type type;

		String name;
		String id;
		bool noname;
		Vector<XForm> xform_list;
		Transform default_transform;
		Transform post_transform;
		Vector<Node*> children;

		Node* parent;

		Transform compute_transform(Collada &state) const;
		Transform get_global_transform() const;
		Transform get_transform() const;

		bool ignore_anim;


		Node() {noname=false; type=TYPE_NODE; parent=NULL; ignore_anim=false;  }
		virtual ~Node() { for(int i=0;i<children.size();i++) memdelete( children[i] ); };

	};

	struct NodeSkeleton : public Node {


		NodeSkeleton() { type=TYPE_SKELETON; }
	};

	struct NodeJoint : public Node {

		NodeSkeleton *owner;
		String sid;
		NodeJoint() { type=TYPE_JOINT; owner=NULL; }
	};


	struct NodeGeometry : public Node {

		bool controller;
		String source;

		struct Material {
			String target;
		};

		Map<String,Material> material_map;
		Vector<String> skeletons;

		NodeGeometry() { type=TYPE_GEOMETRY; }
	};

	struct NodeCamera : public Node {

		String camera;

		NodeCamera() { type=TYPE_CAMERA; }
	};

	struct NodeLight : public Node {

		String light;

		NodeLight() { type=TYPE_LIGHT; }
	};


	struct VisualScene {

		String name;
		Vector<Node*> root_nodes;

		~VisualScene() { for(int i=0;i<root_nodes.size();i++) memdelete( root_nodes[i] ); }
	};


	struct AnimationClip {

		String name;
		float begin;
		float end;
		Vector<String> tracks;

		AnimationClip() { begin=0; end=1; }
	};

	struct AnimationTrack {

		String id;
		String target;
		String param;
		String component;
		bool property;

		enum InterpolationType {
			INTERP_LINEAR,
			INTERP_BEZIER
		};

		struct Key {

			enum Type {
				TYPE_FLOAT,
				TYPE_MATRIX
			};

			float time;
			Vector<float> data;
			Point2 in_tangent;
			Point2 out_tangent;
			InterpolationType interp_type;

			Key() { interp_type=INTERP_LINEAR; }
		};


		Vector<float> get_value_at_time(float p_time);

		Vector<Key> keys;

		AnimationTrack() { property=false; }
	};


	/****************/
	/* IMPORT STATE */
	/****************/


	struct State {


		int import_flags;

		float unit_scale;
		Vector3::Axis up_axis;
		bool z_up;

		struct Version {

			int major,minor,rev;

			bool operator<(const Version& p_ver) const { return (major==p_ver.major)?((minor==p_ver.minor)?(rev<p_ver.rev):minor<p_ver.minor):major<p_ver.major; }
			Version(int p_major=0,int p_minor=0,int p_rev=0) { major=p_major; minor=p_minor; rev=p_rev; }
		} version;


		Map<String,CameraData> camera_data_map;
		Map<String,MeshData> mesh_data_map;
		Map<String,LightData> light_data_map;
		Map<String,CurveData> curve_data_map;


		Map<String,String> mesh_name_map;
		Map<String,String> morph_name_map;
		Map<String,String> morph_ownership_map;
		Map<String,SkinControllerData> skin_controller_data_map;
		Map<String,MorphControllerData> morph_controller_data_map;



		Map<String,Image > image_map;
		Map<String,Material> material_map;
		Map<String,Effect> effect_map;

		Map<String,VisualScene> visual_scene_map;
		Map<String,Node*> scene_map;
		Set<String> idref_joints;
		//Map<String,NodeJoint*> bone_map;

		Map<String,Transform> bone_rest_map;

		String local_path;
		String root_visual_scene;
		String root_physics_scene;

		Vector<AnimationClip> animation_clips;
		Vector<AnimationTrack> animation_tracks;
		Map<String,Vector<int> > referenced_tracks;
		Map<String,Vector<int> > by_id_tracks;

		float animation_length;

		State() { unit_scale=1.0; up_axis=Vector3::AXIS_Y;  import_flags=0; animation_length=0; }
	} state;


	Error load(const String& p_path, int p_flags=0);

	Collada();

	Transform fix_transform(const Transform& p_transform);

	Transform get_root_transform() const;

	int get_uv_channel(String p_name);

private: // private stuff

	Map<String,int> channel_map;

	void _parse_asset(XMLParser& parser);
	void _parse_image(XMLParser& parser);
	void _parse_material(XMLParser& parser);
	void _parse_effect_material(XMLParser& parser,Effect &effect,String &id);
	void _parse_effect(XMLParser& parser);
	void _parse_camera(XMLParser& parser);
	void _parse_light(XMLParser& parser);
	void _parse_animation_clip(XMLParser& parser);

	void _parse_mesh_geometry(XMLParser& parser,String p_id,String p_name);
	void _parse_curve_geometry(XMLParser& parser,String p_id,String p_name);

	void _parse_skin_controller(XMLParser& parser,String p_id);
	void _parse_morph_controller(XMLParser& parser, String id);
	void _parse_controller(XMLParser& parser);

	Node* _parse_visual_instance_geometry(XMLParser& parser);
	Node* _parse_visual_instance_camera(XMLParser& parser);
	Node* _parse_visual_instance_light(XMLParser& parser);

	Node* _parse_visual_node_instance_data(XMLParser& parser);
	Node* _parse_visual_scene_node(XMLParser& parser);
	void _parse_visual_scene(XMLParser& parser);

	void _parse_animation(XMLParser& parser);
	void _parse_scene(XMLParser& parser);
	void _parse_library(XMLParser& parser);


	Variant _parse_param(XMLParser& parser);
	Vector<float> _read_float_array(XMLParser& parser);
	Vector<String> _read_string_array(XMLParser& parser);
	Transform _read_transform(XMLParser& parser);

	void _joint_set_owner(Collada::Node *p_node, NodeSkeleton *p_owner);
	void _create_skeletons(Collada::Node **p_node);
	void _find_morph_nodes(VisualScene *p_vscene,Node *p_node);
	bool _remove_node(Node *p_parent,Node *p_node);
	void _remove_node(VisualScene *p_vscene,Node *p_node);
	void _merge_skeletons(VisualScene *p_vscene,Node *p_node);
	bool _optimize_skeletons(VisualScene *p_vscene,Node *p_node);


	bool _move_geometry_to_skeletons(VisualScene *p_vscene,Node *p_node,List<Node*> *p_mgeom);



	void _optimize();


};

#endif // COLLADA_H

#endif