#include "CKMaterial.hpp"
#include "../CKStateChunk.hpp"
#include "../CKContext.hpp"
#include "CKTexture.hpp"

namespace LibCmo::CK2::ObjImpls {

	CKMaterial::CKMaterial(CKContext* ctx, CK_ID ckid, CKSTRING name) :
		CKBeObject(ctx, ckid, name),
		// following init are gotten from SDK document.
		m_Diffuse(0.7f, 0.7f, 0.7f, 1.0f),
		m_Ambient(0.3f, 0.3f, 0.3f, 1.0f),
		m_Specular(0.5f, 0.5f, 0.5f, 1.0f), m_SpecularPower(0.0f),
		m_Emissive(0.0f, 0.0f, 0.0f, 1.0f),
		m_EnableTwoSided(false),
		m_Textures { nullptr, nullptr, nullptr, nullptr },
		m_TextureMinMode(VxMath::VXTEXTURE_FILTERMODE::VXTEXTUREFILTER_LINEAR), m_TextureMagMode(VxMath::VXTEXTURE_FILTERMODE::VXTEXTUREFILTER_LINEAR),
		m_SourceBlend(VxMath::VXBLEND_MODE::VXBLEND_ONE), m_DestBlend(VxMath::VXBLEND_MODE::VXBLEND_ZERO), m_EnableAlphaBlend(false),
		m_ShadeMode(VxMath::VXSHADE_MODE::VXSHADE_GOURAUD),
		m_FillMode(VxMath::VXFILL_MODE::VXFILL_SOLID),
		m_EnableAlphaTest(false),
		m_EnableZWrite(true),
		// following init are gotten from IDA.
		m_EnablePerspectiveCorrection(true),
		m_TextureBlendMode(VxMath::VXTEXTURE_BLENDMODE::VXTEXTUREBLEND_MODULATEALPHA),
		m_TextureAddressMode(VxMath::VXTEXTURE_ADDRESSMODE::VXTEXTURE_ADDRESSWRAP),
		m_ZFunc(VxMath::VXCMPFUNC::VXCMP_LESSEQUAL),
		m_AlphaFunc(VxMath::VXCMPFUNC::VXCMP_ALWAYS),
		m_Effect(VxMath::VX_EFFECT::VXEFFECT_NONE),
		m_TextureBorderColor(0),
		m_AlphaRef(0)
	{}

	CKMaterial::~CKMaterial() {}

	void CKMaterial::CheckPreDeletion() {
		CKBeObject::CheckPreDeletion();

		// check 4 textures
		for (auto& tex : m_Textures) {
			if (tex != nullptr && tex->IsToBeDeleted()) {
				tex = nullptr;
			}
		}
	}

	bool CKMaterial::Save(CKStateChunk* chunk, CKFileVisitor* file, CKDWORD flags) {
		bool suc = CKBeObject::Save(chunk, file, flags);
		if (!suc) return false;
		
		// save main data
		{
			chunk->WriteIdentifier(CK_STATESAVEFLAGS_MATERIAL::CK_STATESAVE_MATDATA);

			// 4 basic color and some power
			CKDWORD col;
			col = m_Diffuse.ToARGB();
			chunk->WriteStruct(col);
			col = m_Ambient.ToARGB();
			chunk->WriteStruct(col);
			col = m_Specular.ToARGB();
			chunk->WriteStruct(col);
			col = m_Emissive.ToARGB();
			chunk->WriteStruct(col);

			chunk->WriteStruct(m_SpecularPower);
			
			// write main texture
			chunk->WriteObjectPointer(m_Textures[0]);

			// misc data
			chunk->WriteStruct(m_TextureBorderColor);

			// write mix data 1
			// construct mix data, see Read for more info about this mix data
			CKDWORD mixdata = 0;
			mixdata |= static_cast<CKDWORD>(m_TextureAddressMode) & 0xF;
			mixdata <<= 4;
			mixdata |= static_cast<CKDWORD>(m_FillMode) & 0xF;
			mixdata <<= 4;
			mixdata |= static_cast<CKDWORD>(m_ShadeMode) & 0xF;
			mixdata <<= 4;
			mixdata |= static_cast<CKDWORD>(m_DestBlend) & 0xF;
			mixdata <<= 4;
			mixdata |= static_cast<CKDWORD>(m_SourceBlend) & 0xF;
			mixdata <<= 4;
			mixdata |= static_cast<CKDWORD>(m_TextureMagMode) & 0xF;
			mixdata <<= 4;
			mixdata |= static_cast<CKDWORD>(m_TextureMinMode) & 0xF;
			mixdata <<= 4;
			mixdata |= static_cast<CKDWORD>(m_TextureBlendMode) & 0xF;
			// write it
			chunk->WriteStruct(mixdata);

			// write mix data 2
			// construct it first, see Read for more info about this mix data
			mixdata = 0;
			mixdata |= static_cast<CKDWORD>(m_AlphaRef) & 0xFF;
			mixdata <<= 8;
			mixdata |= static_cast<CKDWORD>(m_AlphaFunc) & 0xFF;
			mixdata <<= 8;
			mixdata |= static_cast<CKDWORD>(m_ZFunc) & 0xFF;
			mixdata <<= 8;
			// sub mix flags
			CKDWORD mixflags = 0;
			if (m_EnableTwoSided) mixflags |= 0b1;
			if (m_EnableZWrite) mixflags |= 0b10;
			if (m_EnablePerspectiveCorrection) mixflags |= 0b100;
			if (m_EnableAlphaBlend) mixflags |= 0b1000;
			if (m_EnableAlphaTest) mixflags |= 0b10000;
			// merge into mix data
			mixdata |= mixflags & 0xFF;
			// write it
			chunk->WriteStruct(mixdata);

		}

		// write effect and extra texture.
		// it seems that extra textures only available when a valid effect existing
		if (m_Effect != VxMath::VX_EFFECT::VXEFFECT_NONE) {
			// we only support no-parameter effect, write it
			chunk->WriteIdentifier(CK_STATESAVEFLAGS_MATERIAL::CK_STATESAVE_MATDATA3);
			chunk->WriteStruct(m_Effect);

			// if have extra textures, write it
			if (m_Textures[1] != nullptr || m_Textures[2] != nullptr || m_Textures[3] != nullptr) {
				chunk->WriteIdentifier(CK_STATESAVEFLAGS_MATERIAL::CK_STATESAVE_MATDATA2);
				chunk->WriteObjectPointer(m_Textures[1]);
				chunk->WriteObjectPointer(m_Textures[2]);
				chunk->WriteObjectPointer(m_Textures[3]);
			}
		}

		chunk->SetClassId(CK_CLASSID::CKCID_MATERIAL);
		return true;
	}

	bool CKMaterial::Load(CKStateChunk* chunk, CKFileVisitor* file) {
		bool suc = CKBeObject::Load(chunk, file);
		if (!suc) return false;

		// clear textures
		for (auto& tex : m_Textures) {
			tex = nullptr;
		}

		// read main data
		if (chunk->SeekIdentifier(CK_STATESAVEFLAGS_MATERIAL::CK_STATESAVE_MATDATA)) {
			if (chunk->GetDataVersion() < CK_STATECHUNK_DATAVERSION::CHUNK_MAJORCHANGE_VERSION) {
				// MARK: old data process. i don't want to implement
				// because it is not related to my work. return false
				return false;
			} else {
				// 4 basic color and some power
				CKDWORD col;
				chunk->ReadStruct(col);
				m_Diffuse.FromARGB(col);
				chunk->ReadStruct(col);
				m_Ambient.FromARGB(col);
				chunk->ReadStruct(col);
				m_Specular.FromARGB(col);
				chunk->ReadStruct(col);
				m_Emissive.FromARGB(col);

				chunk->ReadStruct(m_SpecularPower);

				// main texture
				CKObject* tex = nullptr;
				chunk->ReadObjectPointer(tex);
				if (tex != nullptr && tex->GetClassID() == CK_CLASSID::CKCID_TEXTURE) {
					m_Textures[0] = static_cast<CKTexture*>(tex);
				}

				// misc data
				chunk->ReadStruct(m_TextureBorderColor);

				// mix data 1, including some blend enums
				// 32bit data. each 4 bit store a value. total 8 data.
				// HIGH >>> m_TextureAddressMode, m_FillMode, m_ShadeMode, m_DestBlend, m_SourceBlend, m_TextureMagMode, m_TextureMinMode, m_TextureBlendMode <<< LOW
				CKDWORD mixdata;
				chunk->ReadStruct(mixdata);
				m_TextureBlendMode = static_cast<VxMath::VXTEXTURE_BLENDMODE>(mixdata & 0xF);
				mixdata >>= 4;
				m_TextureMinMode = static_cast<VxMath::VXTEXTURE_FILTERMODE>(mixdata & 0xF);
				mixdata >>= 4;
				m_TextureMagMode = static_cast<VxMath::VXTEXTURE_FILTERMODE>(mixdata & 0xF);
				mixdata >>= 4;
				m_SourceBlend = static_cast<VxMath::VXBLEND_MODE>(mixdata & 0xF);
				mixdata >>= 4;
				m_DestBlend = static_cast<VxMath::VXBLEND_MODE>(mixdata & 0xF);
				mixdata >>= 4;
				m_ShadeMode = static_cast<VxMath::VXSHADE_MODE>(mixdata & 0xF);
				mixdata >>= 4;
				m_FillMode = static_cast<VxMath::VXFILL_MODE>(mixdata & 0xF);
				mixdata >>= 4;
				m_TextureAddressMode = static_cast<VxMath::VXTEXTURE_ADDRESSMODE>(mixdata & 0xF);

				// mix data 2, including enable flag and transparent data
				// 32bit data.
				// HIGH >>> 0xFFFF(m_AlphaRef) 0xFFFF(m_AlphaFunc) 0xFFFF(m_ZFunc) 0xFFFF(enable flags) <<< LOW
				// for enable flags, total 8 bit. only low 5 bit used.
				// HIGH >>> 0(not used) 0(not used) 0(not used) 1(m_EnableAlphaTest) 1(m_EnableAlphaBlend) 1(m_EnablePerspectiveCorrection) 1(m_EnableZWrite) 1(m_EnableTwoSided) <<< LOW
				chunk->ReadStruct(mixdata);
				m_EnableTwoSided = mixdata & 0b1;
				m_EnableZWrite = mixdata & 0b10;
				m_EnablePerspectiveCorrection = mixdata & 0b100;
				m_EnableAlphaBlend = mixdata & 0b1000;
				m_EnableAlphaTest = mixdata & 0b10000;
				mixdata >>= 8;
				m_ZFunc = static_cast<VxMath::VXCMPFUNC>(mixdata & 0xFF);
				mixdata >>= 8;
				m_AlphaFunc = static_cast<VxMath::VXCMPFUNC>(mixdata & 0xFF);
				mixdata >>= 8;
				m_AlphaRef = static_cast<CKBYTE>(mixdata & 0xFF);

			}
		}

		// extra texture data
		if (chunk->SeekIdentifier(CK_STATESAVEFLAGS_MATERIAL::CK_STATESAVE_MATDATA2)) {
			// read 3 extra texture
			CKObject* tex = nullptr;

			for (size_t i = 1; i < 4; ++i) {
				chunk->ReadObjectPointer(tex);
				if (tex != nullptr && tex->GetClassID() == CK_CLASSID::CKCID_TEXTURE) {
					m_Textures[i] = static_cast<CKTexture*>(tex);
				}
			}
		}

		// single effect
		if (chunk->SeekIdentifier(CK_STATESAVEFLAGS_MATERIAL::CK_STATESAVE_MATDATA3)) {
			chunk->ReadStruct(m_Effect);
		}

		// effect with parameter
		if (chunk->SeekIdentifier(CK_STATESAVEFLAGS_MATERIAL::CK_STATESAVE_MATDATA5)) {
			// MARK: i do not support CKParameter anymore.
			// so we downgrade it into single effect type.
			// hope this convertion will not break anything.

			// drop parameter id.
			CK_ID paramid;
			chunk->ReadObjectID(paramid);

			// read effect self
			chunk->ReadStruct(m_Effect);
		}

		return true;
	}

#pragma region Data Visitor

	const VxMath::VxColor& CKMaterial::GetDiffuse() const {
		return m_Diffuse;
	}
	void CKMaterial::SetDiffuse(const VxMath::VxColor& col) {
		m_Diffuse = col;
	}
	const VxMath::VxColor& CKMaterial::GetAmbient() const {
		return m_Ambient;
	}
	void CKMaterial::SetAmbient(const VxMath::VxColor& col) {
		m_Ambient = col;
	}
	const VxMath::VxColor& CKMaterial::GetSpecular() const {
		return m_Specular;
	}
	void CKMaterial::SetSpecular(const VxMath::VxColor& col) {
		m_Specular = col;
	}
	const VxMath::VxColor& CKMaterial::GetEmissive() const {
		return m_Emissive;
	}
	void CKMaterial::SetEmissive(const VxMath::VxColor& col) {
		m_Emissive = col;
	}
	CKFLOAT CKMaterial::GetSpecularPower() const {
		return m_SpecularPower;
	}
	void CKMaterial::SetSpecularPower(CKFLOAT val) {
		m_SpecularPower = val;
	}


	CKTexture* CKMaterial::GetTexture(CKDWORD idx) const {
		if (idx >= m_Textures.size()) return nullptr;
		return m_Textures[idx];
	}
	void CKMaterial::SetTexture(CKTexture* tex, CKDWORD idx) {
		if (idx >= m_Textures.size()) return;
		m_Textures[idx] = tex;
	}
	CKDWORD CKMaterial::GetTextureBorderColor() const {
		return m_TextureBorderColor;
	}
	void CKMaterial::SetTextureBorderColor(CKDWORD val) {
		m_TextureBorderColor = val;
	}


	VxMath::VXTEXTURE_BLENDMODE CKMaterial::GetTextureBlendMode() const {
		return m_TextureBlendMode;
	}
	void CKMaterial::SetTextureBlendMode(VxMath::VXTEXTURE_BLENDMODE val) {
		m_TextureBlendMode = val;
	}
	VxMath::VXTEXTURE_FILTERMODE CKMaterial::GetTextureMinMode() const {
		return m_TextureMinMode;
	}
	void CKMaterial::SetTextureMinMode(VxMath::VXTEXTURE_FILTERMODE val) {
		m_TextureMinMode = val;
	}
	VxMath::VXTEXTURE_FILTERMODE CKMaterial::GetTextureMagMode() const {
		return m_TextureMagMode;
	}
	void CKMaterial::SetTextureMagMode(VxMath::VXTEXTURE_FILTERMODE val) {
		m_TextureMagMode = val;
	}
	VxMath::VXTEXTURE_ADDRESSMODE CKMaterial::GetTextureAddressMode() const {
		return m_TextureAddressMode;
	}
	void CKMaterial::SetTextureAddressMode(VxMath::VXTEXTURE_ADDRESSMODE val) {
		m_TextureAddressMode = val;
	}


	VxMath::VXBLEND_MODE CKMaterial::GetSourceBlend() const {
		return m_SourceBlend;
	}
	void CKMaterial::SetSourceBlend(VxMath::VXBLEND_MODE val) {
		m_SourceBlend = val;
	}
	VxMath::VXBLEND_MODE CKMaterial::GetDestBlend() const {
		return m_DestBlend;
	}
	void CKMaterial::SetDestBlend(VxMath::VXBLEND_MODE val) {
		m_DestBlend = val;
	}
	VxMath::VXFILL_MODE CKMaterial::GetFillMode() const {
		return m_FillMode;
	}
	void CKMaterial::SetFillMode(VxMath::VXFILL_MODE val) {
		m_FillMode = val;
	}
	VxMath::VXSHADE_MODE CKMaterial::GetShadeMode() const {
		return m_ShadeMode;
	}
	void CKMaterial::SetShadeMode(VxMath::VXSHADE_MODE val) {
		m_ShadeMode = val;
	}


	bool CKMaterial::GetAlphaTestEnabled() const {
		return m_EnableAlphaTest;
	}
	void CKMaterial::SetAlphaTestEnabled(bool enabled) {
		m_EnableAlphaTest = enabled;
	}
	bool CKMaterial::GetAlphaBlendEnabled() const {
		return m_EnableAlphaBlend;
	}
	void CKMaterial::SetAlphaBlendEnabled(bool enabled) {
		m_EnableAlphaBlend = enabled;
	}
	bool CKMaterial::GetPerspectiveCorrectionEnabled() const {
		return m_EnablePerspectiveCorrection;
	}
	void CKMaterial::SetPerspectiveCorrectionEnabled(bool enabled) {
		m_EnablePerspectiveCorrection = enabled;
	}
	bool CKMaterial::GetZWriteEnabled() const {
		return m_EnableZWrite;
	}
	void CKMaterial::SetZWriteEnabled(bool enabled) {
		m_EnableZWrite = enabled;
	}
	bool CKMaterial::GetTwoSidedEnabled() const {
		return m_EnableTwoSided;
	}
	void CKMaterial::SetTwoSidedEnabled(bool enabled) {
		m_EnableTwoSided = enabled;
	}


	CKBYTE CKMaterial::GetAlphaRef() const {
		return m_AlphaRef;
	}
	void CKMaterial::SetAlphaRef(CKBYTE val) {
		m_AlphaRef = val;
	}
	VxMath::VXCMPFUNC CKMaterial::GetAlphaFunc() const {
		return m_AlphaFunc;
	}
	void CKMaterial::SetAlphaFunc(VxMath::VXCMPFUNC val) {
		m_AlphaFunc = val;
	}
	VxMath::VXCMPFUNC CKMaterial::GetZFunc() const {
		return m_ZFunc;
	}
	void CKMaterial::SetZFunc(VxMath::VXCMPFUNC val) {
		m_ZFunc = val;
	}
	VxMath::VX_EFFECT CKMaterial::GetEffect() const {
		return m_Effect;
	}
	void CKMaterial::SetEffect(VxMath::VX_EFFECT val) {
		m_Effect = val;
	}

#pragma endregion

}