#include "stdafx.h"

#include <Network/Dispatch/ParseUtils.h>
#include <Network/Dispatch/Chat/ChatDispatch.h>

#include <Network/Packet/ChatPacket.h>
#include <Network/Packet/PacketCommand.h>
#include <Network/Packet/PacketStruct/CharCommunityPacket.h>

#include <Creature/CreatureManager.h>
#include <Creature/Character/Character.h>

#include <Map/FieldMap/Cell.h>

#include <Utility/Math/Math.h>

#include "SendCharCommunity.h"
#include "ParseCharChat.h"
#include "GameClientDispatch.h"


bool GameClientParsePacket::ParseCharWhisper(CGameClientDispatch& GameClientDispatch, PktBase* lpPktBase)
{
    int nPacketLength = lpPktBase->GetLen();
    if (nPacketLength <= sizeof(PktWh))
    {
        ERRLOG3(g_Log, "UID:%10u/IP:%15s/±Ó¼Ó¸» ÆÐŶ ±æÀÌ ÀÌ»ó. ±æÀÌ:%d", 
            GameClientDispatch.GetUID(), GameClientDispatch.GetRemoteAddr().get_addr_string(), nPacketLength);

        return false;
    }    

    // ±Ó¼Ó¸»À» ¹ÞÀ¸¸é, ¹Ù·Î äÆü­¹ö·Î RelayÇÑ´Ù.
    PktWh* lpPktWh = reinterpret_cast<PktWh*>(lpPktBase);
    char* szMessagePos = reinterpret_cast<char*>(lpPktWh + 1);
    
    // ¹öÆÛ ¿À¹öÇ÷ο츦 ¸·±â À§Çؼ­, ¸¶Áö¸·¿¡ ³Î ¹®ÀÚ¸¦ ºÙÀδÙ.
    szMessagePos[nPacketLength - sizeof(PktWh) - 1] = 0;

    CCharacter* lpSender = GameClientDispatch.GetCharacter();
    if (NULL != lpSender)
    {
		// äÆà ±ÝÁö
		if (true == lpSender->IsChatBan())
		{
			CGameClientDispatch* lpDispatch = lpSender->GetDispatcher();
	        if (NULL != lpDispatch)
			{
				char* lpBuffer = lpDispatch->GetSendStream().GetBuffer(sizeof(PktWh));
				if (NULL != lpBuffer)
				{
					PktWh* lpPktWhAck = reinterpret_cast<PktWh*>(lpBuffer);

					strncpy(lpPktWhAck->m_SenderName, lpPktWh->m_SenderName, CHAR_INFOST::MAX_NAME_LEN);
					strncpy(lpPktWhAck->m_RecverName, lpPktWh->m_RecverName, CHAR_INFOST::MAX_NAME_LEN);

					return lpDispatch->GetSendStream().WrapCrypt(
						sizeof(PktWh), CmdCharWhisper, 0, PktWh::FAIL_CHAT_BAN);
				}
			}

			return true;
		}

	    unsigned long   dwOwnerCID  = lpSender->GetCID();
        CCharacter* lpRecver = CCreatureManager::GetInstance().GetCharacter(lpPktWh->m_RecverName);
		if(lpRecver)
		{
			// edith 2009.04.04 ³ªÀÇ Ban¸®½ºÆ®¿¡ µî·ÏµÇ¾îÀÖÀ¸¸é ¸ðµç äÆà °ÅºÎÇÏ°Ô Ã³¸®
	//		lpRecver->GetRejectOption().Reject.m_Friend || 
			if ( lpRecver->GetBanList().IsBan(dwOwnerCID, lpPktWh->m_SenderName ) )
			{
				// ¹ê¸®½ºÆ®¿¡ µî·ÏµÇ¾îÀÖÀ»°æ¿ì ±Ó¸»°ÅºÎ
				CGameClientDispatch* lpDispatch = lpSender->GetDispatcher();
				if (NULL != lpDispatch)
				{
					char* lpBuffer = lpDispatch->GetSendStream().GetBuffer(sizeof(PktWh));
					if (NULL != lpBuffer)
					{
						PktWh* lpPktWhAck = reinterpret_cast<PktWh*>(lpBuffer);

						strncpy(lpPktWhAck->m_SenderName, lpPktWh->m_SenderName, CHAR_INFOST::MAX_NAME_LEN);
						strncpy(lpPktWhAck->m_RecverName, lpPktWh->m_RecverName, CHAR_INFOST::MAX_NAME_LEN);

						return lpDispatch->GetSendStream().WrapCrypt(
							sizeof(PktWh), CmdCharWhisper, 0, PktWh::FAIL_REJECT);
					}
				}

				return true;
			}
		}

		// ä±ÝÀ» Á¦¿ÜÇÑ ¿¡·¯ 󸮴 äÆà ¼­¹ö¿¡¼­ ó¸®ÇÕ´Ï´Ù. 
		// (ä±Ý Á¤º¸µµ äÆà ¼­¹ö¿¡ Àü´ÞµÇ¸é ÀÏ·üÀûÀ¸·Î ó¸®ÇÏ´Â°Ô ÁÁÀ» °Í °°½À´Ï´Ù.)

        GET_SINGLE_DISPATCH(lpChatDispatch, CChatDispatch, 
            CChatDispatch::GetDispatchTable());

        if (0 != lpChatDispatch)
        {
            const Position& pos = lpSender->GetCurrentPos();
			
            CChatRequestPacket chatReqPacket(szMessagePos, 
                PktChat::WHISPER, 0, lpSender->GetUID(), lpSender->GetCID(), 
                static_cast<unsigned short>(pos.m_fPointX), 
                static_cast<unsigned short>(pos.m_fPointY),
                static_cast<unsigned short>(pos.m_fPointZ),
                lpPktWh->m_RecverName, 1);

            if (chatReqPacket.IsValid())
            {
                return lpChatDispatch->GetSendStream().PutBuffer(
                    chatReqPacket.GetCompressedPacket(),
                    chatReqPacket.GetCompressedSize(), CmdCharChat);
            }
        }
    }

    return false;
}


bool GameClientParsePacket::ParseCharChat(CGameClientDispatch& GameClientDispatch, PktBase* lpPktBase)
{    
    //  °¡´ÉÇÑ Ã¤Æà ¸ñ·Ï

    //  ¼­¹ö°£ Åë½ÅÀÌ ÇÊ¿ä ¾ø´Â äÆà (·Î±×¸¸ ³²±è)

    //  NORMAL		        = 0,    // ÇöÀç ij¸¯ÅÍ ÁÂÇ¥¸¦ °¡Áö°í ÆÇ´Ü.
    //  ADMIN_NORMAL_CHAT   = 8,    // ¿î¿µÀÚ Åë»ó äÆà     (Ack·Î¸¸ »ç¿ë)
    //  STALL		        = 6,    // ³ëÁ¡»ó ¸»Ç챉    (À̸§ char[16] * m_cNum - MAX 10°³)	
    //  CLIENT_LOG	        = 5,
	//	FIND_PARTY			= 14	// ÆÄƼ ã±â
	//	DICE				= 16	// ÁÖ»çÀ§

    //  ¼­¹ö°£ Åë½ÅÀÌ ÇÊ¿äÇÑ Ã¤ÆÃ

    //  PARTY		        = 1,    // ÆÄƼ ¸»Çϱâ
    //  FRIEND		        = 2,    // Ä£±¸ ¸»Ç챉      (À̸§ char[16] * m_cNum - MAX 100°³)
    //  GUILD	            = 3,    // ±æµå ¸»Çϱâ
    //  SHOUT               = 7,    // Àüü ¸»Çϱâ

    //  ADMIN_SHOUT         = 9,    // ¿î¿µÀÚ ¿ÜÄ¡±â        (Ack·Î¸¸ »ç¿ë)
    //  WHISPER             = 10,   // ÀÌ ¹øÈ£´Â ¾²ÀÌÁö ¾Ê´Â´Ù.Whisper´Â º°µµÀÇ ÆÐŶÀ» »ç¿ëÇϱ⠶§¹®ÀÌ´Ù. ´Ü, ·Î±×½Ã¿¡ ¾²ÀδÙ.

    int nPacketLength = lpPktBase->GetLen();
    if (nPacketLength <= sizeof(PktChat))
    {
        ERRLOG3(g_Log, "UID:%10u/IP:%15s ÆÐŶ ±æÀÌ°¡ ÀÌ»óÇÕ´Ï´Ù. ±æÀÌ:%d", 
            GameClientDispatch.GetUID(), GameClientDispatch.GetRemoteAddr().get_addr_string(), nPacketLength);

        return false;
    }

    PktChat* lpPktChat = reinterpret_cast<PktChat*>(lpPktBase);

    int nMinPacketSize = sizeof(PktChat) + sizeof(char) * CHAR_INFOST::MAX_NAME_LEN * lpPktChat->m_cNum;
    int nMaxPacketSize = nMinPacketSize + PktChat::PktChatMaxSize;

    if (nPacketLength < nMinPacketSize || nMaxPacketSize < nPacketLength)
    {
        ERRLOG3(g_Log, "UID:%10u/IP:%15s ÆÐŶ ±æÀÌ°¡ ÀÌ»óÇÕ´Ï´Ù. ±æÀÌ:%d", 
            GameClientDispatch.GetUID(), GameClientDispatch.GetRemoteAddr().get_addr_string(), nPacketLength);

        return false;
    }

    char* szNames   = reinterpret_cast<char*>(lpPktChat + 1);
    char* szMessage = szNames + sizeof(char) * CHAR_INFOST::MAX_NAME_LEN * lpPktChat->m_cNum;

    // ¹öÆÛ ¿À¹öÇ÷ο츦 ¸·±â À§Çؼ­, ¸¶Áö¸·¿¡ ³Î ¹®ÀÚ¸¦ ºÙÀδÙ.
    szMessage[nPacketLength - nMinPacketSize - 1] = 0;

    CCharacter* lpSender = GameClientDispatch.GetCharacter();

    if (NULL == lpSender)
		return true;

	// äÆà ±ÝÁö
	if (lpSender->IsChatBan())
	{
		if (lpPktChat->m_cCmd != PktChat::CLIENT_LOG)
		{
			CGameClientDispatch* lpDispatch = lpSender->GetDispatcher();
	        if (NULL != lpDispatch)
			{
				CChatPacket ErrorResult(szMessage, lpSender->GetCID(), 
					static_cast<PktChat::PktChatCmd>(lpPktChat->m_cCmd), 0, 0, PktChat::CHAT_BAN);

				if (ErrorResult.IsValid())
				{
					lpDispatch->GetSendStream().PutBuffer(
						ErrorResult.GetCompressedPacket(), 
						ErrorResult.GetCompressedSize(), CmdCharChat);
				}
			}

			return true;
		}
	}
    switch (lpPktChat->m_cCmd)
    {
		case PktChat::DICE:	// ÁÖ»çÀ§µµ µ¿ÀÏ
		{
			// ÁÖ»çÀ§¸é ·£´ýÀ¸·Î ¾ó¸¶³ª µ¹·È´ÂÁöÈ®ÀÎÇÑ´Ù.
			CHAR		seps[] = " ,\t\n" ;
			CHAR		*token, strCommand[ MAX_PATH ] ;

			strcpy( strCommand, szMessage ) ;

			token = strtok( strCommand, seps ) ;
			ULONG len = strlen( token ) + 1 ;

			int iTotal = Math::Convert::Atoi( &strCommand[ len ] );
			int iDice  = Math::Random::ComplexRandom(iTotal)+1;

			sprintf(szMessage, "%s %d %d", token, iTotal, iDice);

			// ÆÄƼ¸é »ó´ÜÀ¸·Î º¸³½´Ù.
			if( lpSender->GetPID() != 0)
			{
				break;
			}

            const unsigned long MAX_SQUARED_DISTANCE = 32 * 32; 
            CCell* lpSenderCell = lpSender->GetCellPos().m_lpCell;

            if (0 != lpSenderCell)
            {
                CChatPacket chatPacket(szMessage, lpSender->GetCID(),
                    static_cast<PktChat::PktChatCmd>(lpPktChat->m_cCmd), lpPktChat->m_usLang);

                if (chatPacket.IsValid())
                {
                    for(int nCount = 0; nCount < CCell::CONNECT_NUM; ++nCount)
                    {
                        CCell* lpSendCell = lpSenderCell->GetConnectCell(nCount);

                        if (0 != lpSendCell)
                        {
                            CCharacter* lpReceiver = lpSendCell->GetFirstCharacter();

                            while (0 != lpReceiver)
                            {
								// ³ªÀڽŵµ º¸³»°Ô ÇÏ´Â°Ô Æ²¸®´Ù.
                                if (lpSender->GetCurrentPos().GetSquaredDistance(
                                    lpReceiver->GetCurrentPos()) < MAX_SQUARED_DISTANCE)
                                {
                                    if (0 != lpSender->GetAdminLevel() || 
										lpSender->GetNation() == lpReceiver->GetNation())
                                    {
                                        CGameClientDispatch* lpDispatch = lpReceiver->GetDispatcher();
                                        if (NULL != lpDispatch)
                                        {

                                            lpDispatch->GetSendStream().PutBuffer(
                                                chatPacket.GetCompressedPacket(), 
                                                chatPacket.GetCompressedSize(), CmdCharChat);
                                        }
                                    }
                                }

                                lpReceiver = lpSendCell->GetNextCharacter();
                            }
                        }
                    }
                }                        
            }

            // À̸§ µîÀº äÆü­¹ö·Î º¸³»Áö ¾Ê´Â´Ù.
            lpPktChat->m_cNum = 0;
		}
		break;

        // ÀÌ °æ¿ì¿¡´Â, ¼­¹ö¿¡¼­ ÀÚüÀûÀ¸·Î ó¸®ÇÑ´Ù.
		case PktChat::NORMAL:
		case PktChat::ADMIN_NORMAL_CHAT:
        {            
            const unsigned long MAX_SQUARED_DISTANCE = 32 * 32; 

            CCell* lpSenderCell = lpSender->GetCellPos().m_lpCell;

            if (0 != lpSenderCell)
            {
                CChatPacket chatPacket(szMessage, lpSender->GetCID(), 
                    static_cast<PktChat::PktChatCmd>(lpPktChat->m_cCmd), lpPktChat->m_usLang);

                if (chatPacket.IsValid())
                {
                    for(int nCount = 0; nCount < CCell::CONNECT_NUM; ++nCount)
                    {
                        CCell* lpSendCell = lpSenderCell->GetConnectCell(nCount);

                        if (0 != lpSendCell)
                        {
                            CCharacter* lpReceiver = lpSendCell->GetFirstCharacter();

                            while (0 != lpReceiver)
                            {
                                if (lpSender != lpReceiver && 
                                    lpSender->GetCurrentPos().GetSquaredDistance(
                                    lpReceiver->GetCurrentPos()) < MAX_SQUARED_DISTANCE)
                                {
									// º¸³»´Â »ç¶÷À̳ª, ¹Þ´Â »ç¶÷À̳ª ¾îµå¹Î ·¹º§ÀÌ 0ÀÌ ¾Æ´Ï°Å³ª Á¾Á·ÀÌ
									// °°À»¶§¸¸ ´ëÈ­ °¡´É
                                    if (0 != lpSender->GetAdminLevel() || 0 != lpReceiver->GetAdminLevel() ||
										lpSender->GetNation() == lpReceiver->GetNation())
                                    {
                                        CGameClientDispatch* lpDispatch = lpReceiver->GetDispatcher();
                                        if (NULL != lpDispatch)
                                        {

                                            lpDispatch->GetSendStream().PutBuffer(
                                                chatPacket.GetCompressedPacket(), 
                                                chatPacket.GetCompressedSize(), CmdCharChat);
                                        }
                                    }
                                }

                                lpReceiver = lpSendCell->GetNextCharacter();
                            }
                        }
                    }
                }                        
            }

            // À̸§ µîÀº äÆü­¹ö·Î º¸³»Áö ¾Ê´Â´Ù.
            lpPktChat->m_cNum = 0;
        }
        break;

        // ÀÌ °æ¿ì¿¡´Â, ¼­¹ö¿¡¼­ ÀÚüÀûÀ¸·Î ó¸®ÇÑ´Ù.
		case PktChat::STALL:
		case PktChat::CAMP_SHOP:
        {            
            CChatPacket chatPacket(szMessage, lpSender->GetCID(), 
                static_cast<PktChat::PktChatCmd>(lpPktChat->m_cCmd), lpPktChat->m_usLang);

            if (chatPacket.IsValid())
            {
                for(; szNames < szMessage; szNames += sizeof(char) * CHAR_INFOST::MAX_NAME_LEN)
                {
                    // ¹öÆÛ ¿À¹öÇÃ·Î¿ì ¸·±â
                    szNames[CHAR_INFOST::MAX_NAME_LEN - 1] = 0;

                    CCharacter* lpReceiver = 
                        CCreatureManager::GetInstance().GetCharacter(szNames);

                    if (0 != lpReceiver && lpSender->GetNation() == lpReceiver->GetNation())
                    {
                        CGameClientDispatch* lpDispatch = lpReceiver->GetDispatcher();
                        if (NULL != lpDispatch)
                        {
                            lpDispatch->GetSendStream().PutBuffer(
                                chatPacket.GetCompressedPacket(),
                                chatPacket.GetCompressedSize(), CmdCharChat);
                        }                            
                    }
                }
            }

            // À̸§ µîÀº äÆü­¹ö·Î º¸³»Áö ¾Ê´Â´Ù.
            lpPktChat->m_cNum = 0;
        }
        break;

		// ÀÌ °æ¿ì¿¡´Â, ¼­¹ö¿¡¼­ ÀÚüÀûÀ¸·Î ó¸®ÇÑ´Ù.
		case PktChat::FIND_PARTY:
		{
			CChatPacket chatPacket(szMessage, lpSender->GetCID(), 
				static_cast<PktChat::PktChatCmd>(lpPktChat->m_cCmd), lpPktChat->m_usLang);

			if (chatPacket.IsValid())
			{
				CCreatureManager::GetInstance().SendFindPartyMsg(
                    lpSender->GetCID(), chatPacket.GetCompressedPacket(), chatPacket.GetCompressedSize());
			}

			// À̸§ µîÀº äÆü­¹ö·Î º¸³»Áö ¾Ê´Â´Ù.
			lpPktChat->m_cNum = 0;
		}
		break;

        // ·Î±×¸¦ Âï´Â´Ù.
		case PktChat::CLIENT_LOG:
		{
			RULLOG3(g_Log, "UID:%10u/CID:%10u/Ŭ¶óÀ̾ðÆ® ·Î±× : %s", 
				lpSender->GetUID(), lpSender->GetCID(), szMessage);

			// À̸§ µîÀº äÆü­¹ö·Î º¸³»Áö ¾Ê´Â´Ù.
			lpPktChat->m_cNum = 0;
		}
		break;

        // ´ÙÀ½ °æ¿ì¿£ äÆü­¹ö·Î °í½º¶õÈ÷ º¸³» ÁÖ¸é µÈ´Ù.
		case PktChat::PARTY:
		case PktChat::FRIEND:
		case PktChat::GUILD:        
		case PktChat::ADMIN_SHOUT:
			break;

		case PktChat::GMREPORT:
			break;

		case PktChat::TRADE:
		case PktChat::SHOUT:
			// edith 2008.05.27 ¿ÜÄ¡±â, Trade ¿ÜÄ¡±â Á¸¿¡ °°Àº Á¾Á·À¸·Î Á¦ÇÑ
			if (0 == lpSender->GetAdminLevel() && !lpSender->CanShout())
			{
				CGameClientDispatch* lpDispatch = lpSender->GetDispatcher();
	            if (NULL != lpDispatch)
				{
					CChatPacket ErrorResult(szMessage, lpSender->GetCID(), 
						static_cast<PktChat::PktChatCmd>(lpPktChat->m_cCmd), 0, 0, PktChat::SHOUT_TIMEOUT);

					if (ErrorResult.IsValid())
					{
						lpDispatch->GetSendStream().PutBuffer(
							ErrorResult.GetCompressedPacket(), 
							ErrorResult.GetCompressedSize(), CmdCharChat);
					}
				}

				return true;
			}
			break;
/*
		{
			// edith 2008.05.27 ¿ÜÄ¡±â, Trade ¿ÜÄ¡±â Á¸¿¡ °°Àº Á¾Á·À¸·Î Á¦ÇÑ
			if (0 == lpSender->GetAdminLevel() && !lpSender->CanShout())
			{
				CGameClientDispatch* lpDispatch = lpSender->GetDispatcher();
	            if (NULL != lpDispatch)
				{
					CChatPacket ErrorResult(szMessage, lpSender->GetCID(), 
						static_cast<PktChat::PktChatCmd>(lpPktChat->m_cCmd), 0, PktChat::SHOUT_TIMEOUT);

					if (ErrorResult.IsValid())
					{
						lpDispatch->GetSendStream().PutBuffer(
							ErrorResult.GetCompressedPacket(), 
							ErrorResult.GetCompressedSize(), CmdCharChat);
					}
				}

				return true;
			}
			else
			{
				CCell* lpSenderCell = lpSender->GetCellPos().m_lpCell;

				if (0 != lpSenderCell)
				{
					CChatPacket chatPacket(szMessage, lpSender->GetCID(),
						static_cast<PktChat::PktChatCmd>(lpPktChat->m_cCmd));

					if (chatPacket.IsValid())
					{
						for(int nCount = 0; nCount < CCell::CONNECT_NUM; ++nCount)
						{
							CCell* lpSendCell = lpSenderCell->GetConnectCell(nCount);

							if (0 != lpSendCell)
							{
								CCharacter* lpReceiver = lpSendCell->GetFirstCharacter();

								while (0 != lpReceiver)
								{
									if (0 != lpSender->GetAdminLevel() || 
										lpSender->GetNation() == lpReceiver->GetNation())
									{
										CGameClientDispatch* lpDispatch = lpReceiver->GetDispatcher();
										if (NULL != lpDispatch)
										{
											lpDispatch->GetSendStream().PutBuffer(
												chatPacket.GetCompressedPacket(), 
												chatPacket.GetCompressedSize(), CmdCharChat);
										}
									}

									lpReceiver = lpSendCell->GetNextCharacter();
								}
							}
						}
					}                        
				}

				// À̸§ µîÀº äÆü­¹ö·Î º¸³»Áö ¾Ê´Â´Ù.
				lpPktChat->m_cNum = 0;                    

				lpSender->Shouted();
			}
		}
		break;
*/
	}

    // ÀÏ´Ü Ã¤Æü­¹ö·Î´Â ¹«Á¶°Ç º¸³½´Ù.
    GET_SINGLE_DISPATCH(lpChatDispatch, CChatDispatch, CChatDispatch::GetDispatchTable());

    if (0 != lpChatDispatch)
    {
        const Position& pos = lpSender->GetCurrentPos();

        CChatRequestPacket chatReqPacket(szMessage, static_cast<PktChat::PktChatCmd>(lpPktChat->m_cCmd),
            lpPktChat->m_usLang, lpSender->GetUID(), lpSender->GetCID(), 
            static_cast<unsigned short>(pos.m_fPointX),
            static_cast<unsigned short>(pos.m_fPointY),
            static_cast<unsigned short>(pos.m_fPointZ),
            szNames, lpPktChat->m_cNum);

        // äÆü­¹ö·Î ÆÐŶÀ» º¸³½´Ù.
        if (chatReqPacket.IsValid())
        {
            lpChatDispatch->GetSendStream().PutBuffer(
                chatReqPacket.GetCompressedPacket(),
                chatReqPacket.GetCompressedSize(), CmdCharChat);                    
        }
    }

    return true;
}