#include "stdafx.h"

#include "MonitoringTool.h"
#include "ManagerServerEventHandler.h"
#include "MonitoringToolSetup.h"
#include "LoginDlg.h"
#include "GlobalFunc.h"

#include <Utility/Setup/ServerSetup.h>
#include <Network/Packet/ManagePacketCmd.h>
#include <Network/Dispatch/SendManagePacket.h>
#include <UserManage/UserStatistics.h>
#include <Log/ServerLog.h>
#include <Utility/Compress/MiniLZO/MiniLZOWrapper.h>

#include <mmsystem.h>

namespace ClientNet
{
    
CManagerServerEventHandler::CManagerServerEventHandler()
:   m_dwLastPingRecvTime(0)
{

}

CManagerServerEventHandler::~CManagerServerEventHandler()
{

}

bool CManagerServerEventHandler::Connect()
{	
	CMonitoringToolSetup Setup = CMonitoringToolSetup::GetInstance();

	const char* szIP = Setup.GetString(_T("MANAGER_SERVER_CONNECTION"), _T("MANAGER_SERVER_IP"));

    CManagerServerEventHandler* lpHandler = new CManagerServerEventHandler;

    if (!theApp.GetEventHandlerMgr().Connect(
		INET_Addr(szIP, CServerSetup::ManageServerManageToolListen), lpHandler))
    {
        delete lpHandler;
        return false;
    }

	return true;
}

int CManagerServerEventHandler::OnOpen(int iErrorCode)
{
	if(0 == iErrorCode)
	{
		theApp.RegisterManagerHandler(this);

		INET_Addr& addr = GetPeerAddress();

		INFLOG3(g_Log, _T("Connect Session (ManagerServer): DP:0x%p, %s:%d"),
			this, addr.get_addr_string(), addr.get_port_in());
		theApp.ReportResult(GetMyINIString("LOCAL_STRING", "STRING_037"));
	}
	else
	{
		ERRLOG1(g_Log, _T("Connect Session Failed (ManagerServer): Err- %d"), iErrorCode);
		theApp.ReportResult(GetMyINIString("LOCAL_STRING", "STRING_038"));
	}

	m_dwLastPingRecvTime = timeGetTime();	
	return 0;
}

int CManagerServerEventHandler::OnClose()
{
    CWnd* lpWnd = AfxGetMainWnd();
    
    if(0 != lpWnd && !IsCloseCalled())
    {
        lpWnd->PostMessage(WM_SHOW_MSGBOX, MSGBOX_MANAGER_DISCONNECTED);
    }

	INFLOG1(g_Log, _T("Disconnect Session (ManagerServer): DP:0x%p"), this);
	theApp.ReportResult(GetMyINIString("LOCAL_STRING", "STRING_039"));

	theApp.RemoveManagerHandler(this);
	return 0;
}

int CManagerServerEventHandler::OnDispatch(PktBase* lpPktBase, INET_Addr& peerAddr)
{
	switch(lpPktBase->GetCmd())
	{
	case ServerManage::CMD::AuthUser:		RecvAuthAck(lpPktBase, peerAddr);			break;
	case ServerManage::CMD::RelayCommand:   RecvUserStatistics(lpPktBase, peerAddr);	break;
    case ServerManage::CMD::Ping:           RecvPing(lpPktBase, peerAddr);              break;
	}

	return 0;
}

/// \brief °ü¸®¼­¹ö·Î ºÎÅÍ µ¿Á¢Á¤º¸¸¦ ¹Þ¾Æ¼­ ÀúÀå
/// \return ÆÐŶ ó¸® ¼º°ø ¿©ºÎ
bool CManagerServerEventHandler::RecvUserStatistics(PktBase* lpPktBase, INET_Addr& peerAddr)
{
	if(lpPktBase->GetLen() < sizeof(ServerManage::ManageCommand))
	{
		ERRLOG3(g_Log, _T("DP:0x%p/Cmd:0x%p/Invalid packet size : %d"),
            this, lpPktBase->GetCmd(), lpPktBase->GetLen());
	}
	else if(0 != lpPktBase->GetError())
	{
		ERRLOG3(g_Log, _T("DP:0x%p/Cmd:0x%p/Err:%d/Get ProcessStatus packet failed"),
			this, lpPktBase->GetCmd(), lpPktBase->GetError());
	}
	else
	{
	    ServerManage::ManageCommand* lpManageCommand = 
		    reinterpret_cast<ServerManage::ManageCommand*>(lpPktBase);

	    if(!ServerManage::CheckManagePacketLength(lpPktBase))
	    {
			ERRLOG3(g_Log, _T("DP:0x%p/Cmd:0x%p/Invalid packet size : %d"),
				this, lpPktBase->GetCmd(), lpPktBase->GetLen());
	    }

        if(sizeof(ServerManage::PktManagePacket) <= lpManageCommand->usDataLen)
        {
            ServerManage::PktManagePacket* lpPktManagePacket = 
                reinterpret_cast<ServerManage::PktManagePacket*>(lpManageCommand + 1);

            switch(lpPktManagePacket->m_dwSubCommand)
            {
            case ServerManage::CMD::SubCmd_ServerUserNum:
                {
                    ServerManage::PktManageUserNum* lpPktManageUserNum = 
                        static_cast<ServerManage::PktManageUserNum*>(lpPktManagePacket);

                    CUserStatistics::GetInstance().SerializeIn(lpManageCommand->dwRunID,
						reinterpret_cast<ServerManage::UserNumPair*>(lpPktManageUserNum + 1), 
                        lpPktManageUserNum->m_dwUserInfoNum);
                }
                break;            
            }
            return true;
        }
    }
	return false;
}

/// \brief °ü¸®¼­¹ö·Î ÀÎÁõÆÐŶ Àü¼Û
/// \param lpHandler °ü¸®¼­¹ö ¿¬°á ¼¼¼Ç
/// \param lpUserInfo ·Î±×ÀÎ À¯Àú Á¤º¸
/// \param cUserInfoNum À¯Àú¼ö(¸ð´ÏÅ͸µÅø¿¡¼± 1·Î °íÁ¤)
/// \param cCommand Ä¿¸Çµå
/// \param cError ÀÎÁõ ÆÐŶ Àü¼Û¿¡ µû¸¥ ¿¡·¯ÄÚµå
/// \return ÆÐŶ Àü¼Û ó¸® ¼º°ø ¿©ºÎ
bool CManagerServerEventHandler::SendUserInfo(CManagerServerEventHandler* lpHandler, 
                                              const ServerManage::UserInfo* lpUserInfo,
                                              unsigned char cUserInfoNum,
                                              unsigned char cCommand,
                                              unsigned char cError)						
{
	// ´Ù¸¥ À¯Àúµé¿¡°Ô ÀÚ½ÅÀÌ Ãß°¡µÇ¾ú´Ù´Â ¸Þ½ÃÁö¸¦ ´øÁø´Ù.
    
    CNetworkMsgPool& networkMsgPool = CNetworkMsgPool::GetInstance();
    
    CNetworkMsgBlock* lpBuffer = networkMsgPool.GetNetworkMsgBlock(
        sizeof(ServerManage::UserCommand) + sizeof(ServerManage::UserInfo) * cUserInfoNum, INET_Addr());
		
	CNetworkMsgBlock* lpCompressedBuffer = networkMsgPool.GetNetworkMsgBlock(
        CMiniLZO::GetLeastCompressBuffer(sizeof(ServerManage::UserCommand) + 
        sizeof(ServerManage::UserInfo) * cUserInfoNum), INET_Addr());

	if(0 != lpBuffer && 0 != lpCompressedBuffer)
	{
		ServerManage::UserCommand*	lpUserCommand	= reinterpret_cast<ServerManage::UserCommand*>(lpBuffer->wr_ptr());
		ServerManage::UserInfo*		lpFirstUserInfo	= reinterpret_cast<ServerManage::UserInfo*>(lpUserCommand + 1);	
		ServerManage::UserInfo*		lpLastUserInfo	= lpFirstUserInfo + cUserInfoNum;

		lpUserCommand->cUserInfoNum = cUserInfoNum;			
		std::copy(lpUserInfo, lpUserInfo + cUserInfoNum, lpFirstUserInfo);

		lpBuffer->wr_ptr(sizeof(ServerManage::UserCommand) + sizeof(ServerManage::UserInfo) * cUserInfoNum);

		if(lpCompressedBuffer->WrapCompress(lpBuffer->rd_ptr(), (unsigned short)lpBuffer->length(), 
			cCommand, 0, cError))
		{
			networkMsgPool.FreeNetworkMsgBlock(lpBuffer);
			theApp.GetEventHandlerMgr().SendPacket(lpHandler, lpCompressedBuffer);
			return true;
		}
	}

    networkMsgPool.FreeNetworkMsgBlock(lpBuffer);
	networkMsgPool.FreeNetworkMsgBlock(lpCompressedBuffer);
	return false;
}

/// \brief °ü¸®¼­¹ö ÀÎÁõ Ack
void CManagerServerEventHandler::RecvAuthAck(PktBase* lpPktBase, INET_Addr& peerAddr)
{
	CString strErrFormat;

	CLoginDlg* lpLoginDlg =
			static_cast<CLoginDlg*>(theApp.GetRegisteredWindow(IDD_LOGINDLG));

	if(lpPktBase->GetLen() < sizeof(ServerManage::UserCommand))
	{
		ERRLOG3(g_Log, _T("DP:0x%p/Cmd:0x%p/Invalid packet size : %d"),
			this, lpPktBase->GetCmd(), lpPktBase->GetLen());
	}
	else if(0 != lpPktBase->GetError())
	{	
		switch(lpPktBase->GetError())
		{
		case ServerManage::AUTHORIZE_FAILED:
			strErrFormat = _T("ManagerServer Auth Failed: AUTHORIZE_FAILED");
			break;
		case ServerManage::CANNOT_AUTHORIZE_NOT_USER:
			strErrFormat = _T("ManagerServer Auth Failed: CANNOT_AUTHORIZE_NOT_USER");
			break;
		case ServerManage::CANNOT_AUTHORIZE_INVALID_PASSWORD:
			strErrFormat = _T("ManagerServer Auth Failed: CANNOT_AUTHORIZE_INVALID_PASSWORD");
			break;
		case ServerManage::CANNOT_AUTHORIZE_INVALID_IPADDRESS:
			strErrFormat = _T("ManagerServer Auth Failed: CANNOT_AUTHORIZE_INVALID_IPADDRESS");
			break;
		case ServerManage::ALREADY_LOGINED:
			strErrFormat = _T("ManagerServer Auth Failed: ALREADY_LOGINED");
			break;
		default:
			break;
		}
	}
	else
	{
		lpLoginDlg->OnOK();
		strErrFormat = GetMyINIString("LOCAL_STRING", "STRING_040");
	}

	theApp.ReportResult(strErrFormat);
}

/// \brief °ü¸®¼­¹ö¿¡¼­ ¸¶Áö¸·À¸·Î ÇιÞÀº ½Ã°¢ °»½Å
void CManagerServerEventHandler::RecvPing(PktBase* lpPktBase, INET_Addr& peerAddr)
{
    m_dwLastPingRecvTime = timeGetTime();
}

}