#include "stdafx.h"

#include "MonitoringTool.h"
#include "MonitoringToolDlg.h"
#include "ChatServerEventHandler.h"
#include "MonitoringToolSetup.h"
#include "MonitoringToolLog.h"
#include "WhisperDlg.h"
#include "ChattingPage.h"
#include "LoginDlg.h"
#include "GlobalFunc.h"

#include <Log/ServerLog.h>
#include <Stream/Buffer/Buffer.h>
#include <Utility/Setup/ServerSetup.h>
#include <Network/Packet/WrapPacket.h>
#include <Network/Packet/ChatToolPacketCmd.h>
#include <Network/Packet/PacketStruct/CharCommunityPacket.h>
#include <mmsystem.h>

const char*	szChatSection = _T("CHAT_SERVER_CONNECTION");
const unsigned int MAX_CHAT = CMonitoringToolSetup::GetInstance().GetInt(szChatSection, _T("CHAT_SERVER_NUM"));


ClientNet::CChatServerEventHandler::CChatServerEventHandler(unsigned int nServerGroup)
:   m_nServerGroup(nServerGroup), m_dwLastPingRecvTime(0)
{
}

bool ClientNet::CChatServerEventHandler::Connect()
{
	char szKey[MAX_PATH];
	unsigned int nServerGroup;
	const char* szIP;

	CMonitoringToolSetup Setup = CMonitoringToolSetup::GetInstance();

	for(unsigned int nIndex = 0; nIndex < MAX_CHAT; ++nIndex)
	{
		_snprintf(szKey, MAX_PATH, "CHAT_SERVER_IP_%02d", nIndex);
		szIP = Setup.GetString(szChatSection, szKey);
		
		_snprintf(szKey, MAX_PATH, "CHAT_SERVER_INDEX_%02d", nIndex);
		nServerGroup = Setup.GetInt(szChatSection, szKey);

        ClientNet::CClientEventHandlerMgr& eventHandlerMgr = theApp.GetEventHandlerMgr();
        ClientNet::CChatServerEventHandler* lpEventHandler = new ClientNet::CChatServerEventHandler(nServerGroup);

        if (!eventHandlerMgr.Connect(
			INET_Addr(szIP, CServerSetup::ChatServerMonitoringToolListen), lpEventHandler))
        {
            delete lpEventHandler; 
            return false;
        }
	}

	return true;
}

int ClientNet::CChatServerEventHandler::OnOpen(int iErrorCode)
{
	if(0 == iErrorCode)
	{
		theApp.RegisterChatHandler(m_nServerGroup, this);

        INET_Addr& addr = GetPeerAddress();
		
		INFLOG3(g_Log, _T("Connect Session (ChatServer) : DP:0x%p, %s:%d"),	
            this, addr.get_addr_string(), addr.get_port_in());

		theApp.ReportResult(GetMyINIString("LOCAL_STRING", "STRING_031"));
	}
	else
	{		
		ERRLOG1(g_Log, _T("Connect Session Failed (ChatServer): Err- %d"), iErrorCode);
		theApp.ReportResult(GetMyINIString("LOCAL_STRING", "STRING_032"));
	}

	m_dwLastPingRecvTime = timeGetTime();	
	return 0;
}

int ClientNet::CChatServerEventHandler::OnClose()
{
	theApp.RemoveChatHandler(m_nServerGroup, this);

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

    return 0;
}

int ClientNet::CChatServerEventHandler::OnDispatch(PktBase* lpPktBase, INET_Addr& peerAddr)
{
	bool bResult = false;
	
	switch(lpPktBase->GetCmd())
	{
	case ChatToolCMD::Authorize:    RecvAuthAck(lpPktBase, peerAddr);     break;
	case ChatToolCMD::ChatSend:		RecvChatData(lpPktBase, peerAddr);    break;
	case ChatToolCMD::ChatPing:		RecvChatPing(lpPktBase, peerAddr);    break;
    case ChatToolCMD::ChatRequest:  RecvChatRequest(lpPktBase, peerAddr); break;
	default:    break;
	}

	return 0;
}

/// \brief äÆü­¹ö·Î ÀÎÁõ ÆÐŶ Àü¼Û
/// \param szUserID ·Î±×ÀÎ °èÁ¤¸í
/// \param szPass ·Î±×ÀÎ Æнº¿öµå
/// \return ÆÐŶ Àü¼Û ó¸® ¼º°ø ¿©ºÎ
bool ClientNet::CChatServerEventHandler::SendAuthPkt(char* szUserID, char* szPass)
{
	CMonitoringToolSetup Setup = CMonitoringToolSetup::GetInstance();
	char szKey[MAX_PATH];

	for(unsigned int nIndex = 0; nIndex < MAX_CHAT; ++nIndex)
	{
		_snprintf(szKey, MAX_PATH, "CHAT_SERVER_INDEX_%02d", nIndex);

		CChatServerEventHandler* lpHandler =
			theApp.GetChatServerHandler(Setup.GetInt(szChatSection, szKey, 100));

		if(0 != lpHandler)
		{
			CNetworkMsgBlock* lpMsg =
                CNetworkMsgPool::GetInstance().GetNetworkMsgBlock(
                sizeof(ChatToolPkt::Authorize), INET_Addr());

			if(0 != lpMsg)
			{
				ChatToolPkt::Authorize* lpAuthorize =
					reinterpret_cast<ChatToolPkt::Authorize*>(lpMsg->wr_ptr());

				_snprintf(lpAuthorize->m_szUserID, ChatToolPkt::MAX_USER_ID, szUserID);
                lpAuthorize->m_szUserID[ChatToolPkt::MAX_USER_ID - 1] = 0;

				_snprintf(lpAuthorize->m_szPassword, ChatToolPkt::MAX_PASSWORD, szPass);
                lpAuthorize->m_szPassword[ChatToolPkt::MAX_PASSWORD - 1] = 0;

				if(lpMsg->WrapCrypt(sizeof(ChatToolPkt::Authorize), ChatToolCMD::Authorize, 0))
				{
					theApp.GetEventHandlerMgr().SendPacket(lpHandler, lpMsg);
				}
				else
				{
                    CNetworkMsgPool::GetInstance().FreeNetworkMsgBlock(lpMsg);
				}
			}	
			Sleep(1000);
		}
		else
		{
			ERRLOG1(g_Log, "Failed get session(ChatServer): Group- %d", Setup.GetInt(szChatSection, szKey, 100));
			theApp.ReportResult(GetMyINIString("LOCAL_STRING", "STRING_030"));
		}
	}
	return true;
}

/// \brief ÀÎÁõ ÆÐŶ Ack ó¸®
/// \return ÆÐŶ Àü¼Û ¼º°ø ¿©ºÎ
bool ClientNet::CChatServerEventHandler::RecvAuthAck(PktBase* lpPktBase, INET_Addr& peerAddr)
{	
	CLoginDlg* lpLoginDlg = static_cast<CLoginDlg*>(theApp.GetRegisteredWindow(IDD_LOGINDLG));
	if(NULL != lpLoginDlg)
	{
		ChatToolPkt::Authorize* lpAuthorize = static_cast<ChatToolPkt::Authorize*>(lpPktBase);

		if(1 == lpAuthorize->m_cResult)
		{
			theApp.ReportResult(GetMyINIString("LOCAL_STRING", "STRING_034"));
			theApp.SetAuthorized(true);

			CString strLoginedName;
			strLoginedName.Format("%s", lpAuthorize->m_szUserID);
			theApp.SetLoginedName(strLoginedName);

			lpLoginDlg->OnOK();

			CChattingPage* lpChatPage =
				static_cast<CChattingPage*>(theApp.GetRegisteredWindow(IDD_CHATTINGPAGE));

			if (NULL != lpChatPage)
			{
				lpChatPage->SetLoginedNameEdit(strLoginedName);
				lpChatPage->CheckDlgButton(IDC_GMLOGINED_CHK, BST_CHECKED);
			}

			unsigned char szOption[ChatToolPkt::ChatOption::MAX_OPTION];
			std::fill_n(szOption, int(ChatToolPkt::ChatOption::MAX_OPTION), 1);

			SendChatOptPkt(m_nServerGroup, szOption, ChatToolPkt::ChatOption::MAX_OPTION);
		}
		else
		{	
			theApp.ReportResult(GetMyINIString("LOCAL_STRING", "STRING_035"));
		}
	}

	return true;
}

/// \brief äÆà ¸Þ¼¼Áö º¸³»±â(¿ÜÄ¡±â, ±Ó¼Ó¸»µî)
/// \param nServerGroup Àü¼ÛÇÒ ¼­¹ö±º
/// \param cChatType Àü¼ÛÇÒ ¸Þ¼¼ÁöÀÇ Å¸ÀÔ
/// \param cTargetType ¸Þ¼¼Áö¸¦ ¹ÞÀ» ´ë»ó ŸÀÔ
/// \param dwTargetUID ¸Þ¼¼Áö¸¦ ¹ÞÀ» ´ë»óÀÇ UID
/// \param dwMessageID ¸Þ¼¼ÁöÀÇ °íÀ¯ ID (Ack¸¦ ¹ÞÀ»¶§ È°¿ë)
/// \param strGMName ¸Þ¼¼Áö¸¦ º¸³»´Â GMÀÇ ·Î±×ÀÎ °èÁ¤¸í
/// \param strTargetName ¸Þ¼¼Áö¸¦ ¹ÞÀ» ´ë»óÀÇ °èÁ¤¸í ¶Ç´Â ij¸¯Å͸í
/// \param strMsg ¸Þ¼¼Áö ³»¿ë
/// \return ÆÐŶ Àü¼Û ó¸® ¼º°ø ¿©ºÎ
bool ClientNet::CChatServerEventHandler::SendChatReqPkt(unsigned int nServerGroup, 
                                                        unsigned char cChatType,
                                                        unsigned char cTargetType,
                                                        unsigned long dwTargetUID,
                                                        unsigned long dwMessageID,
                                                        const CString& strGMName,
														const CString& strTargetName,
														const CString& strMsg)
{
	if (!theApp.IsAuthorized())
	{
		return false;
	}

	CClientEventHandler* lpHandler = theApp.GetChatServerHandler(nServerGroup);
	if (0 == lpHandler)
	{
		return false;
	}

    unsigned  char cMsgLen = static_cast<unsigned char>(strMsg.GetLength());

	CNetworkMsgBlock* lpMsg =
        CNetworkMsgPool::GetInstance().GetNetworkMsgBlock(
        sizeof(ChatToolPkt::ChatRequest) + cMsgLen + 1, INET_Addr());

	if(0 != lpMsg)
	{
		ChatToolPkt::ChatRequest* lpChatReq =
			reinterpret_cast<ChatToolPkt::ChatRequest*>(lpMsg->wr_ptr());

		memset(lpChatReq, 0, sizeof(ChatToolPkt::ChatRequest));

        lpChatReq->m_dwUID = dwTargetUID;           // ´ë»ó ij¸¯ÅÍ UID (TargetNameÀÌ ¾øÀ» °æ¿ì »ç¿ë)
        lpChatReq->m_cTargetType = cTargetType;     // UID / CharName / AccountName Áß Çϳª
        lpChatReq->m_dwMessageID = dwMessageID;

		lpChatReq->m_cChatType   = cChatType;
		lpChatReq->m_cChatMsgLen = cMsgLen + 1;		// +1 : ³Î ¹®ÀÚ »çÀÌÁî

		_snprintf(lpChatReq->m_szAdminName, ChatToolPkt::MAX_CHAR_NAME - 1, "%s", strGMName);
		lpChatReq->m_szAdminName[ChatToolPkt::MAX_CHAR_NAME - 1] = 0;

		_snprintf(lpChatReq->m_szTargetName, ChatToolPkt::MAX_CHAR_NAME - 1, "%s", strTargetName);
		lpChatReq->m_szTargetName[ChatToolPkt::MAX_CHAR_NAME - 1] = 0;

		memcpy(reinterpret_cast<char*>(lpChatReq + 1), strMsg, cMsgLen);
		*(reinterpret_cast<char*>(lpChatReq + 1) + cMsgLen) = 0;

		if (lpMsg->WrapCrypt(sizeof(ChatToolPkt::ChatRequest) + lpChatReq->m_cChatMsgLen,
			ChatToolCMD::ChatRequest, 0))
		{
            theApp.GetEventHandlerMgr().SendPacket(lpHandler, lpMsg);
			return true;
		}

        CNetworkMsgPool::GetInstance().FreeNetworkMsgBlock(lpMsg);
	}	

	return true;
}

/// \brief äÆà °ü·Ã µ¥ÀÌÅÍ Ã³¸®
/// \return ÆÐŶ ó¸® ¼º°ø ¿©ºÎ
bool ClientNet::CChatServerEventHandler::RecvChatData(PktBase* lpPktBase, INET_Addr& peerAddr)
{
	ChatToolPkt::ChatDataSend* lpChatDataSend =
		reinterpret_cast<ChatToolPkt::ChatDataSend*>(lpPktBase);

	CChattingPage* lpPage =
			static_cast<CChattingPage*>(theApp.GetRegisteredWindow(IDD_CHATTINGPAGE));

	CFilterUserDialog* lpFilter =
			static_cast<CFilterUserDialog*>(theApp.GetRegisteredWindow(IDD_FILTERDIALOG));

	CGMReportDialog* lpGMReport =
			static_cast<CGMReportDialog*>(theApp.GetRegisteredWindow(IDD_GMREPORTDIALOG));

	if (NULL != lpPage)
	{
		if(PktChat::GMREPORT == lpChatDataSend->m_cChatType)
		{
			if(lpGMReport)
			{
				lpGMReport->AddMessage(lpChatDataSend);
			}
		}
		else
		{
			// ¿©±â¼­ ÇÊÅ͸µ
			if(lpFilter)
			{
				lpFilter->CheckMessage(lpChatDataSend);
			}

			if (PktChat::WHISPER == lpChatDataSend->m_cChatType)
			{
				if ((0 == theApp.GetLoginedName().Compare(lpChatDataSend->m_szTargetName))
					|| (0 == theApp.GetLoginedName().Compare(lpChatDataSend->m_szSenderName)))
				{
					CWhisperDlg* lpWhisperDlg = lpPage->GetWhisperDlg(lpChatDataSend->m_dwUID);
					
					if (NULL != lpWhisperDlg)
					{
						lpWhisperDlg->ParseChatData(lpChatDataSend);
					}
					else
					{
						bool bGMSender = false;
						// sender À¯Àú°¡ GMÀ̸é 
						if(0 == theApp.GetLoginedName().Compare(lpChatDataSend->m_szSenderName))
							bGMSender = true;

						// µÎ¹ø° ¸Å°³º¯¼ö´Â À¯Àú°¡ ¿î¿µÀÚ¿¡°Ô ¸»À» °Å´Â °æ¿ì true
						lpPage->ParseChatData(lpChatDataSend, true, bGMSender);	
					}
				}
				else
				{
					lpPage->ParseChatData(lpChatDataSend);
				}
			}
			else
			{
				lpPage->ParseChatData(lpChatDataSend);
			}
		}		
	}

	CMonitoringToolLog::GetInstance().WriteChatLog(lpChatDataSend);

	return true;
}

/// \brief ¸ð´ÏÅ͸µ ÇÒ Ã¤Æà ŸÀÔ º¸³»±â
/// \param nServerGroup ÆÐŶÀ» Àü¼ÛÇÒ ¼­¹ö±º
/// \param szOption ¸ð´ÏÅ͸µÇÒ ¿É¼Ç
/// \param cOptionNum ¸ð´ÏÅ͸µ ÇÏ°íÀÚ ¼±ÅÃÇÑ Å¸ÀÔÀÇ °³¼ö
/// \return ÆÐŶ Àü¼Û ó¸® ¼º°ø ¿©ºÎ
bool ClientNet::CChatServerEventHandler::SendChatOptPkt(unsigned int nServerGroup, 
														unsigned char* szOption, unsigned char cOptionNum)
{
	if (true != theApp.IsAuthorized())
	{
		return false;
	}

	cOptionNum = std::min(cOptionNum, unsigned char(ChatToolPkt::ChatOption::MAX_OPTION));

	CChatServerEventHandler* lpHandler = theApp.GetChatServerHandler(nServerGroup);

	if(0 == lpHandler)
	{
		ERRLOG1(g_Log, "Failed get session(ChatServer): Group- %u", nServerGroup);
		theApp.ReportResult(GetMyINIString("LOCAL_STRING", "STRING_030"));

		return false;
	}

	CNetworkMsgBlock* lpMsg = 
        CNetworkMsgPool::GetInstance().GetNetworkMsgBlock(
        sizeof(ChatToolPkt::ChatOption), INET_Addr());

	if(0 != lpMsg)
	{
		ChatToolPkt::ChatOption* lpOption =
			reinterpret_cast<ChatToolPkt::ChatOption*>(lpMsg->wr_ptr());

		memcpy(lpOption->m_cChatOption, szOption, sizeof(unsigned char) * cOptionNum);

		if(lpMsg->WrapCrypt(sizeof(ChatToolPkt::ChatOption), ChatToolCMD::ChangeOption, 0))
		{
			theApp.GetEventHandlerMgr().SendPacket(lpHandler, lpMsg);
			return true;
		}

        CNetworkMsgPool::GetInstance().FreeNetworkMsgBlock(lpMsg);
	}

	return true;
}

///	\brief ¿î¿µÀÚÀÇ Á¢¼Ó »óÅ ¼³Á¤
///	\param nServerGroup »óŸ¦ ´Ù½Ã ¼³Á¤ÇÒ ¼­¹ö±º
///	\param strAdminName »óŸ¦ ¼³Á¤ÇÒ ¿î¿µÀÚÀÇ °èÁ¤¸í
///	\param cStatus ·Î±×ÀÎ ¶Ç´Â ·Î±×¾Æ¿ô »óÅÂ
///	\return ÆÐŶ Àü¼Û ó¸® ¼º°ø ¿©ºÎ
bool ClientNet::CChatServerEventHandler::SendAdminStatus(unsigned int nServerGroup,
														 const CString& strAdminName, unsigned char cStatus)
{
	if(!theApp.IsAuthorized())
	{
		return false;
	}

	CChatServerEventHandler* lpHandler = theApp.GetChatServerHandler(nServerGroup);

	if(0 == lpHandler)
	{
		ERRLOG1(g_Log, "Failed get session(ChatServer): Group- %u", nServerGroup);
		theApp.ReportResult(GetMyINIString("LOCAL_STRING", "STRING_030"));

		return false;
	}

	CNetworkMsgBlock* lpMsg = 
		CNetworkMsgPool::GetInstance().GetNetworkMsgBlock(sizeof(ChatToolPkt::ChatAdminStatus), INET_Addr());

	if(0 != lpMsg)
	{
		ChatToolPkt::ChatAdminStatus* lpAdminStatus =
			reinterpret_cast<ChatToolPkt::ChatAdminStatus*>(lpMsg->wr_ptr());

		strncpy(lpAdminStatus->m_szChatAdminName, strAdminName, ChatToolPkt::MAX_USER_ID);
		lpAdminStatus->m_cChangeStatus = cStatus;

		if(lpMsg->WrapCrypt(sizeof(ChatToolPkt::ChatAdminStatus), ChatToolCMD::ChatAdminStatus, 0))
		{
			theApp.GetEventHandlerMgr().SendPacket(lpHandler, lpMsg);
			return true;
		}

        CNetworkMsgPool::GetInstance().FreeNetworkMsgBlock(lpMsg);
	}

	return true;
}

/// \brief ÇÎ ÆÐŶÀ» ¸¶Áö¸·À¸·Î ¹ÞÀº ½Ã°£ °»½Å
/// \return ÆÐŶ ó¸® ¼º°ø ¿©ºÎ
bool ClientNet::CChatServerEventHandler::RecvChatPing(PktBase* lpPktBase, INET_Addr& peerAddr)
{	
	m_dwLastPingRecvTime = timeGetTime();
	return true;
}

/// \brief äÆà ¿äû¿¡ ´ëÇÑ Ackó¸®
/// \return ÆÐŶ ó¸® ¼º°ø ¿©ºÎ
bool ClientNet::CChatServerEventHandler::RecvChatRequest(PktBase* lpPktBase, INET_Addr& peerAddr)
{
    ChatToolPkt::ChatRequest* lpChatRequest = 
        reinterpret_cast<ChatToolPkt::ChatRequest*>(lpPktBase);

    switch (lpChatRequest->GetError())
    {
	case 0:
		{
			// ¸Þ¼¼Áö ID¿¡ ¸ÅĪµÇ´Â âÀÌ ¶ç¿öÁ®ÀÖ´Ù¸é Ack·Î ¹ÞÀº UID¸¦ ¼ÂÆÃÇØÁØ´Ù.
			CChattingPage* lpPage =
				static_cast<CChattingPage*>(theApp.GetRegisteredWindow(IDD_CHATTINGPAGE));

			CWhisperDlg* lpDlg = lpPage->GetAccountDlg(lpChatRequest->m_dwMessageID);

			if ((NULL != lpDlg) && (0 == lpDlg->GetKeyUID()))
			{
				lpDlg->SetKeyUID(lpChatRequest->m_dwUID, lpChatRequest->m_dwCID);
			}
		}

		break;

    case ChatToolPkt::ChatRequest::PACKET_ERROR:
        // ÆÐŶ¿¡ ¿¡·¯°¡ ÀÖ´Â °æ¿ì. ¾î·°Ç Ack´Â ¿ÔÀ½ÀÌ¿ä...
        break;

    case ChatToolPkt::ChatRequest::NONE_CHARACTER:
        theApp.ReportResult(GetMyINIString("LOCAL_STRING", "STRING_043"));
        break;
    }

    return true;
}