#include "restvar.h"

/////////////////////////////////////////////////////////////////////////////

CRestVariable::CRestVariable(void *pData, const std::type_info &rti, HSHM hShm, const char *pszName, int nIndex, CRest *pParent)
							: m_name(pszName), m_pszPath(NULL), m_nIndex(nIndex), m_vt(VT_Invalid), m_data({NULL}), m_pParent(pParent), m_nCbVarpath(0)
{
	if(!pData || !hShm)
	{
		ASSERT(false);
		return;
	}

    m_data.pVoid = pData;
    m_hShm = hShm;

    if(rti == typeid(bool))
    {
    	m_vt = VT_bool;
    }
    else if(rti == typeid(char))
    {
#ifdef __CHAR_UNSIGNED__
    	m_vt = VT_UI1;
#else
        m_vt = VT_I1;
#endif
    }
    else if(rti == typeid(signed char))
    {
        m_vt = VT_I1;
    }
    else if(rti == typeid(unsigned char))
    {
    	m_vt = VT_UI1;
    }
    else if(rti == typeid(short))
    {
    	m_vt = VT_I2;
    }
    else if(rti == typeid(unsigned short))
    {
    	m_vt = VT_UI2;
    }
    else if(rti == typeid(int))
    {
    	m_vt = VT_I4;
    }
    else if(rti == typeid(unsigned int))
    {
    	m_vt = VT_UI4;
    }
    else if(rti == typeid(long))
    {
    	if(sizeof(long) == sizeof(long long))
    	{
	    	m_vt = VT_I8;
	    }
    	else
    	{
	    	m_vt = VT_I4;
	    }
    }
    else if(rti == typeid(unsigned long))
    {
    	if(sizeof(unsigned long) == sizeof(unsigned long long))
    	{
	    	m_vt = VT_UI8;
	    }
    	else
    	{
	    	m_vt = VT_UI4;
	    }
    }
    else if(rti == typeid(long long))
    {
    	m_vt = VT_I8;
    }
    else if(rti == typeid(unsigned long long))
    {
    	m_vt = VT_UI8;
    }
    else if(rti == typeid(float))
    {
    	m_vt = VT_float;
    }
    else if(rti == typeid(double))
    {
    	m_vt = VT_double;
    }
    else
	{
		ASSERT(false);
	}
}

CRestVariable::~CRestVariable(void)
{
}

/////////////////////////////////////////////////////////////////////////////

void CRestVariable::CreateMembersTable(CRestVarTable &vt)
{
	vt.AddVar(static_cast<CRest*>(this));
}

void CRestVariable::InitPath(CRest *pParent, const char *pszMemberName, int nIndex)
{
	CRest::CreatePath(pParent, pszMemberName, nIndex, m_path);
	m_pszPath = m_path.c_str();
	m_nCbVarpath = m_path.length();
}

void CRestVariable::GetValue(int nReqIndex, json_t *pjtMap)
{
	json_array_append_new(pjtMap, GetValue(nReqIndex));
}

json_t* CRestVariable::GetValue(int nReqIndex)
{
	json_t *pjtVal = NULL;

	Lock();
	
	switch(m_vt)
	{
	case VT_bool:
		pjtVal = json_boolean(*m_data.pBool);
		break;
	case VT_I1:
		pjtVal = json_integer((json_int_t)*m_data.pI1);
		break;
	case VT_UI1:
		pjtVal = json_integer((json_int_t)*m_data.pUI1);
		break;
	case VT_I2:
		pjtVal = json_integer((json_int_t)*m_data.pI2);
		break;
	case VT_UI2:
		pjtVal = json_integer((json_int_t)*m_data.pUI2);
		break;
	case VT_I4:
		pjtVal = json_integer((json_int_t)*m_data.pI4);
		break;
	case VT_UI4:
		pjtVal = json_integer((json_int_t)*m_data.pUI4);
		break;
	case VT_I8:
		pjtVal = json_integer((json_int_t)*m_data.pI8);
		break;
	case VT_UI8:
		pjtVal = json_integer((json_int_t)*m_data.pUI8);
		break;
	case VT_float:
		pjtVal = json_real((double)*m_data.pFloat);
		break;
	case VT_double:
		pjtVal = json_real(*m_data.pDouble);
		break;
    default:
		ASSERT(false);
		break;
	}

	Unlock();

	if(pjtVal)
		return CreateValueObject(nReqIndex, m_pszPath, m_nIndex, json_typeof(pjtVal), m_name.c_str(), pjtVal);
	else
		return CreateStatusObject(nReqIndex, -1, "Unexpected Error!", m_pszPath);
}

json_t* CRestVariable::SetValue(int nReqIndex, json_t *pjtVal)
{
	if(!pjtVal)
		return CreateStatusObject(nReqIndex, -1, "Unexpected error!", GetPath());

	json_int_t jInt;
	double jReal;
	int nCode = 0;
	const char *pszMsg = NULL;
	int nType = json_typeof(pjtVal);
	
	switch(nType)
	{
	case JSON_INTEGER:
		jInt = json_integer_value(pjtVal);
		switch(m_vt)
		{
		case VT_bool:
			Lock();
			*m_data.pBool = !!jInt;
			Unlock();
			break;
		case VT_I1:
			Lock();
			*m_data.pI1 = (signed char)jInt;
			Unlock();
			break;
		case VT_UI1:
			Lock();
			*m_data.pUI1 = (unsigned char)jInt;
			Unlock();
			break;
		case VT_I2:
			Lock();
			*m_data.pI2 = (signed short)jInt;
			Unlock();
			break;
		case VT_UI2:
			Lock();
			*m_data.pUI2 = (unsigned short)jInt;
			Unlock();
			break;
		case VT_I4:
			Lock();
			*m_data.pI4 = (signed int)jInt;
			Unlock();
			break;
		case VT_UI4:
			Lock();
			*m_data.pUI4 = (unsigned int)jInt;
			Unlock();
			break;
		case VT_I8:
			Lock();
			*m_data.pI8 = (signed long long)jInt;
			Unlock();
			break;
		case VT_UI8:
			Lock();
			*m_data.pUI8 = (unsigned long long)jInt;
			Unlock();
			break;
		case VT_float:
			Lock();
			*m_data.pFloat = (float)jInt;
			Unlock();
			break;
		case VT_double:
			Lock();
			*m_data.pDouble = (double)jInt;
			Unlock();
			break;
		default:
			nCode = 1;
			pszMsg = "Cannot assign JSON integer value! Variable is not an integer or real type!";
			break;
		}
		break;
	case JSON_REAL:
		jReal = json_real_value(pjtVal);
		switch(m_vt)
		{
		case VT_float:
			Lock();
			*m_data.pFloat = (float)jReal;
			Unlock();
			break;
		case VT_double:
			Lock();
			*m_data.pDouble = jReal;
			Unlock();
			break;
		default:
			nCode = 2;
			pszMsg = "Cannot assign JSON real value! Variable is not of type real!";
			break;
		}
		break;
	case JSON_TRUE:
	case JSON_FALSE:
		switch(m_vt)
		{
		case VT_bool:
			Lock();
			*m_data.pBool = (nType == JSON_TRUE);
			Unlock();
			break;
		default:
			nCode = 3;
			pszMsg = "Cannot assign JSON bool value! Variable is not of type bool!";
			break;
		}
		break;
	default:
		nCode = 4;
		pszMsg = "Cannot assign incompatible JSON type!";
		break;
	}

	return CreateStatusObject(nReqIndex, nCode, pszMsg, GetPath());
}

/////////////////////////////////////////////////////////////////////////////

void CRestVariable::Lock(void)
{
	::GfaIpcLockSHM(m_hShm);
}

void CRestVariable::Unlock(void)
{
	::GfaIpcUnlockSHM(m_hShm);
}