#include "ValueMapRenderer.h"
#include"clsXML.h"
#include "clsJson.h"
#include "clsPtree.h"
#include"ValueMapRendererComponent.h"
#include<map>
using namespace std;
#include"clsCrSurf.h"
#include"DataCollection.h"
#include"clsUtil.h"
#include <boost/dll/alias.hpp> // for BOOST_DLL_ALIAS
#include <boost/filesystem.hpp>
#include <boost/function.hpp>
#include <boost/make_shared.hpp>
#include <boost/algorithm/string.hpp>
namespace DmapCore_30
{

	ValueMapRenderer::ValueMapRenderer()
	{
		m_sTag = "";
		m_pDefaultSymbol = NULL;
		m_sField = "";
		m_vComponents = {};
		m_simpleRenderer = true;
	}
	ValueMapRenderer::~ValueMapRenderer()
	{
		if (m_pDefaultSymbol)
			m_pDefaultSymbol->Release();
		int length = (int)m_vComponents.size();
		if (length)
		{
			for (int i = 0; i < length; i++)
				m_vComponents[i]->Release();
			m_vComponents.clear();
		}
	}
	ValueMapRenderer* ValueMapRenderer::CreateNew()
	{
		ValueMapRenderer * dest = new ValueMapRenderer();
		return dest;
	}
	bool ValueMapRenderer::Parse(boost::property_tree::ptree &pt, AppendBuffer *f)
	{
	//	if (!node && !f)return false;

		//clsXML clsX(f, "VALUEMAPRENDERER");
		clsXML::XMLAttrParse(pt, f, &m_sField, "lookupfield");
		//clsX.closeProperties();

		for (auto ptchild = pt.begin(); ptchild != pt.end(); ++ptchild)
			{
				string sz = ptchild->first;
				
				if (boost::iequals(sz, "OTHER"))
				{
					for(auto ptchild2 = ptchild->second.begin(); ptchild2 != ptchild->second.end(); ptchild2++)
					{
						if(ptchild2->first != "<xmlattr>")
						{
							clsXML::XMLParse(ptchild2->first,ptchild2->second,  &m_pDefaultSymbol);
							break;
						}
					}
					
				}
				else if (boost::iequals(sz, "EXACT")) 
				{
					string sValue = clsXML::XMLGetPropByString(ptchild->second, "value");
					//auto ptchild2 = ptchild->second.begin();
					for(auto ptchild2 = ptchild->second.begin(); ptchild2 != ptchild->second.end(); ptchild2++)
					{
						if (ptchild2->first != "<xmlattr>")
						{
							Renderer *pSymbol = NULL;
							clsXML::XMLParse(ptchild2->first, ptchild2->second, &pSymbol);
							ValueMapRendererComponent *vmrc = new ValueMapRendererComponent(pSymbol, sValue);
							m_vComponents.push_back(vmrc); //引用只需要一份, 无需AddRef
							break;
						}
					}
				}
				else{ ; }
			}
		return true;
	}

	bool ValueMapRenderer::ParsePtree( boost::property_tree::ptree &pt)
	{
		 char buff[300] = {0};
		boost::property_tree::ptree ptRenderer;
		ptRenderer.add("lookupfield",m_sField);
	
		int length = (int)m_vComponents.size();
		for (int i = 0; i < length; i++)
		{
			boost::property_tree::ptree ptNode;
			ValueMapRendererComponent* vmrc = m_vComponents[i];
	        ptNode.add("value",vmrc->GetValue());
			if(vmrc->m_pSymbol)
			{
				vmrc->m_pSymbol->ParsePtree(ptNode);
			}
			ptRenderer.add_child("EXACT",ptNode);
		}

		if (m_pDefaultSymbol)
		{
			boost::property_tree::ptree ptNode;
			this->m_pDefaultSymbol->ParsePtree(ptNode);
			ptRenderer.add_child("OTHER",ptNode);
		}
		return true;
	}

   void  ValueMapRenderer::ToJson(AppendBuffer *ab)
   {
	    char buff[300] = {0};
		//char resultbuff[5000] = {0};
		sprintf(buff, R"("VALUEMAPRENDERER":{"lookupfield":"%s","EXACT":[)",m_sField.c_str());
		//strcat(resultbuff,buff);
		ab->AppendString(buff);
		int length = (int)m_vComponents.size();
		for (int i = 0; i < length; i++)
		{
			if(i>0) 
			{
				ab->AppendString(",");
			}

			ValueMapRendererComponent* vmrc = m_vComponents[i];
			ab->AppendString("{");
			sprintf(buff, R"("value":"%s",)",vmrc->m_sValue.c_str());
			ab->AppendString(buff);
			if(vmrc->m_pSymbol)
			{
				vmrc->m_pSymbol->ToJson(ab);
			}
			ab->AppendString("}");
		}
		ab->AppendString("]");
		//strcat(resultbuff, "]");

		if (m_pDefaultSymbol)
		{
			ab->AppendString(",\"OTHER\":{");
			this->m_pDefaultSymbol->ToJson(ab);
			ab->AppendString("}");
		}
		ab->AppendString("}");
   }


	int ValueMapRenderer::RendererType()
	{
		return dmapValueMapRenderer;
	}
	const char* ValueMapRenderer::GetTag()
	{
		return m_sTag.c_str();
	}
	bool ValueMapRenderer::SetTag(const char* sTag)
	{
		if (!sTag)
			return false;
		m_sTag = sTag;
		return true;
	}
	Renderer* ValueMapRenderer::GetDefaultSymbol()
	{
		if (m_pDefaultSymbol)m_pDefaultSymbol->AddRef();
		return m_pDefaultSymbol;
	}
	bool ValueMapRenderer::SetDefaultSymbol(Renderer* defaultSymbol)
	{
		if (!defaultSymbol)
		{
			m_pDefaultSymbol = defaultSymbol;
			return true;
		}

		//int renType = defaultSymbol->RendererType();
		//AddRef 必须先执行, 有可能传入的样式和原来的样式是同一个指针, 先 Release 会内存错误
		defaultSymbol->AddRef();
		if (m_pDefaultSymbol)
			m_pDefaultSymbol->Release();
		m_pDefaultSymbol = defaultSymbol;
		return true;
	}
	const char* ValueMapRenderer::GetField()
	{
		return m_sField.c_str();
	}
	bool ValueMapRenderer::SetField(const char* sField)
	{
		if (!sField)
			return false;
		m_sField = sField;
		return true;
	}
	int ValueMapRenderer::GetComponentCount()
	{
		int length = (int)m_vComponents.size();
		return length;
	}
	ValueMapRendererComponent* ValueMapRenderer::GetComponent(int index)
	{
		//GetIndexP(index,m_vComponents);
		int length = (int)(m_vComponents.size());

		if (index < 0 || index >= length)
			return NULL;
		m_vComponents[index]->AddRef();
		return m_vComponents[index];

	}
	bool ValueMapRenderer::SetComponent(int index, ValueMapRendererComponent* component)
	{
		//SetIndexP(index, component, m_vComponents);
		if (!component)return false;
		int length = (int)(m_vComponents.size());
		if (index >= length)
			return false;
		component->AddRef();
		if (index < 0)
			m_vComponents.push_back(component);
		else
		{
			m_vComponents[index]->Release();
			m_vComponents[index] = component;
		}
		return true;
	}
	bool ValueMapRenderer::AddComponent(ValueMapRendererComponent* component)
	{
		return this->SetComponent(-1, component);
	}
	bool ValueMapRenderer::RemoveComponent(int index)
	{
		int length = (int)(m_vComponents.size());
		if (index < 0 || index >= length)
			return false;

		m_vComponents[index]->Release();
		m_vComponents.erase(m_vComponents.begin() + index);
		return true;
	}
	bool ValueMapRenderer::ClearComponents()
	{
		int length = (int)(m_vComponents.size());

		for (int i = 0; i < length; i++)
			m_vComponents[i]->Release();
		m_vComponents.clear();
		return true;
	}
	bool ValueMapRenderer::DrawData(clsCrSurf* pClsCS, DataCollection* data, bool drawSimpleData, char* pFlag)
	{
		//找出 field 在 data 中字符串数组中的索引,这个对应的是列号
		int index = -1;
		int dataFieldCount = (int)(data->m_vFieldName.size());
		for (int i = 0; i < dataFieldCount; i++)
		{
			if (m_sField == data->m_vFieldName[i])
			{
				index = i;
				break;
			}
		}
		if (index == -1)
			return false;

		/*
		开始绘制每个结构体,调用 DrawStruct
		*/
		int iPartCount = data->m_iPartCount;
		//int structType = data->m_iStructType;
		for (int i = 0; i < iPartCount; i++)
		{
			string sFieldValue = data->m_vAllField[i][index];
			Renderer* renderer = NULL;
			bool bHaveFind = false;

			int sz = m_vComponents.size();
			for (int j = 0; j < sz; j++)
			{
				if (sFieldValue == m_vComponents[j]->m_sValue)
				{
					bHaveFind = true;
					renderer = m_vComponents[j]->m_pSymbol;
					break;
				}
			}
			if (!bHaveFind)
				renderer = m_pDefaultSymbol;

			if (!renderer)
				continue;
			renderer->DrawData(pClsCS, data, i, pFlag);
			//clsUtil::DrawStruct(pClsCS, data, i, renderer);
		}
		return true;
	}

	bool ValueMapRenderer::DrawData(clsCrSurf* pClsCS, DataCollection* data, int dataIndex, char* pFlag)
	{
		//找出 field 在 data 中字符串数组中的索引,这个对应的是列号
		int index = -1;
		int dataFieldCount = (int)(data->m_vFieldName.size());
		for (int i = 0; i < dataFieldCount; i++)
		{
			if (m_sField == data->m_vFieldName[i])
			{
				index = i;
				break;
			}
		}
		if (index == -1)
			return false;

		/*
		开始绘制每个结构体,调用 DrawStruct
		*/
		//int iPartCount = data->m_iPartCount;
		//int structType = data->m_iStructType;
		//for (int i = 0; i < iPartCount; i++)
		{
			string sFieldValue = data->m_vAllField[dataIndex][index];
			Renderer* renderer = NULL;
			bool bHaveFind = false;

			int sz = m_vComponents.size();
			for (int j = 0; j < sz; j++)
			{
				if (sFieldValue == m_vComponents[j]->m_sValue)
				{
					bHaveFind = true;
					renderer = m_vComponents[j]->m_pSymbol;
					break;
				}
			}
			if (!bHaveFind)
				renderer = m_pDefaultSymbol;

			if (!renderer)
				return false;
			renderer->DrawData(pClsCS, data, dataIndex, pFlag);
		//	clsUtil::DrawStruct(pClsCS, data, i, renderer);
		}
		return true;
	}
	bool ValueMapRenderer::DrawLegend(clsCrSurf* pClsCS, shared_ptr<legendParamater> pLegendParamater,int layerType, char* pFlag)
	{
		int index = -1;

		if(!pLegendParamater->showclassification)
		{
			return false;
		}
		/*
		开始绘制每个结构体,调用 DrawStruct
		*/
	
		int sz = m_vComponents.size();
		for (int j = 0; j < sz; j++)
		{
			Renderer* renderer = m_vComponents[j]->m_pSymbol; 
			renderer->DrawLegend(pClsCS, pLegendParamater,layerType, (char *)m_vComponents[j]->m_sValue.c_str());
		}
		if(m_pDefaultSymbol)
		{
			m_pDefaultSymbol->DrawLegend(pClsCS, pLegendParamater,layerType, (char *)"其他");
		}
		return true;
	}

	void ValueMapRenderer::TryAddField(vector<string>&pvField)
	{
		TryAddField2(pvField, m_sField);
	}
}