#pragma once

#include "dvc_config.h"
#include "dvc_pre_declare.h"
#include "math/dvc_vector2.h"
#include "math/dvc_vector3.h"
#include "math/dvc_vector4.h"
#include "math/dvc_matrix3.h"
#include "math/dvc_matrix4.h"
#include "dvc_texture.h"

DV_CORE_BEGIN_NAMESPACE

class DV_CORE_API Material
{
public:
	typedef std::variant<int32_t, float32_t, fVector2, fVector3, fVector4, fMatrix3, fMatrix4, TextureInfo> Value;

	struct Param
	{
		enum ParamType
		{
			PF_Int32,
			PT_Float,
			PT_Float2,
			PT_Float3,
			PT_Float4,
			PT_Matrix3,
			PT_Matrix4,
			PT_Texture,
		};
		std::string name;
		ParamType type;
		Value value;

		Param() = delete;
		Param(int32_t v) : type(PF_Int32), value(v) {  }
		Param(float32_t v) : type(PT_Float), value(v) {  }
		Param(const fVector2& v) : type(PT_Float2), value(v) {}
		Param(const fVector3& v) : type(PT_Float3), value(v) {}
		Param(const fVector4& v) : type(PT_Float4), value(v) {}
		Param(const fMatrix3& v) : type(PT_Matrix3), value(v) {}
		Param(const fMatrix4& v) : type(PT_Matrix4), value(v) {}
		Param(const TextureInfo& v) : type(PT_Texture), value(v) {}
	};
	typedef std::map<std::string, Param> ParamMap;

public:
	template<typename T>
	bool setParam(const char* name, const T& value)
	{
		ParamMap::iterator it = m_params.find(name);
		if(it==m_params.end() || (!std::holds_alternative<T>(it->second.value)))
		{
			return false;
		}

		it->second.value = value;
		return true;
	}

	template<typename T>
	bool getParam(const char* name, T& value) const
	{
		ParamMap::const_iterator it = m_params.find(name);
		if(it==m_params.end() || (!std::holds_alternative<T>(it->second.value)))
		{
			return false;
		}

		value = std::get<T>(it->second.value);
		return true;
	}

public:
	int32_t getID(void) const { return m_id; }

	VertexShaderInterface* getVertexShader() const { 
		return m_vertexShader; 
	}

	FragementShaderInterface* getFragementShader() const { 
		return m_fragementShader; 
	}

	virtual bool setupMaterial();
	virtual bool pickupParam(const davinci::MaterialConstPtr otherMaterial) { 
		return true; 
	}

protected:
	void setVertexShader(const char* szShaderFile, const char* vertexShaderName);
	void setFragementShader(const char* szShaderFile, const char* fragementShaderName);

	template<typename T>
	bool registerParam(const char* name, const T& defaultValue) {
		if (m_params.find(name) != m_params.end()) return false;
		m_params.insert(std::make_pair(name, Param(defaultValue)));
		return true;
	}

protected:
	int32_t m_id;
	std::string m_name;

	VertexShaderInterface* m_vertexShader = nullptr;
	FragementShaderInterface* m_fragementShader = nullptr;

	std::string m_vertexshaderFile;
	std::string m_vertexShaderName;

	std::string m_fragementShaderFile;
	std::string m_fragementShaderName;

	ParamMap m_params;
public:
	Material(int32_t id, const char* name);
	~Material();
};

DV_CORE_END_NAMESPACE