#include "Renderer.h"
#include"SimpleMarkerSymbol.h"
#include"SimplePolygonSymbol.h"
#include"ValueMapRenderer.h"
//#include"RangeMapRenderer.h"
#include"GroupRenderer.h"
#include"SimpleLineSymbol.h"

#include"clsUtil.h"
#include"clsMalloc.h"
#include <unistd.h>
#include <algorithm>
namespace DmapCore_30
{
	Renderer::Renderer()
	{
		m_iN = 1;
	}


	Renderer::~Renderer()
	{
	}

	bool Renderer::AddRef()
	{
		m_iN++;
		return true;
	}
	bool Renderer::Release()
	{
		m_iN--;
		if (m_iN < 0)
			return false;
		if (!m_iN)
		{
			switch (this->RendererType())
			{
			case dmapSimpleMarkerSymbol:delete (SimpleMarkerSymbol*)this; break;
			case dmapSimpleLineSymbol:
				delete ((SimpleLineSymbol*)this);
				break;
			case dmapSimplePolygonSymbol: delete (SimplePolygonSymbol*)this; break;
			case dmapValueMapRenderer: delete (ValueMapRenderer*)this; break;
			//case dmapRangeMapRenderer: delete (RangeMapRenderer*)this; break;
			case dmapGroupRenderer: delete (GroupRenderer*)this; break;
			default:
				delete this;
				break;
			}
		}
		return true;
	}

	int Renderer::GetN()
	{
		return m_iN;
	}
/*
	bool Renderer::RendererXmlParse(Renderer**ppRen, const char* fileName)
	{
		if (!(*ppRen))
		{
			rapidxml::xml_document<char> doc;
			rapidxml::file<> fdoc(fileName);
			try
			{
				doc.parse<0>(fdoc.data());
			}
			catch (...)
			{
				return false;
			}

			rapidxml::xml_node<char>* root = doc.first_node();
			bool flag = clsXML::XMLParse(root, NULL, ppRen);
			return flag;
		}
		AppendBuffer ab(fileName);
		clsXML::XMLHead(&ab);
		clsXML::XMLParse(NULL, &ab, ppRen);
	
		return true;
	}
*/
	void Renderer::TryAddField2(vector<string>&pvField, std::string field)
	{
		if (field.size() == 0)return;
		vector<string>::iterator it = find(pvField.begin(), pvField.end(), field);
		if (it == pvField.end())
			pvField.push_back(field);
	};

	string Renderer::GetFilePath(string path)
	{
		char sz[200] = {0};
        if(GetCurrentFolderPath(sz, sizeof(sz)) > 0)
		{
			std::string s;
			s = sz;
			size_t t = s.rfind('/');
			sz[t] = 0;
			if(path[0]=='/')
			{
				return path;
			}
			int i=0;
		    if(path[0]=='.')
			{
				if(path[1]=='.')
				{
					i++;
					s= sz;
					t = s.rfind('/');
					sz[t] = 0;
				}
				i++;
			}
			if((sz[t]=='/' || sz[t]=='\\')&& (path[i]=='/' || path[i]=='\\'))
			{
				i++;
			}

			int j= t;
			for(j=t;i<path.length(); i++,j++)
			{
				if(path[i]=='\\')
				{
					sz[j] = '/';
				}
				else
				{
					sz[j] = path[i];
				}

			}
			sz[j] =0;
			//strcat(sz, path.c_str());
			return sz;
		}
		else return 0;

	}


	int Renderer::GetCurrentFolderPath(char* processdir, size_t len)
	{
        char* path_end;
        if (readlink("/proc/self/exe", processdir, len) <= 0)
                return -1;
        path_end = strrchr(processdir, '/');
        if (path_end == NULL)
                return -1;
        ++path_end;
        //strcpy(processname, path_end);
        *path_end = '\0';
        return (size_t)(path_end - processdir);
	}


	void Renderer::TryAddField(vector<string>&pvField)
	{
		
	};
/*
	bool Renderer::RenStr(Renderer** ppRen, const char** psXML)
	{
		using namespace rapidxml;
		if (*ppRen == NULL)
		{
			if (psXML == 0 || *psXML == 0 || (*psXML)[0] == 0)return false;
			char *xml = _strdup(*psXML); clsMalloc mcx(xml);
			if (xml == 0 || xml[0] == 0)return false;
			try{
				xml_document<> doc;    // character type defaults to char
				doc.parse<0>(xml);
				xml_node<char> *n = doc.first_node();
				if (n == 0){ return false; }
				bool flag = clsXML::XMLParse(n, NULL, ppRen);
				return flag;
			}
			catch (parse_error e)
			{
				
				return false;
			}
			catch (...)
			{
				return false;
			}
		}
		AppendBuffer ab(0);
		clsXML::XMLParse(NULL, &ab, ppRen);
		clsMalloc clsM1(ab.GetString());
		(*ppRen)->m_sXML = clsM1.mem;
	
		*psXML = (*ppRen)->m_sXML.c_str();
		return true;
	
	}*/
}