#include "StdAfx.h"
#include ".\xmlparser.h"
#include "PublicDefine.h"

XMLParser::XMLParser(void)
{
}

XMLParser::~XMLParser(void)
{
//	m_pDoc->Release();
}


BOOL	XMLParser::Init()
{
	CoInitialize( NULL );

	HRESULT	hr;

	hr = m_pDoc.CreateInstance( __uuidof(MSXML2::DOMDocument) );
	if( FAILED(hr) )	return FALSE;

	m_pPI = m_pDoc->createProcessingInstruction( L"xml", L"version=\"1.0\" encoding=\"euc-kr\"" );	//PI생성
	hr = m_pDoc->appendChild( m_pPI );
	if( FAILED(hr) )	return FALSE;

	return TRUE;
}

BOOL	XMLParser::Load( char* pszFile )
{
	m_varXMLFile = pszFile;

	if( m_pDoc->load( m_varXMLFile ) != VARIANT_TRUE )
	{
		return FALSE;
	}

	return TRUE;
}

BOOL	XMLParser::Save()
{
	HRESULT hr = m_pDoc->save( m_varXMLFile );
	if( FAILED(hr) )	return FALSE;

	return TRUE;
}

/************************************************************************/
/* Find Nodes Methods                                                   */
/************************************************************************/

//Element Name 으로 검색
NODELISTPtr			XMLParser::FindNodeList( BSTR strElem, long& nNodeCount )
{
	NODELISTPtr pNodeList = NULL;
	pNodeList = m_pDoc->selectNodes( strElem );
	nNodeCount = pNodeList->Getlength();
	return pNodeList;
}

//속성값으로 노드리스트를 검색 현재 VT_UI4와 VT_BSTR만 사용가능.
NODELISTPtr			XMLParser::FindNodeListByAttr( const TCHAR* pszElem, const TCHAR* pszAttr, _variant_t var )
{
	NODELISTPtr pNodeList = NULL;

	TCHAR szQuery[MAX_QUERY_STRING];
	switch( var.vt )
	{
	case VT_UI4:			//DWORD
		_snprintf( szQuery, MAX_QUERY_STRING, "//%s[@%s='%u']", pszElem, pszAttr, var.ulVal ); 
		break;
	case VT_BSTR:			//String 
		_snprintf( szQuery, MAX_QUERY_STRING, "//%s[@%s='%s']", pszElem, pszAttr,  _com_util::ConvertBSTRToString(var.bstrVal) ); 
		break;
	default:
		return NULL;
	}

	return Query( szQuery );
}


NODELISTPtr			XMLParser::Query( const TCHAR* pszQuery )
{
	if( !pszQuery ) return NULL;

	BSTR strQuery = _com_util::ConvertStringToBSTR( pszQuery );
	NODELISTPtr	pNodeList = m_pDoc->selectNodes( strQuery );
	if( pNodeList )		return pNodeList;
	else				return NULL;
}

NODEPtr				XMLParser::SingleQuery( const TCHAR* pszQuery )
{
	if( !pszQuery ) return NULL;

	BSTR strQuery = _com_util::ConvertStringToBSTR( pszQuery );
	NODEPtr	pNode = m_pDoc->selectSingleNode( strQuery );
	if( pNode )		return pNode;
	else			return NULL;
}

//return  Atrributes of Element
ATTRIMAPPtr			XMLParser::FindAttriMap( NODELISTPtr pNodeList, long nIndex )
{
	if( pNodeList == NULL )	return NULL;
	NODEPtr pNode = pNodeList->Getitem( nIndex );
	if( pNode == NULL )	return NULL;
	return pNode->Getattributes();
}


NODEPtr			XMLParser::FindNode( NODELISTPtr pNodeList, long nIndex )
{
	if( pNodeList == NULL )	return NULL;
	NODEPtr pNode = pNodeList->Getitem( nIndex );
	if( pNode == NULL )	return NULL;
	return pNode;
}

//현재 노드의 바로 아래 단계의 노드들의 리스트를 가져온다.
NODELISTPtr			XMLParser::FindChildNodeList( NODEPtr pNode, long& nNodeCount )
{
	if( pNode == NULL )	return NULL;
	NODELISTPtr	pNodeList = pNode->GetchildNodes();
	if( pNodeList == NULL )		return NULL;
	nNodeCount = pNodeList->Getlength();
	return pNodeList;
}


/************************************************************************/
/* 이름으로 속성값 얻기                                                 */
/************************************************************************/
BOOL			XMLParser::GetAttriData( NODEPtr	pNode, _bstr_t strAttriName, _bstr_t& bstrData )
{
	bstrData = L"";
	if( pNode == NULL )								return FALSE;
	NODEPtr	pAttriNode = GetAttriNode( pNode, strAttriName );
	if( pAttriNode == NULL )						return FALSE;
	if( !GetNodeDataBSTR( pAttriNode, bstrData ) )	return FALSE;
	return TRUE;
}

BOOL			XMLParser::GetAttriDataStr( NODEPtr	pNode, _bstr_t strAttriName, std::string& strData )
{
	strData.clear();
	if( pNode == NULL )								return FALSE;
	NODEPtr	pAttriNode = GetAttriNode( pNode, strAttriName );
	if( pAttriNode == NULL )						return FALSE;
	if( !GetNodeDataStr( pAttriNode, strData ) )	return FALSE;
	return TRUE;
}

BOOL			XMLParser::GetAttriDataInt( NODEPtr	pNode, _bstr_t strAttriName, int& nData )
{
	nData = 0;
	if( pNode == NULL )							return FALSE;
	NODEPtr	pAttriNode = GetAttriNode( pNode, strAttriName );
	if( pAttriNode == NULL )					return FALSE;
	if( !GetNodeDataInt( pAttriNode, nData ) )	return FALSE;

	return TRUE;
}

BOOL			XMLParser::GetAttriDataDWORD( NODEPtr	pNode, _bstr_t strAttriName, DWORD& dwData )
{
	dwData = 0;
	if( pNode == NULL )								return FALSE;
	NODEPtr	pAttriNode = GetAttriNode( pNode, strAttriName );
	if( pAttriNode == NULL )						return FALSE;
	if( !GetNodeDataDWORD( pAttriNode, dwData ) )	return FALSE;

	return TRUE;
}

BOOL			XMLParser::GetAttriDataFloat( NODEPtr	pNode, _bstr_t strAttriName, float& fData )
{
	fData = 0;
	if( pNode == NULL )								return FALSE;
	NODEPtr	pAttriNode = GetAttriNode( pNode, strAttriName );
	if( pAttriNode == NULL )						return FALSE;
	if( !GetNodeDataFloat( pAttriNode, fData ) )	return FALSE;

	return TRUE;
}

BOOL			XMLParser::GetAttriDataBYTE( NODEPtr	pNode, _bstr_t strAttriName, BYTE& byData )
{
	byData = 0;
	if( pNode == NULL )								return FALSE;
	NODEPtr	pAttriNode = GetAttriNode( pNode, strAttriName );
	if( pAttriNode == NULL )						return FALSE;
	if( !GetNodeDataBYTE( pAttriNode, byData ) )	return FALSE;

	return TRUE;
}

BOOL			XMLParser::GetAttriDataBOOL( NODEPtr	pNode, _bstr_t strAttriName, BOOL& bData )
{
	bData = 0;
	if( pNode == NULL )								return FALSE;
	NODEPtr	pAttriNode = GetAttriNode( pNode, strAttriName );
	if( pAttriNode == NULL )						return FALSE;
	if( !GetNodeDataBOOL( pAttriNode, bData ) )	return FALSE;

	return TRUE;
}


NODEPtr			XMLParser::GetAttriNode( NODEPtr pNode, _bstr_t strAttriName )
{
	if( pNode == NULL )	return NULL;

	ATTRIMAPPtr	pAttriMap = pNode->Getattributes();
	if( pAttriMap == NULL )	return NULL;
	NODEPtr pAttriNode = pAttriMap->getNamedItem( strAttriName );
	if( pNode == NULL )	return NULL;
	return pAttriNode;
}

/************************************************************************/
/* Node에서 해당 자료형의 값을 얻어온다.                                */
/************************************************************************/
BOOL			XMLParser::GetNodeDataBSTR( NODEPtr pNode, _bstr_t& strData )
{
	m_varData.Clear();

	if( pNode == NULL )	return FALSE;
	m_varData = pNode->GetnodeValue();
	m_varData.ChangeType( VT_BSTR );
	strData = m_varData.bstrVal;

	return TRUE;
}


BOOL			XMLParser::GetNodeDataStr( NODEPtr pNode, std::string& strData )
{
	m_varData.Clear();

	if( pNode == NULL )	return FALSE;
	m_varData = pNode->GetnodeValue();
	m_varData.ChangeType( VT_BSTR );
	strData = _com_util::ConvertBSTRToString( m_varData.bstrVal );

	return TRUE;
}

BOOL			XMLParser::GetNodeDataInt( NODEPtr pNode, int& nData )
{
	m_varData.Clear();

	if( pNode == NULL )	return FALSE;

	m_varData = pNode->GetnodeValue();
	m_varData.ChangeType( VT_I4 );
	nData = m_varData.intVal;

	return TRUE;
}

BOOL			XMLParser::GetNodeDataDWORD( NODEPtr pNode, DWORD& dwData )
{
	m_varData.Clear();

	if( pNode == NULL )	return FALSE;

	m_varData = pNode->GetnodeValue();
	m_varData.ChangeType( VT_UI4 );
	dwData = m_varData.ulVal;

	return TRUE;
}

BOOL			XMLParser::GetNodeDataFloat( NODEPtr pNode, float& fData )
{
	m_varData.Clear();

	if( pNode == NULL )	return FALSE;

	m_varData = pNode->GetnodeValue();
	m_varData.ChangeType( VT_R4 );
	fData = m_varData.fltVal;

	return TRUE;
}

BOOL			XMLParser::GetNodeDataBYTE( NODEPtr pNode, BYTE& byData )
{
	m_varData.Clear();

	if( pNode == NULL )	return FALSE;

	m_varData = pNode->GetnodeValue();
	m_varData.ChangeType( VT_UI1 );
	byData = m_varData.bVal;

	return TRUE;
}


BOOL			XMLParser::GetNodeDataBOOL( NODEPtr pNode, BOOL& bData )
{
	m_varData.Clear();

	if( pNode == NULL )	return FALSE;

	m_varData = pNode->GetnodeValue();
	m_varData.ChangeType( VT_UI1 );
	bData = m_varData.bVal;

	return TRUE;
}


/************************************************************************/
/* 일련번호로 속성값 얻기                                               */
/************************************************************************/
BOOL			XMLParser::GetAttriData( NODEPtr	pNode, long nIndex, _bstr_t& bstrData )
{
	bstrData = L"";
	if( pNode == NULL )									return FALSE;
	NODEPtr	pAttriNode = GetAttriNode( pNode, nIndex );
	if( pAttriNode == NULL )							return FALSE;
	if( !GetNodeDataBSTR( pAttriNode, bstrData ) )		return FALSE;
	return TRUE;
}

BOOL			XMLParser::GetAttriDataStr( NODEPtr	pNode, long nIndex, std::string& strData )
{
	strData.clear();
	if( pNode == NULL )									return FALSE;
	NODEPtr	pAttriNode = GetAttriNode( pNode, nIndex );
	if( pAttriNode == NULL )							return FALSE;
	if( !GetNodeDataStr( pAttriNode, strData ) )		return FALSE;
	return TRUE;
}

BOOL			XMLParser::GetAttriDataInt( NODEPtr	pNode, long nIndex, int& nData )
{
	nData = 0;
	if( pNode == NULL )									return FALSE;
	NODEPtr	pAttriNode = GetAttriNode( pNode, nIndex );
	if( pAttriNode == NULL )							return FALSE;
	if( !GetNodeDataInt( pAttriNode, nData ) )			return FALSE;
	return TRUE;
}

BOOL			XMLParser::GetAttriDataDWORD( NODEPtr	pNode, long nIndex, DWORD& dwData )
{
	dwData = 0;
	if( pNode == NULL )									return FALSE;
	NODEPtr	pAttriNode = GetAttriNode( pNode, nIndex );
	if( pAttriNode == NULL )		return FALSE;
	if( !GetNodeDataDWORD( pAttriNode, dwData ) )		return FALSE;
	return TRUE;
}

BOOL			XMLParser::GetAttriDataFloat( NODEPtr	pNode, long nIndex, float& fData )
{
	fData = 0;
	if( pNode == NULL )									return FALSE;		
	NODEPtr	pAttriNode = GetAttriNode( pNode, nIndex );
	if( pAttriNode == NULL )							return FALSE;
	if( !GetNodeDataFloat( pAttriNode, fData ) )		return FALSE;
	return TRUE;
}

BOOL			XMLParser::GetAttriDataBYTE( NODEPtr	pNode, long nIndex, BYTE& byData )
{
	byData = 0;
	if( pNode == NULL )									return FALSE;
	NODEPtr	pAttriNode = GetAttriNode( pNode, nIndex );
	if( pAttriNode == NULL )							return FALSE;
	if( !GetNodeDataBYTE( pAttriNode, byData ) )		return FALSE;
	return TRUE;
}

BOOL			XMLParser::GetAttriDataBOOL( NODEPtr	pNode, long nIndex, BOOL& bData )
{
	bData = 0;
	if( pNode == NULL )									return FALSE;
	NODEPtr	pAttriNode = GetAttriNode( pNode, nIndex );
	if( pAttriNode == NULL )							return FALSE;
	if( !GetNodeDataBOOL( pAttriNode, bData ) )			return FALSE;
	return TRUE;
}


NODEPtr			XMLParser::GetAttriNode( NODEPtr pNode, long nIndex )
{
	nIndex = 0;
	if( pNode == NULL )									return NULL;
	ATTRIMAPPtr	pAttriMap = pNode->Getattributes();
	if( pAttriMap == NULL )								return NULL;
	NODEPtr pAttriNode = pAttriMap->Getitem( nIndex );
	if( pNode == NULL )									return NULL;
	return pAttriNode;
}


/************************************************************************/
/* 엘레먼트에 속성값 설정하는 함수들                                    */
/************************************************************************/
BOOL			XMLParser::SetAttribute( ELEMENTPtr pElem, BSTR strName, _variant_t value )
{
	HRESULT hr = pElem->setAttribute( strName, value );
	if( FAILED(hr) )	return FALSE;

	return TRUE;
}

BOOL			XMLParser::SetAttributeStr( ELEMENTPtr pElem, BSTR strName, std::string strValue )
{
	m_varAttrValue.Clear();
	m_varAttrValue.vt = VT_BSTR;
	m_varAttrValue.bstrVal = _com_util::ConvertStringToBSTR( strValue.c_str() );
	
	HRESULT hr = pElem->setAttribute( strName, m_varAttrValue );
	if( FAILED(hr) )	return FALSE;

	return TRUE;
}

BOOL			XMLParser::SetAttributeInt( ELEMENTPtr pElem, BSTR strName, int nValue )
{
	m_varAttrValue.Clear();
	m_varAttrValue.vt = VT_I4;
	m_varAttrValue.intVal = nValue;

	HRESULT hr = pElem->setAttribute( strName, m_varAttrValue );
	if( FAILED(hr) )	return FALSE;

	return TRUE;
}

BOOL			XMLParser::SetAttributeDWORD( ELEMENTPtr pElem, BSTR strName, DWORD dwValue )
{
	m_varAttrValue.Clear();
	m_varAttrValue.vt = VT_UI4;
	m_varAttrValue.ulVal = dwValue;

	HRESULT hr = pElem->setAttribute( strName, m_varAttrValue );
	if( FAILED(hr) )	return FALSE;

	return TRUE;

}

BOOL			XMLParser::SetAttributeFloat( ELEMENTPtr pElem, BSTR strName, float fValue )
{
	m_varAttrValue.Clear();
	m_varAttrValue.vt = VT_R4;
	m_varAttrValue.fltVal = fValue;

	HRESULT hr = pElem->setAttribute( strName, m_varAttrValue );
	if( FAILED(hr) )	return FALSE;

	return TRUE;
}

BOOL			XMLParser::SetAttributeBYTE( ELEMENTPtr pElem, BSTR strName, BYTE byValue )
{
	m_varAttrValue.Clear();
	m_varAttrValue.vt = VT_UI1;
	m_varAttrValue.bVal = byValue;

	HRESULT hr = pElem->setAttribute( strName, m_varAttrValue );
	if( FAILED(hr) )	return FALSE;

	return TRUE;
}

BOOL			XMLParser::SetAttributeBOOL( ELEMENTPtr pElem, BSTR strName, BOOL bValue )
{
	m_varAttrValue.Clear();
	m_varAttrValue.vt = VT_BOOL;
	m_varAttrValue.boolVal = bValue;

	HRESULT hr = pElem->setAttribute( strName, m_varAttrValue );
	if( FAILED(hr) )	return FALSE;

	return TRUE;
}


/************************************************************************/
/* Element Function                                                     */
/************************************************************************/
ELEMENTPtr		XMLParser::CreateElement( BSTR strNewElem )
{
	return m_pDoc->createElement( strNewElem );
}

ELEMENTPtr		XMLParser::InsertElement( BSTR strParent, BSTR strNewElem )
{
	ELEMENTPtr		pNewElem = m_pDoc->createElement( strNewElem );
	NODEPtr			pParent = m_pDoc->selectSingleNode( strParent );
	pParent->appendChild( pNewElem );

	return pNewElem;
}


//엘레멘트 이름과 속성값으로 삭제
BOOL			XMLParser::RemoveElement( TCHAR* pszElem, TCHAR* pszFindAttr, _variant_t var )
{
	if( !pszElem || !pszFindAttr ) 
		return FALSE;

	NODELISTPtr	pNodeList = FindNodeListByAttr( pszElem, pszFindAttr, var );
	if( pNodeList == NULL )		return FALSE;

	int nCount = pNodeList->Getlength();

	for( int i = 0; i < nCount; i++ )
	{
		NODEPtr pNode = FindNode( pNodeList, i );		//첫번째 채널부터 순차적으로.
		if( pNode )
		{
			NODEPtr pPrarentNode = pNode->GetparentNode();
			if( pPrarentNode )
				pPrarentNode->removeChild( pNode );
		}
	}

	return TRUE;
}

//엘레먼트 이름과, 속성의 조건으로 검색하여, 검색된 전 노드를 바꾸려는 속성의 값으로 바꾼다.
BOOL			XMLParser::UpdateElement( TCHAR* pszElem, TCHAR* pszFindAttr, _variant_t FindVar, TCHAR* pszModifyAttr, _variant_t ModifyVar ) 
{
	if( !pszElem || !pszFindAttr || !pszModifyAttr ) 
		return FALSE;

	NODELISTPtr	pNodeList = FindNodeListByAttr( pszElem, pszFindAttr, FindVar );
	if( pNodeList == NULL )		return FALSE;

	return _UpdateNodeList( pNodeList, pszModifyAttr, ModifyVar );
}


BOOL	XMLParser::_UpdateNodeList( NODELISTPtr pNodeList, TCHAR* pszModifyAttr, _variant_t ModifyVar ) 
{
	int nCount = pNodeList->Getlength();
	if( nCount <= 0 )	return FALSE;

	_variant_t	varAttrValue;

	for( int i = 0; i < nCount; i++ )
	{
		NODEPtr pNode = FindNode( pNodeList, i );		
		if( pNode )
		{
			NODEPtr pAttrNode = GetAttriNode( pNode, (_bstr_t)pszModifyAttr );

			pAttrNode->nodeValue.ChangeType( ModifyVar.vt );
			varAttrValue.ChangeType( ModifyVar.vt );
			switch( ModifyVar.vt )
			{
			case VT_UI4:		//DWORD
				varAttrValue.ulVal = ModifyVar.ulVal;
				break;
			case VT_BSTR:		//BSTR
				varAttrValue.bstrVal = ModifyVar.bstrVal;
				break;
			default:
				continue;
			}

			pAttrNode->put_nodeValue( varAttrValue );
		}
	}

	return TRUE;
}

BOOL	XMLParser::RemoveElement( const TCHAR* pszElem )
{
	if( !pszElem )		return FALSE;

	TCHAR szQuery[MAX_PATH];
	_snprintf( szQuery, MAX_PATH, "//%s", pszElem );

	NODELISTPtr	pNodeList = Query( szQuery );
	if( pNodeList == NULL )		return FALSE;

	for( int i = 0; i < pNodeList->Getlength(); i++ )
	{
		NODEPtr pNode = FindNode( pNodeList, i );		//첫번째 채널부터 순차적으로.
		if( pNode )
		{
			NODEPtr pPrarentNode = pNode->GetparentNode();
			if( pPrarentNode )
				pPrarentNode->removeChild( pNode );
		}
	}	

	return TRUE;
}