#include "stdafx.h"
#include "OISTKMsgSubscribeMgr.h"
#include <QByteArray>
#include "OICommFun.h"
using namespace OIComm;

namespace OISTKC {

/////////////////////////////////////////////////////////////////////////////
// COISTKMsgSubscribeTag window

COISTKMsgSubscribeTag::COISTKMsgSubscribeTag(void)
{
}

COISTKMsgSubscribeTag::~COISTKMsgSubscribeTag(void)
{
	m_vectParam.clear();
	m_vectValue.clear();
}

/////////////////////////////////////////////////////////////////////////////
// COISTKMsgSubscribeTag message handlers

bool COISTKMsgSubscribeTag::SetInfo( const wstring &strTag )
{
	m_strInfo	= strTag;

	return	ParseData( strTag, m_strName, m_vectParam, m_vectValue );
}

void COISTKMsgSubscribeTag::SetInfo( COISTKMsgSubscribeTag &tag )
{
	m_strInfo	= tag.m_strInfo;

	COISingleLock	lock( m_cs );
	m_strName	= tag.m_strName;
	m_vectParam.clear();
	m_vectParam	= tag.m_vectParam;
	m_vectValue.clear();
	m_vectValue	= tag.m_vectValue;
}

bool COISTKMsgSubscribeTag::AddParam( const wstring &strParam, const wstring &strValue )
{
	if ( strParam.empty() || strValue.empty() )
		return	false;

	if ( FindParam( m_vectParam, m_vectValue, strParam, strValue ) != -1 )
		return	false;

	m_vectParam.push_back( strParam );
	m_vectValue.push_back( strValue );
	return	true;
}

bool COISTKMsgSubscribeTag::RemoveParam( const wstring &strParam, const wstring &strValue )
{
	if ( strParam.empty() )
		return	false;

	CStrVector::iterator	itParam, itCurParam;
	CStrVector::iterator	itValue, itCurValue;

	itParam		= m_vectParam.begin();
	itValue		= m_vectValue.begin();
	if ( strValue.empty() )
	{
		// 未指定 Value，则 Param 名称相同的都移除
		while ( itParam != m_vectParam.end() )
		{
			itCurParam	= itParam;
			itParam++;
			itCurValue	= itValue;
			itValue++;

            //if ( _wcsicmp( (*itCurParam).c_str(), strParam.c_str() ) == 0 )
            if ( qstricmp ( COICommFun::WideChar2MultiByte((*itCurParam).c_str()).c_str()  , COICommFun::WideChar2MultiByte(strParam.c_str()).c_str() ) == 0 )
			{
				m_vectParam.erase( itCurParam );
				m_vectValue.erase( itCurValue );
			}
		} // End of while ( itParam != m_vectParam.end() )
	} // End of if ( strValue.empty() )
	else
	{
		while ( itParam != m_vectParam.end() )
		{
			itCurParam	= itParam;
			itParam++;
			itCurValue	= itValue;
			itValue++;

//			if ( _wcsicmp( (*itCurParam).c_str(), strParam.c_str() ) == 0
//				&& _wcsicmp( (*itCurValue).c_str(), strValue.c_str() ) == 0 )
            if (  qstricmp ( COICommFun::WideChar2MultiByte( (*itCurParam).c_str()).c_str(),COICommFun::WideChar2MultiByte( strParam.c_str()).c_str() ) == 0
               && qstricmp( COICommFun::WideChar2MultiByte ((*itCurValue).c_str()).c_str(),COICommFun::WideChar2MultiByte( strValue.c_str()).c_str() ) == 0 )
			{
				m_vectParam.erase( itCurParam );
				m_vectValue.erase( itCurValue );
				break;
			}
		} // End of while ( itParam != m_vectParam.end() )
	} // End of if ( strValue.empty() ) else ...

	return	true;
}

bool COISTKMsgSubscribeTag::IsSame( wstring strTag )
{
	// 方法1：内容相同，肯定相同
    //if ( _wcsicmp( m_strInfo.c_str(), strTag.c_str() ) == 0 )
    if ( qstricmp( COICommFun::WideChar2MultiByte(m_strInfo.c_str()).c_str(), COICommFun::WideChar2MultiByte(strTag.c_str()).c_str() ) == 0 )
		return	true;

	COISTKMsgSubscribeTag	tag;

	tag.SetInfo( strTag );
	return	IsSame( tag );
}

bool COISTKMsgSubscribeTag::IsSame( COISTKMsgSubscribeTag &tag )
{
	wstring			strTagName;
	CStrVector		vectParam, vectValue;				// 本身的数据，为了不破坏数据而复制出来的

	// 方法1：内容相同，肯定相同
    //if ( _wcsicmp( m_strInfo.c_str(), tag.m_strInfo.c_str() ) == 0 )
    if ( qstricmp ( COICommFun::WideChar2MultiByte(m_strInfo.c_str()).c_str(), COICommFun::WideChar2MultiByte(tag.m_strInfo.c_str()).c_str()  ) == 0 )
		return	true;

	// 方法2：比较 名称 以及参数，为防止参数顺序不同
	// 标签名称是否相同
    //if ( _wcsicmp( m_strName.c_str(), strTagName.c_str() ) != 0 )
    if ( qstricmp( COICommFun::WideChar2MultiByte(m_strName.c_str()).c_str(), COICommFun::WideChar2MultiByte(strTagName.c_str()).c_str() ) != 0 )
		return false;

	// 参数数量不同，肯定不同
	{
	COISingleLock		lock( m_cs );
	if ( tag.m_vectParam.size() != m_vectParam.size() )
		return	false;
	vectParam	= m_vectParam;
	vectValue	= m_vectValue;
	}

	// 比较参数
	CStrVector::iterator	itParam, itValue;
	bool		bRet	= true;

	itParam		= tag.m_vectParam.begin();
	itValue		= tag.m_vectValue.begin();
	while ( itParam != tag.m_vectParam.end() )
	{
		// 有一项参数不存在，则不相同
		if ( -1 == FindParam( vectParam, vectValue, *itParam, *itValue ) )
		{
			bRet	= false;
			break;
		}
	}

	vectParam.clear();
	vectValue.clear();
	return	bRet;
}

bool COISTKMsgSubscribeTag::IsSubscribe( wstring strTag )
{
	// 表示订阅分类的全部消息
	if ( m_strName.empty() )
		return	true;

	COISTKMsgSubscribeTag	tag;

	ParseData( strTag, tag.m_strName, tag.m_vectParam, tag.m_vectValue );
	return	IsSubscribe( tag );
}

bool COISTKMsgSubscribeTag::IsSubscribe( const COISTKMsgSubscribeTag &tag )
{
	// 表示订阅分类的全部消息
	if ( m_strName.empty() )
		return	true;
    // 标签名称是否相同
    //if ( _wcsicmp( m_strName.c_str(), tag.m_strName.c_str() ) != 0 )
    if ( qstricmp( COICommFun::WideChar2MultiByte( m_strName.c_str()).c_str(), COICommFun::WideChar2MultiByte(tag.m_strName.c_str()).c_str() ) != 0 )
		return false;

	CStrVector		vectParam, vectValue;				// 本身的数据，为了不破坏数据而复制出来的

	{
	COISingleLock		lock( m_cs );
	// 无参数约束
	if ( m_vectParam.empty() )
		return	true;
	vectParam	= m_vectParam;
	vectValue	= m_vectValue;
	}

	// 参数多于源标签，不符合
	if ( vectParam.size() > tag.m_vectParam.size() )
	{
		vectParam.clear();
		vectValue.clear();
		return	false;
	}

	// 比较参数
	CStrVector::iterator	itParam, itValue;
	bool		bRet	= true;

	itParam		= vectParam.begin();
	itValue		= vectValue.begin();
	while ( itParam != vectParam.end() )
	{
		// 有一项参数不存在，则不符合
		if ( -1 == FindParam( tag.m_vectParam, tag.m_vectValue, *itParam, *itValue ) )
		{
			bRet	= false;
			break;
		}
	}

	vectParam.clear();
	vectValue.clear();

	return	bRet;
}

// TagName?Param1=Value1&Param1=Value2&Param2=Value&...
bool COISTKMsgSubscribeTag::ParseData( wstring strTag, wstring &strName, CStrVector &vectParam, CStrVector &vectValue )
{
	strName.clear();
	vectParam.clear();
	vectValue.clear();
	if ( strTag.empty() )
		return	true;

	// Parse Tag String
	wstring		strItemName, strItemValue;

	COICommFun::GetStrItem( strTag, strName, L"?" );
	// TagName 为空，参数忽略
	if ( strName.empty() )
		return	true;

	while ( COICommFun::GetStrItem( strTag, strItemValue, L"&" ) )
	{
		COICommFun::GetStrItem( strItemValue, strItemName, L"=" );

		COICommFun::Trim( strItemName );
		COICommFun::Trim( strItemValue );
		if ( !strItemName.empty() && !strItemValue.empty() )
		{
			if ( -1 == FindParam( vectParam, vectValue, strItemName, strItemValue ) )
			{
				vectParam.push_back( strItemName );
				vectValue.push_back( strItemValue );
			}
		}
	}

	return	true;
}

int COISTKMsgSubscribeTag::FindParam( const CStrVector &vectParam, const CStrVector &vectValue, const wstring &strParam, const wstring &strValue )
{
	if ( strParam.empty() || strValue.empty() )
		return	-1;

	CStrVector::size_type	nCount, nIndex;

	nCount	= vectParam.size();
	for ( nIndex = 0; nIndex < nCount; nIndex++ )
	{

//		if ( _wcsicmp( vectParam.at( nIndex ).c_str(), strParam.c_str() ) == 0
//			&& _wcsicmp( vectValue.at( nIndex ).c_str(), strValue.c_str() ) == 0 )
        if ( qstricmp( COICommFun::WideChar2MultiByte( vectParam.at( nIndex ).c_str()).c_str(), COICommFun::WideChar2MultiByte( strParam.c_str()).c_str() ) == 0
             && qstricmp( COICommFun::WideChar2MultiByte( vectValue.at( nIndex ).c_str()).c_str(),  COICommFun::WideChar2MultiByte( strValue.c_str()).c_str() ) == 0 )
		{
			return	nIndex;
		}
	}

	return	-1;
}


/////////////////////////////////////////////////////////////////////////////
// COISTKMsgSubscribeItem window

COISTKMsgSubscribeItem::COISTKMsgSubscribeItem(void)
{
	m_pSession		= NULL;
}

COISTKMsgSubscribeItem::~COISTKMsgSubscribeItem(void)
{
	m_pSession		= NULL;
}

/////////////////////////////////////////////////////////////////////////////
// COISTKMsgSubscribeItem message handlers

bool COISTKMsgSubscribeItem::IsSameTag( wstring strMsgTag )
{
	return	m_tag.IsSame( strMsgTag );
}

bool COISTKMsgSubscribeItem::IsSameTag( COISTKMsgSubscribeTag &tag )
{
	return	m_tag.IsSame( tag );
}

bool COISTKMsgSubscribeItem::IsSubscribe( wstring strMsgTag )
{
	return	m_tag.IsSubscribe( strMsgTag );
}

bool COISTKMsgSubscribeItem::IsSubscribe( const COISTKMsgSubscribeTag &tag )
{
	return	m_tag.IsSubscribe( tag );
}
	

/////////////////////////////////////////////////////////////////////////////
// COISTKMsgSubscribeCategory window

COISTKMsgSubscribeCategory::COISTKMsgSubscribeCategory(void)
{
}

COISTKMsgSubscribeCategory::~COISTKMsgSubscribeCategory(void)
{
	m_listSubscribe.clear();
}

/////////////////////////////////////////////////////////////////////////////
// COISTKMsgSubscribeCategory message handlers

bool COISTKMsgSubscribeCategory::AddMsgSubscribe( wstring strMsgTag, COISTKSession *pSession )
{
	COIBasePtr<COISTKMsgSubscribeItem>	ptrSubscribe;

	ptrSubscribe	= GetMsgSubscribe( strMsgTag, pSession );
	if ( ptrSubscribe )
		return	false;

	ptrSubscribe	= new COISTKMsgSubscribeItem;
	ptrSubscribe->m_tag.SetInfo( strMsgTag );
	ptrSubscribe->m_pSession	= pSession;

	COISingleLock		lock( m_csSubscribe );
	m_listSubscribe.push_back( ptrSubscribe );

	return	true;
}

void COISTKMsgSubscribeCategory::RemoveMsgSubscribe( wstring strMsgTag, COISTKSession *pSession )
{
	CSTKMsgSubscribeList::iterator		it, itCur;
	COISTKMsgSubscribeItem	*pSubscribe;
	COISTKMsgSubscribeTag	tag;

	tag.SetInfo( strMsgTag );

	if ( pSession )
	{
		COISingleLock		lock( m_csSubscribe );
		for ( it = m_listSubscribe.begin(); it != m_listSubscribe.end(); )
		{
			itCur		= it;
			it++;

			pSubscribe	= *itCur;
			if ( pSubscribe->IsSameTag( tag )
				&& pSubscribe->m_pSession == pSession )
			{
				m_listSubscribe.erase( itCur );
				break;
			}
		}
	}
	else
	{
		COISingleLock		lock( m_csSubscribe );
		for ( it = m_listSubscribe.begin(); it != m_listSubscribe.end(); )
		{
			itCur		= it;
			it++;

			pSubscribe	= *itCur;
			if ( pSubscribe->IsSameTag( tag ) )
				m_listSubscribe.erase( itCur );
		}
	}
}

void COISTKMsgSubscribeCategory::RemoveMsgSubscribe( COISTKSession *pSession )
{
	CSTKMsgSubscribeList::iterator		it, itCur;
	COISTKMsgSubscribeItem	*pSubscribe;

	COISingleLock		lock( m_csSubscribe );
	for ( it = m_listSubscribe.begin(); it != m_listSubscribe.end(); )
	{
		itCur		= it;
		it++;

		pSubscribe	= *itCur;
		if ( pSubscribe->m_pSession == pSession )
			m_listSubscribe.erase( itCur );
	}
}

COIBasePtr<COISTKMsgSubscribeItem> COISTKMsgSubscribeCategory::GetMsgSubscribe( wstring strMsgTag, COISTKSession *pSession )
{
	CSTKMsgSubscribeList	listSubscribe;

	{
	COISingleLock		lock( m_csSubscribe );
	if ( m_listSubscribe.empty() )
		return	NULL;
	listSubscribe	= m_listSubscribe;
	}

	COIBasePtr<COISTKMsgSubscribeItem>	ptrSubscribe;
	CSTKMsgSubscribeList::iterator		it;
	COISTKMsgSubscribeTag	tag;

	tag.SetInfo( strMsgTag );

	for ( it = listSubscribe.begin(); it != listSubscribe.end(); it++ )
	{
		ptrSubscribe	= *it;
		if ( ptrSubscribe->IsSameTag( tag )
			&& ptrSubscribe->m_pSession == pSession )
		{
			listSubscribe.clear();
			return	ptrSubscribe;
		}
	}
	listSubscribe.clear();

	return	NULL;
}

void COISTKMsgSubscribeCategory::AppendMsgSubscribe( COISTKMsgSubscribeItem *pSubscribe )
{
	if ( !GetMsgSubscribe( pSubscribe->m_tag.m_strInfo, pSubscribe->m_pSession ) )
	{
		COISingleLock		lock( m_csSubscribe );
		m_listSubscribe.push_back( pSubscribe );
	}
}

int COISTKMsgSubscribeCategory::GetMsgSubscribeSessionList( wstring strMsgTag, CSTKSessionList &listSession )
{
	CSTKMsgSubscribeList	listSubscribe;

	listSession.clear();
	{
	COISingleLock		lock( m_csSubscribe );
	if ( m_listSubscribe.empty() )
		return	0;
	listSubscribe	= m_listSubscribe;
	}

	CSTKMsgSubscribeList::iterator		it;
	COISTKMsgSubscribeItem	*pSubscribe;
	COISTKMsgSubscribeTag	tag;

	tag.SetInfo( strMsgTag );

	for ( it = listSubscribe.begin(); it != listSubscribe.end(); it++ )
	{
		pSubscribe	= *it;
		if ( pSubscribe->IsSubscribe( tag ) )
			listSession.push_back( pSubscribe->m_pSession );
	}
	listSubscribe.clear();

	return	listSession.size();
}


/////////////////////////////////////////////////////////////////////////////
// COISTKMsgSubscribeMgr window

COISTKMsgSubscribeMgr::COISTKMsgSubscribeMgr(void)
{
}

COISTKMsgSubscribeMgr::~COISTKMsgSubscribeMgr(void)
{
	m_mapMsgCategory.clear();
}

/////////////////////////////////////////////////////////////////////////////
// COISTKMsgSubscribeMgr message handlers

bool COISTKMsgSubscribeMgr::AddMsgSubscribe( wstring strMsgCategory, wstring strMsgTag, COISTKSession *pSession )
{
	if ( strMsgCategory.empty() || !pSession )
		return	false;

	COIBasePtr<COISTKMsgSubscribeCategory>	ptrCategory;
	CSTKMsgSubscribeCategoryMap::iterator	it;

	COICommFun::ToUpper( strMsgCategory );

	{
	COISingleLock		lock( m_csCategory );
	it	= m_mapMsgCategory.find( strMsgCategory );
	if ( it != m_mapMsgCategory.end() )
		ptrCategory		= it->second;
	else
	{
		ptrCategory		= new COISTKMsgSubscribeCategory;
		ptrCategory->m_strMsgCategory		= strMsgCategory;
		m_mapMsgCategory[strMsgCategory]	= ptrCategory;
	}
	}

	return	ptrCategory->AddMsgSubscribe( strMsgTag, pSession );
}

void COISTKMsgSubscribeMgr::RemoveMsgSubscribe( wstring strMsgCategory, wstring strMsgTag, COISTKSession *pSession )
{
	COIBasePtr<COISTKMsgSubscribeCategory>	ptrCategory;

	ptrCategory		= GetMsgSubscribeCategory( strMsgCategory );
	if ( !ptrCategory )
		return;

	ptrCategory->RemoveMsgSubscribe( strMsgTag, pSession );
}

void COISTKMsgSubscribeMgr::RemoveMsgSubscribe( COISTKSession *pSession )
{
	CSTKMsgSubscribeCategoryMap::iterator	it;
	CSTKMsgSubscribeCategoryMap		mapMsgCategory;
	COISTKMsgSubscribeCategory		*pCategory;

	{
	COISingleLock		lock( m_csCategory );
	if ( m_mapMsgCategory.empty() )
		return;
	mapMsgCategory		= m_mapMsgCategory;
	}

	for ( it = mapMsgCategory.begin(); it != mapMsgCategory.end(); it++ )
	{
		pCategory	= it->second;
		pCategory->RemoveMsgSubscribe( pSession );
	}
	mapMsgCategory.clear();
}

COIBasePtr<COISTKMsgSubscribeItem> COISTKMsgSubscribeMgr::GetMsgSubscribe( wstring strMsgCategory, wstring strMsgTag, COISTKSession *pSession )
{
	COIBasePtr<COISTKMsgSubscribeCategory>	ptrCategory;

	ptrCategory		= GetMsgSubscribeCategory( strMsgCategory );
	if ( !ptrCategory )
		return	NULL;

	return	ptrCategory->GetMsgSubscribe( strMsgTag, pSession );
}

void COISTKMsgSubscribeMgr::ClearMsgSubscribe()
{
	COISingleLock		lock( m_csCategory );
	m_mapMsgCategory.clear();
}

void COISTKMsgSubscribeMgr::GetMsgSubscribeCategoryList( CSTKMsgSubscribeCategoryList &listCategory )
{
	CSTKMsgSubscribeCategoryMap::iterator	it;
	CSTKMsgSubscribeCategoryMap		mapMsgCategory;
	COISTKMsgSubscribeCategory		*pCategory;

	listCategory.clear();
	{
	COISingleLock		lock( m_csCategory );
	if ( m_mapMsgCategory.empty() )
		return;
	mapMsgCategory		= m_mapMsgCategory;
	}

	for ( it = mapMsgCategory.begin(); it != mapMsgCategory.end(); it++ )
	{
		pCategory	= it->second;
		listCategory.push_back( pCategory );
	}
	mapMsgCategory.clear();
}

void COISTKMsgSubscribeMgr::AppendMsgSubscribeCategory( CSTKMsgSubscribeCategoryList &listCategory )
{
	CSTKMsgSubscribeCategoryList::iterator	it;
	COISTKMsgSubscribeCategory	*pCategory;

	for ( it = listCategory.begin(); it != listCategory.end(); it++ )
	{
		pCategory	= *it;
		AppendMsgSubscribeCategory( pCategory );
	}
}

void COISTKMsgSubscribeMgr::AppendMsgSubscribeCategory( COISTKMsgSubscribeCategory *pCategory )
{
	if ( !pCategory || pCategory->m_strMsgCategory.empty() )
		return;

	COIBasePtr<COISTKMsgSubscribeCategory>	ptrCategory;
	CSTKMsgSubscribeCategoryMap::iterator	itCategory;
	wstring		strMsgCategory;

	strMsgCategory	= pCategory->m_strMsgCategory;
	COICommFun::ToUpper( strMsgCategory );

	{
	COISingleLock		lock( m_csCategory );
	itCategory	= m_mapMsgCategory.find( strMsgCategory );
	if ( itCategory == m_mapMsgCategory.end() )
	{
		m_mapMsgCategory[strMsgCategory]	= pCategory;
		return;
	};

	ptrCategory		= itCategory->second;
	}

	CSTKMsgSubscribeList::iterator	it;
	COISTKMsgSubscribeItem	*pSubscribe;

	for ( it = pCategory->m_listSubscribe.begin(); it != pCategory->m_listSubscribe.end(); it++ )
	{
		pSubscribe	= *it;
//		ptrCategory->AddMsgSubscribe( pSubscribe->m_tag.m_strInfo, pSubscribe->m_pSession );
		ptrCategory->AppendMsgSubscribe( pSubscribe );
	}
}

int COISTKMsgSubscribeMgr::GetMsgSubscribeSessionList( wstring strMsgCategory, wstring strMsgTag, CSTKSessionList &listSession )
{
	listSession.clear();

	COIBasePtr<COISTKMsgSubscribeCategory>	ptrCategory;

	ptrCategory		= GetMsgSubscribeCategory( strMsgCategory );
	if ( !ptrCategory )
		return	0;

	return	ptrCategory->GetMsgSubscribeSessionList( strMsgTag, listSession );
}

bool COISTKMsgSubscribeMgr::AddMsgSubscribeCategory( COISTKMsgSubscribeCategory *pCategory )
{
	if ( !pCategory || pCategory->m_strMsgCategory.empty() )
		return	false;

	CSTKMsgSubscribeCategoryMap::iterator	it;
	wstring		strCategory;

	strCategory		= pCategory->m_strMsgCategory;
	COICommFun::ToUpper( strCategory );

	COISingleLock		lock( m_csCategory );
	it	= m_mapMsgCategory.find( strCategory );
	if ( it != m_mapMsgCategory.end() )
		return	false;

	m_mapMsgCategory[strCategory]	= pCategory;
	return	true;
}

COIBasePtr<COISTKMsgSubscribeCategory> COISTKMsgSubscribeMgr::GetMsgSubscribeCategory( wstring strMsgCategory )
{
	if ( strMsgCategory.empty() )
		return	NULL;

	CSTKMsgSubscribeCategoryMap::iterator	it;

	COICommFun::ToUpper( strMsgCategory );

	COISingleLock		lock( m_csCategory );
	it	= m_mapMsgCategory.find( strMsgCategory );
	if ( it == m_mapMsgCategory.end() )
		return	NULL;
	
	return	it->second;
}


} // End of namespace OISTKC