#include "stdafx.h"
#include "SpBase.h"
#include "SpBinaryPersistStream.h"
#include "SpMisc.h"

#include "iobuffer.h"
#include "memutil.h"

static int add_child_elem(sp_pst_elem_t *parent, const char *key, int t, const void *value, int value_len)
{
	sp_pst_elem_t *elem = sp_pst_elem_create(parent, key);
	sp_pst_elem_set_value(elem, t, value, value_len);
	sp_pst_elem_append_child(parent, elem);
	return 0;
}

static int get_child_value(sp_pst_elem_t *parent, const char *key, int t, const void **p_value, int *p_value_len)
{
	sp_pst_elem_t *elem = sp_pst_elem_find_child(parent, key);
	if (!elem) 
		return Error_NotExist;
	if (sp_pst_elem_get_type(elem) != t)
		return Error_Bug;
	*p_value = sp_pst_elem_get_value(elem);
	*p_value_len = sp_pst_elem_get_value_len(elem);
	return 0;
}

SpBinaryPersistStream::SpBinaryPersistStream(int iMode, sp_pst_elem_t *pNode)
: m_iMode(iMode), m_pNode(pNode)
{
}

SpBinaryPersistStream::~SpBinaryPersistStream()
{
	//...
}

ErrorCodeEnum SpBinaryPersistStream::Get(const char *pszKey,CSimpleStringA &strValue)
{
	if (!pszKey)
		return Error_Param;
	const void *value;
	int value_len;
	int rc = get_child_value(m_pNode, pszKey, SP_PST_T_STR, &value, &value_len);
	if (rc == 0) {
		if (value_len > 0) {
			strValue = CSimpleStringA((const char*)value, value_len);
		} else {
			strValue.Clear();
		}
	}
	return SpTranslateError(rc);
}

ErrorCodeEnum SpBinaryPersistStream::Get(const char *pszKey,ULONGLONG &nValue)
{
	if (!pszKey)
		return Error_Param;
	const void *value;
	int value_len;
	int rc = get_child_value(m_pNode, pszKey, SP_PST_T_I8, &value, &value_len);
	if (rc == 0) {
		memcpy(&nValue, value, value_len);
	}
	return SpTranslateError(rc);
}

ErrorCodeEnum SpBinaryPersistStream::Get(const char *pszKey,DWORD &nValue)
{
	if (!pszKey)
		return Error_Param;
	const void *value;
	int value_len;
	int rc = get_child_value(m_pNode, pszKey, SP_PST_T_I4, &value, &value_len);
	if (rc == 0) {
		memcpy(&nValue, value, value_len);
	}
	return SpTranslateError(rc);
}

ErrorCodeEnum SpBinaryPersistStream::Get(const char *pszKey,WORD &nValue)
{
	if (!pszKey)
		return Error_Param;
	const void *value;
	int value_len;
	int rc = get_child_value(m_pNode, pszKey, SP_PST_T_I2, &value, &value_len);
	if (rc == 0) {
		memcpy(&nValue, value, value_len);
	}
	return SpTranslateError(rc);
}

ErrorCodeEnum SpBinaryPersistStream::Get(const char *pszKey,BYTE &nValue)
{
	if (!pszKey)
		return Error_Param;
	const void *value;
	int value_len;
	int rc = get_child_value(m_pNode, pszKey, SP_PST_T_I1, &value, &value_len);
	if (rc == 0) {
		memcpy(&nValue, value, value_len);
	}
	return SpTranslateError(rc);
}

ErrorCodeEnum SpBinaryPersistStream::Get(const char *pszKey,FLOAT &nValue)
{
	if (!pszKey)
		return Error_Param;
	const void *value;
	int value_len;
	int rc = get_child_value(m_pNode, pszKey, SP_PST_T_I4, &value, &value_len);
	if (rc == 0) {
		memcpy(&nValue, value, value_len);
	}
	return SpTranslateError(rc);
}

ErrorCodeEnum SpBinaryPersistStream::Get(const char *pszKey,DOUBLE &nValue)
{
	if (!pszKey)
		return Error_Param;
	const void *value;
	int value_len;
	int rc = get_child_value(m_pNode, pszKey, SP_PST_T_I8, &value, &value_len);
	if (rc == 0) {
		memcpy(&nValue, value, value_len);
	}
	return SpTranslateError(rc);
}

ErrorCodeEnum SpBinaryPersistStream::Get(const char *pszKey,IEntityPersistObject *pValue)
{
	if (!pszKey)
		return Error_Param;
	ErrorCodeEnum Error = Error_Succeed;
	sp_pst_elem_t *child_elem = sp_pst_elem_find_child(m_pNode, pszKey);
	if (child_elem) {
		if (sp_pst_elem_get_type(child_elem) != SP_PST_T_OBJ) 
			return Error_Bug;
		CSmartPointer<IEntityPersistStreamRead> pStream;
		pStream.Attach(new SpBinaryPersistStream(m_iMode, child_elem));
		Error = pValue->OnRead(pStream);
	} else {
		Error = Error_NotExist;
	}
	return Error;
}

ErrorCodeEnum SpBinaryPersistStream::GetArray(const char *pszKey,CAutoArray<CSimpleStringA> &strValues)
{
	if (!pszKey)
		return Error_Param;
	const void *value;
	int value_len;
	int rc = get_child_value(m_pNode, pszKey, SP_PST_T_ARR_STR, &value, &value_len);
	if (rc == 0) {
		int cnt;
		iobuffer_t *iob = iobuffer_create(-1, value_len);
		memcpy(iobuffer_data(iob, 0), value, value_len);
		iobuffer_push_count(iob, value_len);
		iobuffer_read(iob, IOBUF_T_I4, &cnt, NULL);
		strValues.Init(cnt);
		for (int i = 0; i < cnt; ++i) {
			char *buf = NULL;
			iobuffer_format_read(iob, "s", &buf);
			strValues[i] = buf;
			FREE(buf);
		}
		iobuffer_dec_ref(iob);
	}
	return SpTranslateError(rc);
}

ErrorCodeEnum SpBinaryPersistStream::GetArray(const char *pszKey,CAutoArray<ULONGLONG> &nValues)
{
	if (!pszKey)
		return Error_Param;
	const void *value;
	int value_len;
	int rc = get_child_value(m_pNode, pszKey, SP_PST_T_I8, &value, &value_len);
	if (rc == 0) {
		nValues.Init(value_len/8);
		memcpy(&nValues[0], value, value_len);
	}
	return SpTranslateError(rc);
}

ErrorCodeEnum SpBinaryPersistStream::GetArray(const char *pszKey,CAutoArray<DWORD> &nValues)
{
	if (!pszKey)
		return Error_Param;
	const void *value;
	int value_len;
	int rc = get_child_value(m_pNode, pszKey, SP_PST_T_I4, &value, &value_len);
	if (rc == 0) {
		nValues.Init(value_len/4);
		memcpy(&nValues[0], value, value_len);
	}
	return SpTranslateError(rc);
}

ErrorCodeEnum SpBinaryPersistStream::GetArray(const char *pszKey,CAutoArray<WORD> &nValues)
{
	if (!pszKey)
		return Error_Param;
	const void *value;
	int value_len;
	int rc = get_child_value(m_pNode, pszKey, SP_PST_T_I2, &value, &value_len);
	if (rc == 0) {
		nValues.Init(value_len/2);
		memcpy(&nValues[0], value, value_len);
	}
	return SpTranslateError(rc);
}

ErrorCodeEnum SpBinaryPersistStream::GetArray(const char *pszKey,CAutoArray<BYTE> &nValues)
{
	if (!pszKey)
		return Error_Param;
	const void *value;
	int value_len;
	int rc = get_child_value(m_pNode, pszKey, SP_PST_T_I1, &value, &value_len);
	if (rc == 0) {
		nValues.Init(value_len/1);
		memcpy(&nValues[0], value, value_len);
	}
	return SpTranslateError(rc);
}

ErrorCodeEnum SpBinaryPersistStream::GetArray(const char *pszKey,CAutoArray<FLOAT> &nValues)
{
	if (!pszKey)
		return Error_Param;
	const void *value;
	int value_len;
	int rc = get_child_value(m_pNode, pszKey, SP_PST_T_I4, &value, &value_len);
	if (rc == 0) {
		nValues.Init(value_len/4);
		memcpy(&nValues[0], value, value_len);
	}
	return SpTranslateError(rc);
}

ErrorCodeEnum SpBinaryPersistStream::GetArray(const char *pszKey,CAutoArray<DOUBLE> &nValues)
{
	if (!pszKey)
		return Error_Param;
	const void *value;
	int value_len;
	int rc = get_child_value(m_pNode, pszKey, SP_PST_T_I8, &value, &value_len);
	if (rc == 0) {
		nValues.Init(value_len/8);
		memcpy(&nValues[0], value, value_len);
	}
	return SpTranslateError(rc);
}

ErrorCodeEnum SpBinaryPersistStream::Set(const char *pszKey,const char *pszValue)
{
	if (!pszKey)
		return Error_Param;
	int rc = add_child_elem(m_pNode, pszKey, SP_PST_T_STR, pszValue, -1);
	return SpTranslateError(rc);
}

ErrorCodeEnum SpBinaryPersistStream::Set(const char *pszKey,const ULONGLONG nValue)
{
	if (!pszKey)
		return Error_Param;
	int rc = add_child_elem(m_pNode, pszKey, SP_PST_T_I8, &nValue, sizeof(nValue));
	return SpTranslateError(rc);
}

ErrorCodeEnum SpBinaryPersistStream::Set(const char *pszKey,const DWORD nValue)
{
	if (!pszKey)
		return Error_Param;
	int rc = add_child_elem(m_pNode, pszKey, SP_PST_T_I4, &nValue, sizeof(nValue));
	return SpTranslateError(rc);
}

ErrorCodeEnum SpBinaryPersistStream::Set(const char *pszKey,const WORD nValue)
{
	if (!pszKey)
		return Error_Param;
	int rc = add_child_elem(m_pNode, pszKey, SP_PST_T_I2, &nValue, sizeof(nValue));
	return SpTranslateError(rc);
}

ErrorCodeEnum SpBinaryPersistStream::Set(const char *pszKey,const BYTE nValue)
{
	if (!pszKey)
		return Error_Param;
	int rc = add_child_elem(m_pNode, pszKey, SP_PST_T_I1, &nValue, sizeof(nValue));
	return SpTranslateError(rc);
}

ErrorCodeEnum SpBinaryPersistStream::Set(const char *pszKey,const FLOAT nValue)
{
	if (!pszKey)
		return Error_Param;
	int rc = add_child_elem(m_pNode, pszKey, SP_PST_T_I4, &nValue, sizeof(nValue));
	return SpTranslateError(rc);
}

ErrorCodeEnum SpBinaryPersistStream::Set(const char *pszKey,const DOUBLE nValue)
{
	if (!pszKey)
		return Error_Param;
	int rc = add_child_elem(m_pNode, pszKey, SP_PST_T_I8, &nValue, sizeof(nValue));
	return SpTranslateError(rc);
}

ErrorCodeEnum SpBinaryPersistStream::Set(const char *pszKey,const IEntityPersistObject *pValue)
{
	if (!pszKey)
		return Error_Param;
	sp_pst_elem_t *elem = sp_pst_elem_create(m_pNode, pszKey);
	sp_pst_elem_set_value(elem, SP_PST_T_OBJ, NULL, 0);
	CSmartPointer<IEntityPersistStreamWrite> pStream;
	pStream.Attach(new SpBinaryPersistStream(m_iMode, elem));
	ErrorCodeEnum Error = pValue->OnWrite(pStream);
	if (Error == Error_Succeed) {
		sp_pst_elem_append_child(m_pNode, elem);
	} else {
		sp_pst_elem_destroy(elem);
	}
	return Error;
}

ErrorCodeEnum SpBinaryPersistStream::SetArray(const char *pszKey,const CAutoArray<CSimpleStringA> &strValues)
{
	if (!pszKey)
		return Error_Param;
	int v;
	iobuffer_t *iob = iobuffer_create(-1, -1);
	v = strValues.GetCount();
	iobuffer_write(iob, IOBUF_T_I4, &v, 0);
	for (int i = 0; i < strValues.GetCount(); ++i)
		iobuffer_write(iob, IOBUF_T_STR, (const char*)strValues[i], -1);
	add_child_elem(m_pNode, pszKey, SP_PST_T_ARR_STR, iobuffer_data(iob, 0), iobuffer_get_length(iob));
	iobuffer_dec_ref(iob);
	return Error_Succeed;
}

ErrorCodeEnum SpBinaryPersistStream::SetArray(const char *pszKey,const CAutoArray<ULONGLONG> &nValues)
{
	if (!pszKey)
		return Error_Param;
	int rc = add_child_elem(m_pNode, pszKey, SP_PST_T_ARR_I8, &nValues[0], 8*nValues.GetCount());
	return SpTranslateError(rc);
}

ErrorCodeEnum SpBinaryPersistStream::SetArray(const char *pszKey,const CAutoArray<DWORD> &nValues)
{
	if (!pszKey)
		return Error_Param;
	int rc = add_child_elem(m_pNode, pszKey, SP_PST_T_ARR_I4, &nValues[0], 4*nValues.GetCount());
	return SpTranslateError(rc);
}

ErrorCodeEnum SpBinaryPersistStream::SetArray(const char *pszKey,const CAutoArray<WORD> &nValues)
{
	if (!pszKey)
		return Error_Param;
	int rc = add_child_elem(m_pNode, pszKey, SP_PST_T_ARR_I2, &nValues[0], 2*nValues.GetCount());
	return SpTranslateError(rc);
}

ErrorCodeEnum SpBinaryPersistStream::SetArray(const char *pszKey,const CAutoArray<BYTE> &nValues)
{
	if (!pszKey)
		return Error_Param;
	int rc = add_child_elem(m_pNode, pszKey, SP_PST_T_ARR_I1, &nValues[0], 1*nValues.GetCount());
	return SpTranslateError(rc);
}

ErrorCodeEnum SpBinaryPersistStream::SetArray(const char *pszKey,const CAutoArray<FLOAT> &nValues)
{
	if (!pszKey)
		return Error_Param;
	int rc = add_child_elem(m_pNode, pszKey, SP_PST_T_ARR_I4, &nValues[0], 4*nValues.GetCount());
	return SpTranslateError(rc);
}

ErrorCodeEnum SpBinaryPersistStream::SetArray(const char *pszKey,const CAutoArray<DOUBLE> &nValues)
{
	if (!pszKey)
		return Error_Param;
	int rc = add_child_elem(m_pNode, pszKey, SP_PST_T_ARR_I8, &nValues[0], 8*nValues.GetCount());
	return SpTranslateError(rc);
}