#include "StdAfx.h"
#include "MsgCenter.h"
#include "IMsgObserver.h"


SINGLETON_IMPLEMENT(CMsgCenter)

CMsgCenter::CMsgCenter(void) : m_Stop(false)
{
	m_pThreadObj = AfxBeginThread(__dipatchThreadFunc, this);
}


CMsgCenter::~CMsgCenter(void)
{
	m_Stop = true;

	if(m_pThreadObj != NULL)
	{
		DWORD ExitCode;
		GetExitCodeThread(m_pThreadObj->m_hThread, &ExitCode);
		if(ExitCode == STILL_ACTIVE)
		{
			m_ThreadSleepFlag.SetEvent();
			WaitForSingleObject(m_pThreadObj->m_hThread, INFINITE);
		}
		m_pThreadObj = NULL;
	}	
}

/*****************************************************************
**【函数名称】	__wait
**【函数功能】	置线程于等待信号状态
**【参数】		
**【返回值】
****************************************************************/
void CMsgCenter::__wait( void )
{
	m_ThreadSleepFlag.Lock();
}

/*****************************************************************
**【函数名称】	__releaseMsg
**【函数功能】	释放消息
**【参数】		
**【返回值】
****************************************************************/
void CMsgCenter::__releaseMsg( UINT MsgType, PARAM lpContent )
{
	// 填充事件内容
	switch(MsgType)
	{
	case DEV_EVENT_LOG:						// 设备日志
		{
			delete (EventLog*)lpContent;
		}
		break;

	case DEV_EVENT_RES_TYPE:				// 设备资源类型
		{
			delete (EventResType*)lpContent;
		}
		break;

	case DEV_EVENT_RES_DETAIL:				// 设备资源明细
		{
			delete (EventResDetail*)lpContent;
		}
		break;

	case DEV_EVENT_RES_STATUS:				// 设备资源状态变化
		{
			delete (EventResStatus*)lpContent;
		}
		break;

	case DEV_EVENT_LINE_OP_PROCESS:			// 线路操作进展
		{
			delete (EventOpProcess*)lpContent;
		}
		break;

	case DEV_EVENT_LINE_OP_RESULT:			// 线路操作执行结果
		{
			delete (EventOpResult*)lpContent;
		}
		break;

	case DEV_EVENT_DEV_OPERATOR:		 // 设备主动操作事件
		{
			delete (EventDevOperation*)lpContent;
		}
		break;
	} // end switch
}

/*****************************************************************
**【函数名称】	__dispatchMsg
**【函数功能】	分派消息
**【参数】		
**【返回值】
****************************************************************/
int CMsgCenter::__dispatchMsg( void )
{
	CSingleLock Locker(&m_RWLock, TRUE);

	// 获取事件队列信息
	if(m_MsgList.IsEmpty()) 
		return 0;
	MSG_INNER* pMsg = m_MsgList.RemoveHead();
	
	Locker.Unlock();

	// 根据实际类型分发消息
	__sendMsgToObserver(pMsg->MsgType, pMsg->Content);
	__releaseMsg(pMsg->MsgType, pMsg->Content);
	
	// 删除节点，释放内存
	delete pMsg;

	// 返回
	return m_MsgList.GetCount();
}

/*****************************************************************
**【函数名称】	__sendMsgToObserver
**【函数功能】	消息发送给订阅者
**【参数】		
**【返回值】
****************************************************************/
void CMsgCenter::__sendMsgToObserver( UINT MsgType, const PARAM lpContent )
{
	ObsvrMap::iterator itr;
	ObsvrMap::iterator itrEnd;

	itr = m_ObsvrMap.find(MsgType);
	if(itr == m_ObsvrMap.end())
		return;

	itrEnd = m_ObsvrMap.upper_bound(MsgType);
	for(; itr != itrEnd; ++itr)
	{
		itr->second->onMessage(MsgType, lpContent);
	}
}


/*****************************************************************
**【函数名称】	__dipatchThreadFunc
**【函数功能】	消息分发线程函数
**【参数】		
**【返回值】
****************************************************************/
UINT CMsgCenter::__dipatchThreadFunc( LPVOID pParam )
{
	CMsgCenter* pSelf = (CMsgCenter*)pParam;

	while(!pSelf->m_Stop)
	{
		if(pSelf->__dispatchMsg() == 0)
			pSelf->__wait();
	} // end while

	return 0;
}

/*****************************************************************
**【函数名称】	regist
**【函数功能】	订阅消息
**【参数】		
**【返回值】
****************************************************************/
void CMsgCenter::regist( UINT MsgType, IMsgObserver* pObserver )
{
	m_ObsvrMap.insert(pair<UINT, IMsgObserver*>(MsgType, pObserver));
}

/*****************************************************************
**【函数名称】	unregist
**【函数功能】	取消订阅
**【参数】		
**【返回值】
****************************************************************/
void CMsgCenter::unregist( UINT MsgType, IMsgObserver* pObserver )
{
	ObsvrMap::iterator itr;
	ObsvrMap::iterator itrEnd;

	itr = m_ObsvrMap.find(MsgType);
	if(itr == m_ObsvrMap.end())
		return;

	itrEnd = m_ObsvrMap.upper_bound(MsgType);
	while(itr != itrEnd)
	{
		if(itr->second == pObserver)
		{
			m_ObsvrMap.erase(itr);
			break;
		}
		itr++;
	}
}

/*****************************************************************
**【函数名称】	pushMsg
**【函数功能】	压入消息
**【参数】		
**【返回值】
****************************************************************/
void CMsgCenter::pushMsg( UINT MsgType, const PARAM lpContent )
{
	// 生成消息实体
	MSG_INNER* pMsg = new MSG_INNER;
	memset(pMsg, 0, sizeof(pMsg));
	pMsg->MsgType = MsgType;			// 消息类型

	// 填充事件内容
	switch(MsgType)
	{
	case DEV_EVENT_LOG:						// 设备日志
		{
			pMsg->Content = new EventLog;
			memcpy(pMsg->Content, lpContent, sizeof(EventLog));
		}
		break;

	case DEV_EVENT_RES_TYPE:				// 设备资源类型
		{
			pMsg->Content = new EventResType;
			memcpy(pMsg->Content, lpContent, sizeof(EventResType));
		}
		break;

	case DEV_EVENT_RES_DETAIL:				// 设备资源明细
		{
			pMsg->Content = new EventResDetail;
			memcpy(pMsg->Content, lpContent, sizeof(EventResDetail));
		}
		break;

	case DEV_EVENT_INIT_END:				// 设备初始化结束
	case DEV_EVENT_DEV_CLOSED:				// 设备已关闭
		{
			pMsg->Content = NULL;
		}
		break;

	case DEV_EVENT_RES_STATUS:				// 设备资源状态变化
		{
			pMsg->Content = new EventResStatus;
			memcpy(pMsg->Content, lpContent, sizeof(EventResStatus));
		}
		break;

	case DEV_EVENT_LINE_OP_PROCESS:			// 线路操作进展
		{
			pMsg->Content = new EventOpProcess;
			memcpy(pMsg->Content, lpContent, sizeof(EventOpProcess));
		}
		break;

	case DEV_EVENT_LINE_OP_RESULT:			// 线路操作执行结果
		{
			pMsg->Content = new EventOpResult;
			memcpy(pMsg->Content, lpContent, sizeof(EventOpResult));
		}
		break;

	case DEV_EVENT_DEV_OPERATOR:		 // 设备主动操作事件
		{
			pMsg->Content = new EventDevOperation;
			memcpy(pMsg->Content, lpContent, sizeof(EventDevOperation));
		}
		break;
	} // end switch

	m_RWLock.Lock();	// 互斥加锁

	// 将消息插入缓冲队列
	m_MsgList.AddTail(pMsg);

	m_RWLock.Unlock();

	// 需要唤醒分发线程
	m_ThreadSleepFlag.SetEvent();	
}