// SSPHH/Fluxions/Unicornfish/Viperfish/Hatchetfish/Sunfish/KASL/GLUT Extensions
// Copyright (C) 2017 Jonathan Metzgar
// All rights reserved.
//
// This program is free software : you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.If not, see <https://www.gnu.org/licenses/>.
//
// For any other type of licensing, please contact me at jmetzgar@outlook.com
#ifndef FLUXIONS_SIMPLE_MATERIALS_HPP
#define FLUXIONS_SIMPLE_MATERIALS_HPP

#include <fluxions_stdcxx.hpp>
#include <fluxions_fileio.hpp>
#include <fluxions_simple_texture.hpp>
#include <fluxions_resource_manager.hpp>
#include <fluxions_simple_property.hpp>

namespace Fluxions
{
	using namespace std;


	struct SimpleMaterial
	{
		Vector3f Kd;
		Vector3f Ks;
		Vector3f Ke;
		Vector3f Ka;
		Vector3f Tf; // Translucency;	// Tf
		float Tr = 0.0f; // TranslucencyLevel -- same as (1 - d)
		Vector3f Refract;
		Vector3f Opacity;
		float Ns = 0.0f; // Specular exponent [0 <= Ns <= 1000]
		float Ni = 0.0f;
		float d = 1.0f; // dissolved -- same as (1 - Tr)

		float PBm = 0.0f; // for roughness
		float PBk = 0.0f; // for metals
		float PBKdm = 0.0f; // for diffuse roughness (Oren-Nayer)
		float PBKsm = 0.0f; // for specular roughness (Cook-Torrance)
		float PBior = 0.0f; // for Fresnel reflection (Cook-Torrance)
		float PBGGXgamma = 0.11f; // for GGX BRDF (0.0 - 1.0 maps to 1.0 to 10.0 in the shader)
		string PBmap;

		float EmissionGlossiness;
		float ReflectFresnel;
		float RefractGlossiness;
		float ReflectGlossiness;
		float AnisotropyAmount;
		float AnisotropyRotation;
		Vector3f AttenuationColor;
		float AttenuationDistance;
		Vector3f ScatteringAlbedo;
		float MeanCosine;
		vector<string> RefractMode;
		bool HasRoundedCorners = false;
		float RoundedCorners;
		bool IsPortal = false;
		bool HasIesProfile = false;
		string IesProfileFilename;
		Matrix4f IesProfileMatrix;
		bool IesProfileKeepSharp;
		vector<string> Invisible;
		string map_Ka;
		string map_Kd;
		string map_Ks;
		string map_Ke;
		string map_d;
		string map_opacity;
		string map_Ns;
		string map_Ni;
		string map_Tr;// translucency;
		string map_Tf;//Tf translucencyLevel;
		string map_refract;
		string map_anisotropy;
		string map_anisorotation;
		string map_scatteringAlbedo;
		string map_attenuation;
		string map_normal;
		string map_bump;

		SimpleAssociativePropertyList Properties;
	};


	struct SimpleMap
	{
		string mapName;
		GLuint mapId;
		string pathname;
		string shader;
		GLuint textureId;
		GLuint samplerId;
		GLint unitId; // we're not using GLenum here because unitId can be < 0 and no overflow is expected.
		GLint map_loc;
		GLint map_mix_loc;
		SimpleTexture textureObject;
	};


	ostream & WriteMaterial(ostream &ostr, const SimpleMaterial &mtl);
	istream & ReadMaterial(istream &istr, SimpleMaterial &mtl);
	void SetMaterialDefaults(SimpleMaterial &mtl);


	struct SimpleMaterialLibrary
	{
		TResourceManager<SimpleMap> maps;
		TResourceManager<SimpleMaterial> mtls;
		FilePathInfo fpi;
		string name;

		SimpleMaterialLibrary() { }
		~SimpleMaterialLibrary() { }
	};


	class SimpleMaterialSystem
	{
	private:
		string defaultName = "<INVALIDMATERIAL>";
		string currentMtlLibName;
		GLuint currentMtlLibId = 0;
		string currentMtlName;
		GLuint currentMtlId = 0;

		SimpleMaterialLibrary *currentMtlLibPtr = nullptr;
		SimpleMaterial *currentMtlPtr = nullptr;

		TResourceManager<SimpleMaterialLibrary> mtllibs;
		TResourceManager<string> shaderMaps;

		map<string, string> maps_paths;
		string defaultMapPath = "<UNKNOWN>";

		void SynchronizeIds();
	public:
		SimpleMaterialSystem();
		~SimpleMaterialSystem();

		void Clear();

		auto begin() -> decltype(mtllibs.begin()) { return mtllibs.begin(); }
		auto end() -> decltype(mtllibs.end()) { return mtllibs.end(); }
		auto size() -> decltype(mtllibs.size()) { return mtllibs.size(); }

		bool Save(const string &path);
		bool Load(const string &mtllibName, const string &filename);
		bool Save(const string &mtllibName, const string &filename);

		SimpleMaterialLibrary *CreateLibrary(const string &name);
		SimpleMaterial *CreateMaterial(const string &name);

		void DeleteLibrary(const string &name);
		void DeleteMaterial(const string &name);
		void DeleteLibraryMaterial(const string &mtllibName, const string &mtlName);

		SimpleMaterialLibrary *SetLibrary(const string &name);
		SimpleMaterial *SetMaterial(const string &name);
		SimpleMaterial *SetLibraryMaterial(const string &mtllibName, const string &mtlName);
		const SimpleMaterial *GetLibraryMaterial(const string &mtllibName, const string &mtlName) const;
		SimpleMaterial *GetCurrentMaterial() { return currentMtlPtr; }

		const string & GetLibraryName();
		const string & GetMaterialName();
		const string & GetMaterialName(GLuint id);

		GLuint GetLibraryId();
		GLuint GetMaterialId();
		GLuint GetLibraryId(const string &name);
		GLuint GetMaterialId(const string &name);
		GLuint GetLibraryMaterialId(const string &mtllibName, const string &mtlName);

		bool AddMap(const string &path, const string &filename);
		bool AddMapShader(const string &name, const string &shader);
		void LoadMaps();
		SimpleMap *GetTextureMap(const string &name);
		const SimpleMap *GetTextureMap(const string &name) const;

		const string & GetMapPath(const string & mapName) const;
	};
}

#endif