#ifndef OSGINTROSPECTION_TYPE_
#define OSGINTROSPECTION_TYPE_

#include <osgIntrospection/Export>
#include <osgIntrospection/Exceptions>
#include <osgIntrospection/Value>
#include <osgIntrospection/CustomAttributeProvider>

#include <string>
#include <typeinfo>
#include <vector>
#include <map>

namespace osgIntrospection
{

	// forward declarations
	class MethodInfo;
	class PropertyInfo;
	class ParameterInfo;
	class ReaderWriter;

	// typedefs for member info lists
	typedef std::vector<const MethodInfo *> MethodInfoList;	
	typedef std::vector<const PropertyInfo *> PropertyInfoList;	
	typedef std::vector<const ParameterInfo *> ParameterInfoList;

	// typedef for enum label map
	typedef std::map<int, std::string> EnumLabelMap;

	/// Base class for instance creators. An instance creator is
	/// a lightweight object that creates a Value containing an
	/// instance of some type. Every non-abstract Type object has
	/// an instance creator that creates instances of that type.
	/// This is an abstract interface, it must be derived to
	/// provide the actual implementation of createInstance().
	struct InstanceCreatorBase
	{
		virtual Value createInstance() const = 0;
	};

	/// This is an instance creator to be used with types that ought to
	/// be created on the heap, for example all classes derived from
	/// osg::Referenced.
	template<typename T>
	struct InstanceCreator: public InstanceCreatorBase
	{
		Value createInstance() const
		{
			return new T();
		}
	};

	/// This is an instance creator to be used with types that can be
	/// created on the stack (for example: int, std::string, or other
	/// possibly small user-defined structs or classes).
	template<typename T>
	struct ValueInstanceCreator: public InstanceCreatorBase
	{
		Value createInstance() const
		{
			return T();
		}
	};

	/// Objects of class Type are used to maintain information about
	/// reflected types. They also provide a number of services, like
	/// instance creation and dynamic calling of methods.
	/// All details about the data type being described are available
	/// at runtime, provided that the type was defined (and not just
	/// declared) through a Reflector class.
	/// It is not possible to modify a Type object once it has been
	/// created, unless you are a class derived from Reflector (which
	/// has firm friendship with this class).
	class OSGINTROSPECTION_EXPORT Type: public CustomAttributeProvider
	{
	public:
		/// Destructor. Note that this class is not meant to be subclassed.
		~Type();

		/// Returns a reference to the std::type_info instance associated 
		/// to this Type.
		inline const std::type_info &getStdTypeInfo() const;

		/// Returns true if this Type is defined, false if it's just 
		/// declared. See class Reflector if you want to create a new Type.
		inline bool isDefined() const;

		/// Returns the name of the reflected type.
		inline const std::string &getName() const;

		/// Returns the namespace of the reflected type.
		inline const std::string &getNamespace() const;

		/// Returns the qualified name of the reflected type. The qualified 
		/// name is formed by the namespace, if present, plus other modifiers 
		/// like 'const' and/or '*' (pointer) where applicable.
		inline std::string getQualifiedName() const;

		/// Returns the number of base types.
		/// This number is zero if the type is not derived from any other 
		/// type.
		inline int getNumBaseTypes() const;

		/// Returns the i-th base type.
		inline const Type &getBaseType(int i) const;

		/// Returns whether the reflected type is abstract.
		inline bool isAbstract() const;

		/// Returns whether the reflected type is "atomic", that is
		/// it can be rendered to and decoded from a stream directly.
		inline bool isAtomic() const;

		/// Returns whether the reflected type is an enumeration.
		inline bool isEnum() const;

		/// Returns whether the reflected type is the type void.
		inline bool isVoid() const;

		/// Returns true if the reflected type is a pointer, false otherwise.
		inline bool isPointer() const;

		/// Returns true if the reflected type is a pointer AND it is const, 
		/// false otherwise.
		inline bool isConstPointer() const;

		/// Returns true if the reflected type is a pointer AND it is not 
		/// const, false otherwise.
		inline bool isNonConstPointer() const;

		/// Returns the pointed type. If the reflected type is not a pointer,
		/// the object returned is typeof(void).
		inline const Type &getPointedType() const;

		/// Returns the list of properties defined for this type. The list
		/// does not include properties inherited from base types.
		inline const PropertyInfoList &getProperties() const;

		/// Fills a list of properties that are either defined in this Type 
		/// or in inherited types.
		void getAllProperties(PropertyInfoList &props) const;

		/// Returns the list of methods defined for this type. The list
		/// does not include methods inherited from base types.
		inline const MethodInfoList &getMethods() const;

		/// Fills a list of methods that are either defined in this Type 
		/// or in inherited types.
		void getAllMethods(MethodInfoList &methods) const;

		/// Returns the map of enumeration labels. If the type is not an
		/// enumeration, an empty map is returned.
		inline const EnumLabelMap &getEnumLabels() const;

		/// Searches for a method that can be called with the given list of 
		/// arguments without raising type conversion errors. If more than
		/// one method are suitable for calling, the best match is returned.
		const MethodInfo *getCompatibleMethod(const std::string &name, const ValueList &values, bool inherit) const;

		/// Searches for a method whose parameters match exactly the given 
		/// list of parameter descriptions.
		const MethodInfo *getMethod(const std::string &name, const ParameterInfoList &params, bool inherit) const;

		/// Searches for a property given its name, type and list of indices.
		/// Only exact matches are returned.
		const PropertyInfo *getProperty(const std::string &name, const Type &ptype, const ParameterInfoList &indices, bool inherit) const;

		/// Searches for a suitable method and invokes it with the given list 
		/// of arguments (const instance).
		Value invokeMethod(const std::string &name, const Value &instance, ValueList &args, bool inherit) const;

		/// Searches for a suitable method and invokes it with the given list 
		/// of arguments.
		Value invokeMethod(const std::string &name, Value &instance, ValueList &args, bool inherit) const;

		/// Returns whether the reflected type is derived from another type.
		bool isSubclassOf(const Type &type) const;

		/// Returns the instance of the reader/writer object assigned to 
		/// this type, if any. Otherwise it returns the null pointer.
		inline const ReaderWriter *getReaderWriter() const;

		/// Creates an instance of the reflected type. The returned Value 
		/// can be casted to T*, where T is the reflected type. If the type 
		///	is abstract, an exception is thrown.
		inline Value createInstance() const;

	protected:
		Type(const std::type_info &ti)
		:	ti_(ti), 
			is_const_(false), 
			pointed_type_(0), 
			is_defined_(false), 
			icb_(0), 
			rw_(0) 
		{
		}

		// throws an exception if the type is not defined.
		void check_defined() const;

		virtual void getInheritedProviders(CustomAttributeProviderList &providers) const;

		void set_instance_creator(const InstanceCreatorBase *icb)
		{
			delete icb_;
			icb_ = icb;
		}

	private:
		template<typename C> friend class Reflector;
		friend class Reflection;

		Type(const Type &copy): CustomAttributeProvider(copy), ti_(copy.ti_) {}

		const std::type_info &ti_;

		std::string name_;
		std::string namespace_;

		typedef std::vector<const Type *> TypeList;
		TypeList base_;

		bool is_const_;
		const Type *pointed_type_;

		PropertyInfoList props_;
		MethodInfoList methods_;

		EnumLabelMap labels_;
		bool is_defined_;

		const InstanceCreatorBase *icb_;
		const ReaderWriter *rw_;
	};

	// OPERATORS

	/// Equality test operator. Returns true if the two instances of Type
	/// describe the same type, false otherwise.
	inline bool operator==(const Type &t1, const Type &t2)
	{
		return (t1.getStdTypeInfo() == t2.getStdTypeInfo()) != 0;
	}

	/// Inequality test operator. Returns false if the two instances of Type
	/// describe the same type, true otherwise.
	inline bool operator!=(const Type &t1, const Type &t2)
	{
		return (t1.getStdTypeInfo() != t2.getStdTypeInfo()) != 0;
	}

	/// Less than operator. Returns true if the first type comes before the
	/// second one. The actual ordering is implementation-dependent.
	inline bool operator<(const Type &t1, const Type &t2)
	{
		return (t1.getStdTypeInfo().before(t2.getStdTypeInfo())) != 0;
	}

	/// Greater than or equal to operator. Returns !operator<().
	inline bool operator>=(const Type &t1, const Type &t2)
	{
		return !operator<(t1, t2);
	}

	// INLINE METHODS

	inline void Type::check_defined() const
	{
		if (!is_defined_)
			throw TypeNotDefinedException(ti_);
	}

	inline const std::type_info &Type::getStdTypeInfo() const
	{
		return ti_;
	}

	inline const std::string &Type::getName() const
	{
		check_defined();
		return name_;
	}

	inline const std::string &Type::getNamespace() const
	{
		check_defined();
		return namespace_;
	}

	inline std::string Type::getQualifiedName() const
	{
		check_defined();
		std::string qname;
		if (is_const_) qname = "const ";
		if (!namespace_.empty()) 
		{
			qname.append(namespace_);
			qname.append("::");
		}
		qname.append(name_);
		if (pointed_type_)
			qname.append(" *");
		return qname;
	}

	inline int Type::getNumBaseTypes() const
	{
		check_defined();
		return static_cast<int>(base_.size());
	}

	inline bool Type::isConstPointer() const
	{
		check_defined();
		return is_const_ && pointed_type_;
	}

	inline bool Type::isNonConstPointer() const
	{
		check_defined();
		return !is_const_ && pointed_type_;
	}

	inline bool Type::isAbstract() const
	{
		check_defined();
		return icb_ == 0;
	}

	inline bool Type::isAtomic() const
	{
		check_defined();
		return rw_ != 0;
	}

	inline const PropertyInfoList &Type::getProperties() const
	{
		check_defined();
		return props_;
	}

	inline const MethodInfoList &Type::getMethods() const
	{
		check_defined();
		return methods_;
	}

	inline bool Type::isPointer() const
	{
		check_defined();
		return pointed_type_ != 0;
	}

	inline bool Type::isVoid() const
	{
		return (ti_ == typeid(void)) != 0;
	}

	inline const Type &Type::getPointedType() const
	{
		check_defined();
		if (pointed_type_)
			return *pointed_type_;
		return Reflection::type_void();
	}

	inline bool Type::isEnum() const
	{
		check_defined();
		return !labels_.empty();
	}

	inline const EnumLabelMap &Type::getEnumLabels() const
	{
		check_defined();
		return labels_;
	}

	inline bool Type::isDefined() const
	{
		return is_defined_;
	}

	inline const ReaderWriter *Type::getReaderWriter() const
	{
		check_defined();
		return rw_;
	}

	inline const Type &Type::getBaseType(int i) const
	{
		check_defined();
		return *base_.at(i);
	}

	inline Value Type::createInstance() const
	{
		check_defined();
		if (!icb_)
			throw TypeIsAbstractException(ti_);
		return icb_->createInstance();
	}

}

#endif