#include "SimpleRenderer.h"
#include"clsXML.h"
#include"clsUtil.h"

#include"DataCollection.h"
#include"SimpleMarkerSymbol.h"
#include"SimpleLabelRenderer.h"
#include"SimpleLineSymbol.h"
#include"SimplePolygonSymbol.h"
#include"ValueMapRenderer.h"
//#include"RangeMapRenderer.h"
#include"GroupRenderer.h"
#include "clsPtree.h"
namespace DmapCore_30
{
	SimpleRenderer::SimpleRenderer()
	{
		m_pRen = NULL;
		m_dUpper = 1e308;
		m_dLower = 0;
		m_alwaysShow = true;
		this->m_simpleRenderer = true;
	}


	SimpleRenderer::~SimpleRenderer()
	{
		if (m_pRen)
			m_pRen->Release();
	}

	int SimpleRenderer::RendererType()
	{
		return dmapSimpleRenderer;
	}

	bool SimpleRenderer::DrawData(clsCrSurf* pClsCS, DataCollection* data, bool drawSimpleData, char* pFlag)
	{
		double r = data->m_dScaleDenominator;
		//double r = r__ / (3779.52755905);
		if (r <m_dLower || (r > m_dUpper && m_dUpper< 10000000000) || m_pRen == 0)
			return false;
		return m_pRen->DrawData(pClsCS, data, pFlag);
	}

	bool SimpleRenderer::DrawData(clsCrSurf* pClsCS, DataCollection* data, int dataIndex, char* pFlag)
	{
		double r = data->m_dScaleDenominator;
		//double r = r__ / (3779.52755905);
		if (r <m_dLower || r > m_dUpper || m_pRen == 0)
			return false;
		return m_pRen->DrawData(pClsCS, data, dataIndex, pFlag);
	}

	bool SimpleRenderer::Parse(boost::property_tree::ptree &pt, AppendBuffer *f)
	{
		clsXML clsX(f, "SIMPLERENDERER");
		//bool alwaysShow = true; //  
		clsXML::XMLAttrParse(pt, f, &m_dUpper, "maxscale");
		clsXML::XMLAttrParse(pt, f, &m_dLower, "minscale");

		bool definedAlwaysShow = this->m_dLower == 0 && this->m_dUpper>10000000000;
		clsXML::XMLAttrParse(pt, f, &m_alwaysShow, "alwaysShow",definedAlwaysShow);
	
		
		clsX.closeProperties();
		//if (node)
		{
			//rapidxml::xml_node<char>* node__ = node->first_node();
			for(auto ptchild = pt.begin(); ptchild != pt.end(); ptchild++)
			{
				if(ptchild->first == "<xmlattr>")
					continue;
				clsXML::XMLParse(ptchild->first, ptchild->second, &m_pRen);
			   if (m_pRen == 0)
			   {
				  return false;
			   }
			}

			if (m_pRen != NULL)
			{
				this->m_simpleRenderer = m_pRen->m_simpleRenderer;
			}
			return true;
		}
		//clsXML::XMLParse(NULL, f, &m_pRen);

		if (m_pRen != NULL)
		{
			this->m_simpleRenderer = m_pRen->m_simpleRenderer;
		}
	

		return true;
	}

	bool SimpleRenderer::ParsePtree( boost::property_tree::ptree &pt)
	{
		boost::property_tree::ptree ptRenderer;
		char buff_maxscale[100];
	   char buff_minscale[100];
	   if(this->m_dUpper>100000000)
	   {
		    sprintf(buff_maxscale,"%e",  this->m_dUpper);
	   }
	   else
	   {
		   sprintf(buff_maxscale,"%.0f",  this->m_dUpper);
	   }

	   if(this->m_dLower>100000000)
	   {
		    sprintf(buff_minscale,"%e",  this->m_dLower);
	   }
	   else
	   {
		   sprintf(buff_minscale,"%.0f",  this->m_dLower);
	   }
	   
       ptRenderer.add("<xmlattr>.maxscale",buff_maxscale);
	   ptRenderer.add("<xmlattr>.minscale",buff_minscale);
	   ptRenderer.add("<xmlattr>.alwaysShow", m_alwaysShow?"true":"false");
	  
	   if(this->m_pRen)
	   {
		   this->m_pRen->ParsePtree(ptRenderer);
	   }
       pt.add_child("SIMPLERENDERER",ptRenderer);
		return true;
	}

   void  SimpleRenderer::ToJson(AppendBuffer *ab)
   {
	   char buff[600];
	   //bool alwaysShow =  this->m_dLower == 0 && this->m_dUpper>10000000000;
	  
	   char buff_maxscale[100];
	   char buff_minscale[100];
	   if(this->m_dUpper>100000000)
	   {
		    sprintf(buff_maxscale,"%e",  this->m_dUpper);
	   }
	   else
	   {
		   sprintf(buff_maxscale,"%.0f",  this->m_dUpper);
	   }

	   if(this->m_dLower>100000000)
	   {
		    sprintf(buff_minscale,"%e",  this->m_dLower);
	   }
	   else
	   {
		   sprintf(buff_minscale,"%.0f",  this->m_dLower);
	   }
	   

	   sprintf(buff,R"({"maxscale":"%s", "minscale":"%s", "alwaysShow":"%s" %s )", 
	   buff_maxscale,
	   buff_minscale,
	   m_alwaysShow?"true":"false",
	   this->m_pRen?",":"");

	   //strcat(resultbuff,buff);
	   ab->AppendString(buff);
	   if(this->m_pRen)
	   {
		   this->m_pRen->ToJson(ab);
	   }
	   ab->AppendString("}");
	   //strcat(resultbuff,"}");
   }

	bool SimpleRenderer::DrawLegend(clsCrSurf* pClsCS, shared_ptr<legendParamater> pLegendParamater,int layerType, char* pFlag)
	{
		double r = pLegendParamater->m_dScaleDenominator;
		//double r = r__ / (3779.52755905);
		if (r <m_dLower || (r > m_dUpper && m_dUpper< 100000000) || m_pRen == 0)
			return false;
		return m_pRen->DrawLegend(pClsCS, pLegendParamater,layerType, pFlag);
	}

	bool SimpleRenderer::TryFindHeatRenderer()
	{
		if (m_pRen == 0)return false;
		return m_pRen->TryFindHeatRenderer();
	}



	void SimpleRenderer::TryAddField(vector<string>&pvField)
	{
		if (m_pRen == 0)return;
		m_pRen->TryAddField(pvField);
	}

	Renderer* SimpleRenderer::GetRenderer()
	{
		if (m_pRen)
			m_pRen->AddRef();
		return m_pRen;
	}
	bool SimpleRenderer::SetRenderer(Renderer* pRen)
	{
		if (!pRen)
			return false;
		pRen->AddRef();
		m_pRen = pRen;
		return true;
	}

	double SimpleRenderer::GetUpper()
	{
		return m_dUpper;
	}
	bool SimpleRenderer::SetUpper(double dUpper)
	{
		m_dUpper = dUpper;
		return true;
	}
	double SimpleRenderer::GetLower()
	{
		return m_dLower;
	}
	bool SimpleRenderer::SetLower(double dLower)
	{
		m_dLower = dLower;
		return true;
	}
}