#include "StdAfx.h"
#include "PythonChat.h"

#include "AbstractApplication.h"
#include "PythonCharacterManager.h"
#include "../eterbase/Timer.h"

int CPythonChat::TChatSet::ms_iChatModeSize = CHAT_TYPE_MAX_NUM;

const float c_fStartDisappearingTime = 5.0f;
const int c_iMaxLineCount = 5;

#if defined(__BL_MULTI_LANGUAGE_PREMIUM__)
#include "../eterPack/EterPackManager.h"
#include <fmt/format.h>

constexpr float c_fFlagTargetX = 22.0f * 0.9f;
constexpr float c_fFlagTargetY = 17.0f * 0.8f;

static int gs_mx = 0;
static int gs_my = 0;
static std::string gs_Country;
static BYTE gb_Empire = 0;

void CPythonChat::UpdateMousePos(int x, int y)
{
	gs_mx = x;
	gs_my = y;
	gs_Country = "";
	gb_Empire = 0;
}

const std::string& CPythonChat::GetCountry()
{
	return gs_Country;
}

BYTE CPythonChat::GetEmpire()
{
	return gb_Empire;
}
#endif

#if defined(__BL_MULTI_LANGUAGE_PREMIUM__)
#include "PythonSystem.h"
#endif

///////////////////////////////////////////////////////////////////////////////////////////////////

CDynamicPool<CPythonChat::SChatLine> CPythonChat::SChatLine::ms_kPool;

void CPythonChat::SetChatColor(UINT eType, UINT r, UINT g, UINT b)
{
	if (eType>=CHAT_TYPE_MAX_NUM)
		return;

	DWORD dwColor=(0xff000000)|(r<<16)|(g<<8)|(b);
	m_akD3DXClrChat[eType]=D3DXCOLOR(dwColor);
}

///////////////////////////////////////////////////////////////////////////////////////////////////

CPythonChat::SChatLine* CPythonChat::SChatLine::New()
{
	return ms_kPool.Alloc();
}

void CPythonChat::SChatLine::Delete(CPythonChat::SChatLine* pkChatLine)
{
	pkChatLine->Instance.Destroy();
#if defined(__BL_MULTI_LANGUAGE_PREMIUM__)
	if (pkChatLine->pCountryFlagImageInstance)
	{
		CGraphicExpandedImageInstance::Delete(pkChatLine->pCountryFlagImageInstance);
		pkChatLine->pCountryFlagImageInstance = NULL;
	}
	if (pkChatLine->pEmpireFlagImageInstance)
	{
		CGraphicExpandedImageInstance::Delete(pkChatLine->pEmpireFlagImageInstance);
		pkChatLine->pEmpireFlagImageInstance = NULL;
	}
	pkChatLine->strCountry = "";
	pkChatLine->bEmpire = 0;
#endif
	ms_kPool.Free(pkChatLine);
}

void CPythonChat::SChatLine::DestroySystem()
{
	ms_kPool.Destroy();
}

void CPythonChat::SChatLine::SetColor(DWORD dwID, DWORD dwColor)
{
	assert(dwID < CHAT_LINE_COLOR_ARRAY_MAX_NUM);

	if (dwID >= CHAT_LINE_COLOR_ARRAY_MAX_NUM)
		return;

	aColor[dwID] = dwColor;
}

void CPythonChat::SChatLine::SetColorAll(DWORD dwColor)
{
	for (int i = 0; i < CHAT_LINE_COLOR_ARRAY_MAX_NUM; ++i)
		aColor[i] = dwColor;
}

D3DXCOLOR & CPythonChat::SChatLine::GetColorRef(DWORD dwID)
{
	assert(dwID < CHAT_LINE_COLOR_ARRAY_MAX_NUM);

	if (dwID >= CHAT_LINE_COLOR_ARRAY_MAX_NUM)
	{
		static D3DXCOLOR color(1.0f, 0.0f, 0.0f, 1.0f);
		return color;
	}

	return aColor[dwID];
}

CPythonChat::SChatLine::SChatLine()
{
	for (int i = 0; i < CHAT_LINE_COLOR_ARRAY_MAX_NUM; ++i)
		aColor[i] = 0xff0000ff;
#if defined(__BL_MULTI_LANGUAGE_PREMIUM__)
	pCountryFlagImageInstance = NULL;
	pEmpireFlagImageInstance = NULL;
	bEmpire = 0;
#endif
}
CPythonChat::SChatLine::~SChatLine()
{
	Instance.Destroy();
#if defined(__BL_MULTI_LANGUAGE_PREMIUM__)
	if (pCountryFlagImageInstance)
	{
		CGraphicExpandedImageInstance::Delete(pCountryFlagImageInstance);
		pCountryFlagImageInstance = NULL;
	}
	if (pEmpireFlagImageInstance)
	{
		CGraphicExpandedImageInstance::Delete(pEmpireFlagImageInstance);
		pEmpireFlagImageInstance = NULL;
	}
#endif
}

///////////////////////////////////////////////////////////////////////////////////////////////////

int CPythonChat::CreateChatSet(DWORD dwID)
{
	m_ChatSetMap.emplace(dwID, TChatSet());
	return dwID;
}

void CPythonChat::UpdateViewMode(DWORD dwID)
{
	IAbstractApplication& rApp=IAbstractApplication::GetSingleton();

	float fcurTime = rApp.GetGlobalTime();

	TChatSet * pChatSet = GetChatSetPtr(dwID);
	if (!pChatSet)
		return;

	TChatLineList * pLineList = &(pChatSet->m_ShowingChatLineList);
	int iLineIndex = pLineList->size();
	int iHeight = -(int(pLineList->size()+1) * pChatSet->m_iStep);

	TChatLineList::iterator itor;
	for (itor = pLineList->begin(); itor != pLineList->end();)
	{
		TChatLine * pChatLine = (*itor);

		D3DXCOLOR & rColor = pChatLine->GetColorRef(dwID);

		float fElapsedTime = (fcurTime - pChatLine->fAppendedTime);
		if (fElapsedTime >= c_fStartDisappearingTime || iLineIndex >= c_iMaxLineCount)
		{
			rColor.a -= rColor.a / 10.0f;

			if (rColor.a <= 0.1f)
			{
				itor = pLineList->erase(itor);
			}
			else
			{
				++itor;
			}
		}
		else
		{
			++itor;
		}

		/////

		iHeight += pChatSet->m_iStep;
		--iLineIndex;

#if defined(__BL_MULTI_LANGUAGE_PREMIUM__)
		int iWidth = 0;
#if defined(__BL_MULTI_LANGUAGE_ULTIMATE__)
		if (pChatLine->pCountryFlagImageInstance && CPythonSystem::Instance().IsShowCountryFlag())
#else
		if (pChatLine->pCountryFlagImageInstance)
#endif
		{
			if (GetDefaultCodePage() == CP_ARABIC)
			{
				pChatLine->pCountryFlagImageInstance->SetPosition(pChatSet->m_ix + iWidth - c_fFlagTargetX, pChatSet->m_iy + iHeight);
				iWidth -= c_fFlagTargetX + 2;
			}
			else
			{
				pChatLine->pCountryFlagImageInstance->SetPosition(pChatSet->m_ix + iWidth, pChatSet->m_iy + iHeight);
				iWidth += c_fFlagTargetX + 2;
			}

			if (pChatLine->pCountryFlagImageInstance->IsMouseOverIn(gs_mx, gs_my))
				gs_Country = pChatLine->strCountry;
		}

#if defined(__BL_MULTI_LANGUAGE_ULTIMATE__)
		if (pChatLine->pEmpireFlagImageInstance && CPythonSystem::Instance().IsShowEmpireFlag())
#else
		if (pChatLine->pEmpireFlagImageInstance)
#endif
		{
			if (GetDefaultCodePage() == CP_ARABIC)
			{
				pChatLine->pEmpireFlagImageInstance->SetPosition(pChatSet->m_ix + iWidth - c_fFlagTargetX, pChatSet->m_iy + iHeight);
				iWidth -= c_fFlagTargetX + 2;
			}
			else
			{
				pChatLine->pEmpireFlagImageInstance->SetPosition(pChatSet->m_ix + iWidth, pChatSet->m_iy + iHeight);
				iWidth += c_fFlagTargetX + 2;
			}

			if (pChatLine->pEmpireFlagImageInstance->IsMouseOverIn(gs_mx, gs_my))
				gb_Empire = pChatLine->bEmpire;
		}

		pChatLine->Instance.SetPosition(pChatSet->m_ix + iWidth, pChatSet->m_iy + iHeight);
#else
		pChatLine->Instance.SetPosition(pChatSet->m_ix, pChatSet->m_iy + iHeight);
#endif
		pChatLine->Instance.SetColor(rColor);
		pChatLine->Instance.Update();
	}
}

void CPythonChat::UpdateEditMode(DWORD dwID)
{
	TChatSet * pChatSet = GetChatSetPtr(dwID);
	if (!pChatSet)
		return;

	const int c_iAlphaLine = max(0, GetVisibleLineCount(dwID) - GetEditableLineCount(dwID) + 2);

	int iLineIndex = 0;
	float fAlpha = 0.0f;
	float fAlphaStep = 0.0f;

	if (c_iAlphaLine > 0)
		fAlphaStep = 1.0f / float(c_iAlphaLine);

	TChatLineList * pLineList = &(pChatSet->m_ShowingChatLineList);
	int iHeight = -(int(pLineList->size()+1) * pChatSet->m_iStep);

	for (TChatLineList::iterator itor = pLineList->begin(); itor != pLineList->end(); ++itor)
	{
		TChatLine * pChatLine = (*itor);

		D3DXCOLOR & rColor = pChatLine->GetColorRef(dwID);

		if (iLineIndex < c_iAlphaLine)
		{
			rColor.a += (fAlpha - rColor.a) / 10.0f;
			fAlpha = fMIN(fAlpha+fAlphaStep, 1.0f);
		}
		else
		{
			rColor.a = fMIN(rColor.a+0.05f, 1.0f);
		}

		iHeight += pChatSet->m_iStep;

#if defined(__BL_MULTI_LANGUAGE_PREMIUM__)
		int iWidth = 0;
#if defined(__BL_MULTI_LANGUAGE_ULTIMATE__)
		if (pChatLine->pCountryFlagImageInstance && CPythonSystem::Instance().IsShowCountryFlag())
#else
		if (pChatLine->pCountryFlagImageInstance)
#endif
		{
			if (GetDefaultCodePage() == CP_ARABIC)
			{
				pChatLine->pCountryFlagImageInstance->SetPosition(pChatSet->m_ix + iWidth - c_fFlagTargetX, pChatSet->m_iy + iHeight);
				iWidth -= c_fFlagTargetX + 2;
			}
			else
			{
				pChatLine->pCountryFlagImageInstance->SetPosition(pChatSet->m_ix + iWidth, pChatSet->m_iy + iHeight);
				iWidth += c_fFlagTargetX + 2;
			}

			if (pChatLine->pCountryFlagImageInstance->IsMouseOverIn(gs_mx, gs_my))
				gs_Country = pChatLine->strCountry;
		}

#if defined(__BL_MULTI_LANGUAGE_ULTIMATE__)
		if (pChatLine->pEmpireFlagImageInstance && CPythonSystem::Instance().IsShowEmpireFlag())
#else
		if (pChatLine->pEmpireFlagImageInstance)
#endif
		{
			if (GetDefaultCodePage() == CP_ARABIC)
			{
				pChatLine->pEmpireFlagImageInstance->SetPosition(pChatSet->m_ix + iWidth - c_fFlagTargetX, pChatSet->m_iy + iHeight);
				iWidth -= c_fFlagTargetX + 2;
			}
			else
			{
				pChatLine->pEmpireFlagImageInstance->SetPosition(pChatSet->m_ix + iWidth, pChatSet->m_iy + iHeight);
				iWidth += c_fFlagTargetX + 2;
			}

			if (pChatLine->pEmpireFlagImageInstance->IsMouseOverIn(gs_mx, gs_my))
				gb_Empire = pChatLine->bEmpire;
		}

		pChatLine->Instance.SetPosition(pChatSet->m_ix + iWidth, pChatSet->m_iy + iHeight);
#else
		pChatLine->Instance.SetPosition(pChatSet->m_ix, pChatSet->m_iy + iHeight);
#endif
		pChatLine->Instance.SetColor(rColor);
		pChatLine->Instance.Update();
	}
}

void CPythonChat::UpdateLogMode(DWORD dwID)
{
	TChatSet * pChatSet = GetChatSetPtr(dwID);
	if (!pChatSet)
		return;

	TChatLineList * pLineList = &(pChatSet->m_ShowingChatLineList);
	int iHeight = 0;

	for (TChatLineList::reverse_iterator itor = pLineList->rbegin(); itor != pLineList->rend(); ++itor)
	{
		TChatLine * pChatLine = (*itor);

		iHeight -= pChatSet->m_iStep;

#if defined(__BL_MULTI_LANGUAGE_PREMIUM__)
		int iWidth = 0;
#if defined(__BL_MULTI_LANGUAGE_ULTIMATE__)
		if (pChatLine->pCountryFlagImageInstance && CPythonSystem::Instance().IsShowCountryFlag())
#else
		if (pChatLine->pCountryFlagImageInstance)
#endif
		{
			if (GetDefaultCodePage() == CP_ARABIC)
			{
				pChatLine->pCountryFlagImageInstance->SetPosition(pChatSet->m_ix + iWidth - c_fFlagTargetX, pChatSet->m_iy + iHeight);
				iWidth -= c_fFlagTargetX + 2;
			}
			else
			{
				pChatLine->pCountryFlagImageInstance->SetPosition(pChatSet->m_ix + iWidth, pChatSet->m_iy + iHeight);
				iWidth += c_fFlagTargetX + 2;
			}

			if (pChatLine->pCountryFlagImageInstance->IsMouseOverIn(gs_mx, gs_my))
				gs_Country = pChatLine->strCountry;
		}

#if defined(__BL_MULTI_LANGUAGE_ULTIMATE__)
		if (pChatLine->pEmpireFlagImageInstance && CPythonSystem::Instance().IsShowEmpireFlag())
#else
		if (pChatLine->pEmpireFlagImageInstance)
#endif
		{
			if (GetDefaultCodePage() == CP_ARABIC)
			{
				pChatLine->pEmpireFlagImageInstance->SetPosition(pChatSet->m_ix + iWidth - c_fFlagTargetX, pChatSet->m_iy + iHeight);
				iWidth -= c_fFlagTargetX + 2;
			}
			else
			{
				pChatLine->pEmpireFlagImageInstance->SetPosition(pChatSet->m_ix + iWidth, pChatSet->m_iy + iHeight);
				iWidth += c_fFlagTargetX + 2;
			}

			if (pChatLine->pEmpireFlagImageInstance->IsMouseOverIn(gs_mx, gs_my))
				gb_Empire = pChatLine->bEmpire;
		}

		pChatLine->Instance.SetPosition(pChatSet->m_ix + iWidth, pChatSet->m_iy + iHeight);
#else
		pChatLine->Instance.SetPosition(pChatSet->m_ix, pChatSet->m_iy + iHeight);
#endif
		pChatLine->Instance.SetColor(pChatLine->GetColorRef(dwID));
		pChatLine->Instance.Update();
	}
}

void CPythonChat::Update(DWORD dwID)
{
	TChatSet * pChatSet = GetChatSetPtr(dwID);
	if (!pChatSet)
		return;

	switch (pChatSet->m_iBoardState)
	{
		case BOARD_STATE_VIEW:
			UpdateViewMode(dwID);
			break;
		case BOARD_STATE_EDIT:
			UpdateEditMode(dwID);
			break;
		case BOARD_STATE_LOG:
			UpdateLogMode(dwID);
			break;
	}

	DWORD dwcurTime = CTimer::Instance().GetCurrentMillisecond();
	for (TWaitChatList::iterator itor = m_WaitChatList.begin(); itor != m_WaitChatList.end();)
	{
		TWaitChat & rWaitChat = *itor;

		if (rWaitChat.dwAppendingTime < dwcurTime)
		{
			AppendChat(rWaitChat.iType, rWaitChat.strChat.c_str());

			itor = m_WaitChatList.erase(itor);
		}
		else
		{
			++itor;
		}
	}
}

void CPythonChat::Render(DWORD dwID)
{
	TChatLineList * pLineList = GetChatLineListPtr(dwID);
	if (!pLineList)
		return;

	for (TChatLineList::iterator itor = pLineList->begin(); itor != pLineList->end(); ++itor)
	{
		CGraphicTextInstance & rInstance = (*itor)->Instance;
		rInstance.Render();
#if defined(__BL_MULTI_LANGUAGE_PREMIUM__)
		CGraphicExpandedImageInstance* rCountryFlagInstance = (*itor)->pCountryFlagImageInstance;
#if defined(__BL_MULTI_LANGUAGE_ULTIMATE__)
		if (rCountryFlagInstance && CPythonSystem::Instance().IsShowCountryFlag())
#else
		if (rCountryFlagInstance)
#endif
			rCountryFlagInstance->Render();
		CGraphicExpandedImageInstance* rEmpireFlagInstance = (*itor)->pEmpireFlagImageInstance;
#if defined(__BL_MULTI_LANGUAGE_ULTIMATE__)
		if (rEmpireFlagInstance && CPythonSystem::Instance().IsShowEmpireFlag())
#else
		if (rEmpireFlagInstance)
#endif
			rEmpireFlagInstance->Render();
#endif
	}
}

void CPythonChat::SetBoardState(DWORD dwID, int iState)
{
	TChatSet * pChatSet = GetChatSetPtr(dwID);
	if (!pChatSet)
		return;

	pChatSet->m_iBoardState = iState;
	ArrangeShowingChat(dwID);
}
void CPythonChat::SetPosition(DWORD dwID, int ix, int iy)
{
	TChatSet * pChatSet = GetChatSetPtr(dwID);
	if (!pChatSet)
		return;

	pChatSet->m_ix = ix;
	pChatSet->m_iy = iy;
}
void CPythonChat::SetHeight(DWORD dwID, int iHeight)
{
	TChatSet * pChatSet = GetChatSetPtr(dwID);
	if (!pChatSet)
		return;

	pChatSet->m_iHeight = iHeight;
}
void CPythonChat::SetStep(DWORD dwID, int iStep)
{
	TChatSet * pChatSet = GetChatSetPtr(dwID);
	if (!pChatSet)
		return;

	pChatSet->m_iStep = iStep;
}
void CPythonChat::ToggleChatMode(DWORD dwID, int iMode)
{
	TChatSet * pChatSet = GetChatSetPtr(dwID);
	if (!pChatSet)
		return;

	pChatSet->m_iMode[iMode] = 1 - pChatSet->m_iMode[iMode];
// 	Tracef("ToggleChatMode : %d\n", iMode);
	ArrangeShowingChat(dwID);
}
void CPythonChat::EnableChatMode(DWORD dwID, int iMode)
{
	TChatSet * pChatSet = GetChatSetPtr(dwID);
	if (!pChatSet)
		return;

	pChatSet->m_iMode[iMode] = TRUE;
// 	Tracef("EnableChatMode : %d\n", iMode);
	ArrangeShowingChat(dwID);
}
void CPythonChat::DisableChatMode(DWORD dwID, int iMode)
{
	TChatSet * pChatSet = GetChatSetPtr(dwID);
	if (!pChatSet)
		return;

	pChatSet->m_iMode[iMode] = FALSE;
// 	Tracef("DisableChatMode : %d\n", iMode);
	ArrangeShowingChat(dwID);
}
void CPythonChat::SetEndPos(DWORD dwID, float fPos)
{
	TChatSet * pChatSet = GetChatSetPtr(dwID);
	if (!pChatSet)
		return;

	fPos = max(0.0f, fPos);
	fPos = min(1.0f, fPos);
	if (pChatSet->m_fEndPos != fPos)
	{
		pChatSet->m_fEndPos = fPos;
		ArrangeShowingChat(dwID);
	}
}

int CPythonChat::GetVisibleLineCount(DWORD dwID)
{
	TChatLineList * pLineList = GetChatLineListPtr(dwID);
	if (!pLineList)
		return 0;

	return pLineList->size();
}

int CPythonChat::GetEditableLineCount(DWORD dwID)
{
	TChatSet * pChatSet = GetChatSetPtr(dwID);
	if (!pChatSet)
		return 0;

	return pChatSet->m_iHeight / pChatSet->m_iStep + 1;
}

int CPythonChat::GetLineCount(DWORD dwID)
{
	TChatSet * pChatSet = GetChatSetPtr(dwID);
	if (!pChatSet)
		return 0;

	int iCount = 0;
	for (DWORD i = 0; i < m_ChatLineDeque.size(); ++i)
	{
		if (!pChatSet->CheckMode(m_ChatLineDeque[i]->iType))
			continue;

		++iCount;
	}

	return iCount;
}

int CPythonChat::GetLineStep(DWORD dwID)
{
	TChatSet * pChatSet = GetChatSetPtr(dwID);
	if (!pChatSet)
		return 0;

	return pChatSet->m_iStep;
}

CPythonChat::TChatLineList * CPythonChat::GetChatLineListPtr(DWORD dwID)
{
	TChatSetMap::iterator itor = m_ChatSetMap.find(dwID);
	if (m_ChatSetMap.end() == itor)
		return NULL;

	TChatSet & rChatSet = itor->second;
	return &(rChatSet.m_ShowingChatLineList);
}

CPythonChat::TChatSet * CPythonChat::GetChatSetPtr(DWORD dwID)
{
	TChatSetMap::iterator itor = m_ChatSetMap.find(dwID);
	if (m_ChatSetMap.end() == itor)
		return NULL;

	TChatSet & rChatSet = itor->second;
	return &rChatSet;
}

void CPythonChat::ArrangeShowingChat(DWORD dwID)
{
	TChatSet * pChatSet = GetChatSetPtr(dwID);
	if (!pChatSet)
		return;

	pChatSet->m_ShowingChatLineList.clear();

	TChatLineDeque TempChatLineDeque;
	for (TChatLineDeque::iterator itor = m_ChatLineDeque.begin(); itor != m_ChatLineDeque.end(); ++itor)
	{
		TChatLine * pChatLine = *itor;
#if defined(__BL_MULTI_LANGUAGE_ULTIMATE__)
		if (pChatSet->CheckMode(pChatLine->iType) && !CPythonSystem::Instance().IsChatFilterCountry(pChatLine->strCountry) && !CPythonSystem::Instance().IsChatFilterEmpire(pChatLine->bEmpire))
#else
		if (pChatSet->CheckMode(pChatLine->iType))
#endif
			TempChatLineDeque.push_back(pChatLine);
	}

	int icurLineCount = TempChatLineDeque.size();
	int iVisibleLineCount = min(icurLineCount, (pChatSet->m_iHeight + pChatSet->m_iStep) / pChatSet->m_iStep);
	int iEndLine = iVisibleLineCount + int(float(icurLineCount - iVisibleLineCount - 1) * pChatSet->m_fEndPos);

	/////

	int iHeight = 12;
	for (int i = min(icurLineCount-1, iEndLine); i >= 0; --i)
	{
		if (!pChatSet->CheckMode(TempChatLineDeque[i]->iType))
			continue;

		if (pChatSet->m_iHeight + pChatSet->m_iStep <= iHeight)
		{
			break;
		}

		pChatSet->m_ShowingChatLineList.push_front(TempChatLineDeque[i]);

		iHeight += pChatSet->m_iStep;
	}
}

#if defined(__BL_CLIENT_LOCALE_STRING__)
#if defined(__BL_MULTI_LANGUAGE_PREMIUM__)
void CPythonChat::AppendChat(int iType, const char* c_szChat, BYTE bSpecialColorType, BYTE bEmpire, const std::string& countryName)
#else
void CPythonChat::AppendChat(int iType, const char* c_szChat, BYTE bSpecialColorType)
#endif
#else
void CPythonChat::AppendChat(int iType, const char* c_szChat)
#endif
{
	// DEFAULT_FONT
	//static CResource * s_pResource = CResourceManager::Instance().GetResourcePointer(g_strDefaultFontName.c_str());

	CGraphicText* pkDefaultFont = static_cast<CGraphicText*>(DefaultFont_GetResource());
	if (!pkDefaultFont)
	{
		TraceError("CPythonChat::AppendChat - CANNOT_FIND_DEFAULT_FONT");
		return;
	}
	// END_OF_DEFAULT_FONT

	IAbstractApplication& rApp=IAbstractApplication::GetSingleton();
	SChatLine * pChatLine = SChatLine::New();
	pChatLine->iType = iType;
	pChatLine->Instance.SetValue(c_szChat);

	// DEFAULT_FONT
	pChatLine->Instance.SetTextPointer(pkDefaultFont);
#if defined(__BL_MULTI_LANGUAGE_PREMIUM__)
	if (!countryName.empty())
	{
		const auto path = fmt::format("D:/ymir work/ui/intro/login/server_flag_{}.sub", countryName);
		if (CEterPackManager::Instance().isExist(path.c_str()))
		{
			CGraphicSubImage* pkGrpImgFlag = (CGraphicSubImage*)CResourceManager::Instance().GetResourcePointer(path.c_str());
			if (pkGrpImgFlag)
			{
				pChatLine->pCountryFlagImageInstance = CGraphicExpandedImageInstance::New();
				pChatLine->pCountryFlagImageInstance->SetImagePointer(pkGrpImgFlag);
				pChatLine->pCountryFlagImageInstance->SetScale(c_fFlagTargetX / pChatLine->pCountryFlagImageInstance->GetWidth(),
					c_fFlagTargetY / pChatLine->pCountryFlagImageInstance->GetHeight());
				pChatLine->strCountry = countryName;
			}
		}
	}

	if (bEmpire)
	{
		const auto path = fmt::format("D:/ymir work/ui/intro/empire_01/empireflag_{:c}.sub", bEmpire + 'a' - 1);
		if (CEterPackManager::Instance().isExist(path.c_str()))
		{
			CGraphicSubImage* pkGrpImgFlag = (CGraphicSubImage*)CResourceManager::Instance().GetResourcePointer(path.c_str());
			if (pkGrpImgFlag)
			{
				pChatLine->pEmpireFlagImageInstance = CGraphicExpandedImageInstance::New();
				pChatLine->pEmpireFlagImageInstance->SetImagePointer(pkGrpImgFlag);
				pChatLine->pEmpireFlagImageInstance->SetScale(c_fFlagTargetX / pChatLine->pEmpireFlagImageInstance->GetWidth(),
					c_fFlagTargetY / pChatLine->pEmpireFlagImageInstance->GetHeight());
				pChatLine->bEmpire = bEmpire;
			}
		}
	}
#endif
	// END_OF_DEFAULT_FONT

	pChatLine->fAppendedTime = rApp.GetGlobalTime();
#if defined(__BL_CLIENT_LOCALE_STRING__)
	switch (bSpecialColorType)
	{
	case IAbstractChat::ESpecialColorType::CHAT_SPECIAL_COLOR_DICE_0:
		pChatLine->SetColorAll(D3DXCOLOR(1.0f, 0.97640002f, 0.6196f, 1.0f));
		break;
	case IAbstractChat::ESpecialColorType::CHAT_SPECIAL_COLOR_DICE_1:
		pChatLine->SetColorAll(D3DXCOLOR(1.0f, 0.1058f, 0.73720002f, 1.0f));
		break;
	default:
		pChatLine->SetColorAll(GetChatColor(iType));
		break;
	}
#else
	pChatLine->SetColorAll(GetChatColor(iType));
#endif

	m_ChatLineDeque.push_back(pChatLine);
	if (m_ChatLineDeque.size() > CHAT_LINE_MAX_NUM)
	{
		SChatLine * pChatLine = m_ChatLineDeque.front();
		SChatLine::Delete(pChatLine);
		m_ChatLineDeque.pop_front();
	}

	for (TChatSetMap::iterator itor = m_ChatSetMap.begin(); itor != m_ChatSetMap.end(); ++itor)
	{
		TChatSet * pChatSet = &(itor->second);
		//pChatLine->SetColor(itor->first, GetChatColor(iType));

		if (BOARD_STATE_EDIT == pChatSet->m_iBoardState)
		{
			ArrangeShowingChat(itor->first);
		}
		else// if (BOARD_STATE_VIEW == pChatSet->m_iBoardState)
		{
			pChatSet->m_ShowingChatLineList.push_back(pChatLine);
			if (pChatSet->m_ShowingChatLineList.size() > CHAT_LINE_MAX_NUM)
			{
				pChatSet->m_ShowingChatLineList.pop_front();
			}
		}
	}
}

void CPythonChat::AppendChatWithDelay(int iType, const char * c_szChat, int iDelay)
{
	TWaitChat WaitChat;
	WaitChat.iType = iType;
	WaitChat.strChat = c_szChat;
	WaitChat.dwAppendingTime = CTimer::Instance().GetCurrentMillisecond() + iDelay;
	m_WaitChatList.push_back(WaitChat);
}

DWORD CPythonChat::GetChatColor(int iType)
{
	if (iType<CHAT_TYPE_MAX_NUM)
	{
		return m_akD3DXClrChat[iType];
	}

	return D3DXCOLOR(0.0f, 0.0f, 1.0f, 1.0f);
}

void CPythonChat::IgnoreCharacter(const char * c_szName)
{
	TIgnoreCharacterSet::iterator itor = m_IgnoreCharacterSet.find(c_szName);
	if (m_IgnoreCharacterSet.end() != itor)
	{
		m_IgnoreCharacterSet.erase(itor);
	}
	else
	{
		m_IgnoreCharacterSet.insert(c_szName);
	}
}

BOOL CPythonChat::IsIgnoreCharacter(const char * c_szName)
{
	TIgnoreCharacterSet::iterator itor = m_IgnoreCharacterSet.find(c_szName);

	if (m_IgnoreCharacterSet.end() == itor)
		return FALSE;

	return TRUE;
}

CWhisper * CPythonChat::CreateWhisper(const char * c_szName)
{
	CWhisper * pWhisper = CWhisper::New();
	m_WhisperMap.insert(TWhisperMap::value_type(c_szName, pWhisper));
	return pWhisper;
}

#if defined(__BL_MULTI_LANGUAGE_PREMIUM__)
void CPythonChat::AppendWhisper(int iType, const char * c_szName, const char * c_szChat, BYTE bEmpire, const std::string& countryName)
#else
void CPythonChat::AppendWhisper(int iType, const char* c_szName, const char* c_szChat)
#endif
{
	TWhisperMap::iterator itor = m_WhisperMap.find(c_szName);

	CWhisper * pWhisper;
	if (itor == m_WhisperMap.end())
	{
		pWhisper = CreateWhisper(c_szName);
	}
	else
	{
		pWhisper = itor->second;
	}

#if defined(__BL_MULTI_LANGUAGE_PREMIUM__)
	pWhisper->AppendChat(iType, c_szChat, bEmpire, countryName);
#else
	pWhisper->AppendChat(iType, c_szChat);
#endif
}

void CPythonChat::ClearWhisper(const char * c_szName)
{
	TWhisperMap::iterator itor = m_WhisperMap.find(c_szName);

	if (itor != m_WhisperMap.end())
	{
		CWhisper * pWhisper = itor->second;
		CWhisper::Delete(pWhisper);

		m_WhisperMap.erase(itor);
	}
}

BOOL CPythonChat::GetWhisper(const char * c_szName, CWhisper ** ppWhisper)
{
	TWhisperMap::iterator itor = m_WhisperMap.find(c_szName);

	if (itor == m_WhisperMap.end())
		return FALSE;

	*ppWhisper = itor->second;

	return TRUE;
}

void CPythonChat::InitWhisper(PyObject * ppyObject)
{
	TWhisperMap::iterator itor = m_WhisperMap.begin();
	for (; itor != m_WhisperMap.end(); ++itor)
	{
		std::string strName = itor->first;
		PyCallClassMemberFunc(ppyObject, "MakeWhisperButton", Py_BuildValue("(s)", strName.c_str()));
	}
}

void CPythonChat::__DestroyWhisperMap()
{
	TWhisperMap::iterator itor = m_WhisperMap.begin();
	for (; itor != m_WhisperMap.end(); ++itor)
	{
		CWhisper::Delete(itor->second);
	}
	m_WhisperMap.clear();
}

void CPythonChat::Close()
{
	TChatSetMap::iterator itor = m_ChatSetMap.begin();
	for (; itor != m_ChatSetMap.end(); ++itor)
	{
		TChatSet & rChatSet = itor->second;
		TChatLineList * pLineList = &(rChatSet.m_ShowingChatLineList);
		for (TChatLineList::iterator itor = pLineList->begin(); itor != pLineList->end(); ++itor)
		{
			TChatLine * pChatLine = (*itor);
			pChatLine->fAppendedTime = 0.0f;
		}
	}
}

void CPythonChat::Destroy()
{
	__DestroyWhisperMap();

	m_ShowingChatLineList.clear();
	m_ChatSetMap.clear();
	m_ChatLineDeque.clear();

	SChatLine::DestroySystem();
	CWhisper::DestroySystem();

	__Initialize();
}

void CPythonChat::__Initialize()
{
	m_akD3DXClrChat[CHAT_TYPE_TALKING]		= D3DXCOLOR(1.0f, 1.0f, 1.0f, 1.0f);
	m_akD3DXClrChat[CHAT_TYPE_INFO]			= D3DXCOLOR(1.0f, 0.785f, 0.785f, 1.0f);
	m_akD3DXClrChat[CHAT_TYPE_NOTICE]		= D3DXCOLOR(1.0f, 0.902f, 0.730f, 1.0f);
	m_akD3DXClrChat[CHAT_TYPE_PARTY]		= D3DXCOLOR(0.542f, 1.0f, 0.949f, 1.0f);
	m_akD3DXClrChat[CHAT_TYPE_GUILD]		= D3DXCOLOR(0.906f, 0.847f, 1.0f, 1.0f);
	m_akD3DXClrChat[CHAT_TYPE_COMMAND]		= D3DXCOLOR(0.658f, 1.0f, 0.835f, 1.0f);
	m_akD3DXClrChat[CHAT_TYPE_SHOUT]		= D3DXCOLOR(0.658f, 1.0f, 0.835f, 1.0f);
	m_akD3DXClrChat[CHAT_TYPE_WHISPER]		= D3DXCOLOR(0xff4AE14A);
	m_akD3DXClrChat[CHAT_TYPE_BIG_NOTICE]	= D3DXCOLOR(1.0f, 0.902f, 0.730f, 1.0f);
	m_akD3DXClrChat[CHAT_TYPE_MONARCH_NOTICE]	= D3DXCOLOR(1.0f, 0.902f, 0.730f, 1.0f);
#ifdef ENABLE_DICE_SYSTEM
	m_akD3DXClrChat[CHAT_TYPE_DICE_INFO]	= D3DXCOLOR(0xFFcc00cc);
#endif
}

CPythonChat::CPythonChat()
{
	__Initialize();
}

CPythonChat::~CPythonChat()
{
	assert(m_ChatLineDeque.empty());
	assert(m_ShowingChatLineList.empty());
	assert(m_ChatSetMap.empty());
	assert(m_WhisperMap.empty());
}

///////////////////////////////////////////////////////////////////////////////////////////////////
CDynamicPool<CWhisper> CWhisper::ms_kPool;

CWhisper* CWhisper::New()
{
	return ms_kPool.Alloc();
}

void CWhisper::Delete(CWhisper* pkWhisper)
{
	pkWhisper->Destroy();
	ms_kPool.Free(pkWhisper);
}

void CWhisper::DestroySystem()
{
	ms_kPool.Destroy();

	SChatLine::DestroySystem();
}

void CWhisper::SetPosition(float fPosition)
{
	m_fcurPosition = fPosition;
	__ArrangeChat();
}

void CWhisper::SetBoxSize(float fWidth, float fHeight)
{
	m_fWidth = fWidth;
	m_fHeight = fHeight;

	for (TChatLineDeque::iterator itor = m_ChatLineDeque.begin(); itor != m_ChatLineDeque.end(); ++itor)
	{
		TChatLine * pChatLine = *itor;
		pChatLine->Instance.SetLimitWidth(fWidth);
	}
}

#if defined(__BL_CLIENT_LOCALE_STRING__)
#if defined(__BL_MULTI_LANGUAGE_PREMIUM__)
void CWhisper::AppendChat(int iType, const char * c_szChat, BYTE bEmpire, const std::string& countryName)
#else
void CWhisper::AppendChat(int iType, const char* c_szChat)
#endif
#else
void CWhisper::AppendChat(int iType, const char* c_szChat)
#endif
{
	CGraphicText* pkDefaultFont = (iType == CPythonChat::WHISPER_TYPE_GM) ? static_cast<CGraphicText*>(DefaultItalicFont_GetResource()) : static_cast<CGraphicText*>(DefaultFont_GetResource());

	if (!pkDefaultFont)
	{
		TraceError("CWhisper::AppendChat - CANNOT_FIND_DEFAULT_FONT");
		return;
	}
	// END_OF_DEFAULT_FONT

	SChatLine * pChatLine = SChatLine::New();
	pChatLine->Instance.SetValue(c_szChat);

	// DEFAULT_FONT
	pChatLine->Instance.SetTextPointer(pkDefaultFont);
	// END_OF_DEFAULT_FONT

	pChatLine->Instance.SetLimitWidth(m_fWidth);
	pChatLine->Instance.SetMultiLine(TRUE);
#if defined(__BL_MULTI_LANGUAGE_PREMIUM__)
	if (!countryName.empty())
	{
		const auto path = fmt::format("D:/ymir work/ui/intro/login/server_flag_{}.sub", countryName);
		if (CEterPackManager::Instance().isExist(path.c_str()))
		{
			CGraphicSubImage* pkGrpImgFlag = (CGraphicSubImage*)CResourceManager::Instance().GetResourcePointer(path.c_str());
			if (pkGrpImgFlag)
			{
				pChatLine->pCountryFlagImageInstance = CGraphicExpandedImageInstance::New();
				pChatLine->pCountryFlagImageInstance->SetImagePointer(pkGrpImgFlag);
				pChatLine->pCountryFlagImageInstance->SetScale(c_fFlagTargetX / pChatLine->pCountryFlagImageInstance->GetWidth(),
					c_fFlagTargetY / pChatLine->pCountryFlagImageInstance->GetHeight());
				pChatLine->strCountry = countryName;
			}
		}
	}

	if (bEmpire)
	{
		const auto path = fmt::format("D:/ymir work/ui/intro/empire_01/empireflag_{:c}.sub", (bEmpire + 'a' - 1));
		if (CEterPackManager::Instance().isExist(path.c_str()))
		{
			CGraphicSubImage* pkGrpImgFlag = (CGraphicSubImage*)CResourceManager::Instance().GetResourcePointer(path.c_str());
			if (pkGrpImgFlag)
			{
				pChatLine->pEmpireFlagImageInstance = CGraphicExpandedImageInstance::New();
				pChatLine->pEmpireFlagImageInstance->SetImagePointer(pkGrpImgFlag);
				pChatLine->pEmpireFlagImageInstance->SetScale(c_fFlagTargetX / pChatLine->pEmpireFlagImageInstance->GetWidth(),
					c_fFlagTargetY / pChatLine->pEmpireFlagImageInstance->GetHeight());
				pChatLine->bEmpire = bEmpire;
			}
		}
	}
#endif

	switch(iType)
	{
		case CPythonChat::WHISPER_TYPE_SYSTEM:
			pChatLine->Instance.SetColor(D3DXCOLOR(1.0f, 0.785f, 0.785f, 1.0f));
			break;
		case CPythonChat::WHISPER_TYPE_GM:
			pChatLine->Instance.SetColor(D3DXCOLOR(1.0f, 0.632f, 0.0f, 1.0f));
			break;
		case CPythonChat::WHISPER_TYPE_CHAT:
		default:
			pChatLine->Instance.SetColor(0xffffffff);
			break;
	}

	m_ChatLineDeque.push_back(pChatLine);

	__ArrangeChat();
}

void CWhisper::__ArrangeChat()
{
	for (TChatLineDeque::iterator itor = m_ChatLineDeque.begin(); itor != m_ChatLineDeque.end(); ++itor)
	{
		TChatLine * pChatLine = *itor;
		pChatLine->Instance.Update();
	}
}

void CWhisper::Render(float fx, float fy)
{
	float fHeight = fy + m_fHeight;

	int iViewCount = int(m_fHeight / m_fLineStep) - 1;
	int iLineCount = int(m_ChatLineDeque.size());
	int iStartLine = -1;
	if (iLineCount > iViewCount)
	{
		iStartLine = int(float(iLineCount-iViewCount) * m_fcurPosition) + iViewCount - 1;
	}
	else if (!m_ChatLineDeque.empty())
	{
		iStartLine = iLineCount - 1;
	}

	RECT Rect = { fx, fy, fx+m_fWidth, fy+m_fHeight };

	for (int i = iStartLine; i >= 0; --i)
	{
		assert(i >= 0 && i < int(m_ChatLineDeque.size()));
		TChatLine * pChatLine = m_ChatLineDeque[i];

		WORD wLineCount = pChatLine->Instance.GetTextLineCount();
		fHeight -= wLineCount * m_fLineStep;

#if defined(__BL_MULTI_LANGUAGE_PREMIUM__)
		float fWidth = 0.0f;
#if defined(__BL_MULTI_LANGUAGE_ULTIMATE__)
		if (pChatLine->pCountryFlagImageInstance && CPythonSystem::Instance().IsShowCountryFlag())
#else
		if (pChatLine->pCountryFlagImageInstance)
#endif
		{
			if (GetDefaultCodePage() == CP_ARABIC)
			{
				pChatLine->pCountryFlagImageInstance->SetPosition(fx + fWidth - c_fFlagTargetX, fHeight);
				fWidth -= c_fFlagTargetX + 2;
			}
			else
			{
				pChatLine->pCountryFlagImageInstance->SetPosition(fx + fWidth, fHeight);
				fWidth += c_fFlagTargetX + 2;
			}

#if defined(__BL_CLIP_MASK__)
			pChatLine->pCountryFlagImageInstance->Render(&Rect);
#else
			pChatLine->pCountryFlagImageInstance->Render();
#endif

			if (pChatLine->pCountryFlagImageInstance->IsMouseOverIn(gs_mx, gs_my))
				gs_Country = pChatLine->strCountry;
		}

#if defined(__BL_MULTI_LANGUAGE_ULTIMATE__)
		if (pChatLine->pEmpireFlagImageInstance && CPythonSystem::Instance().IsShowEmpireFlag())
#else
		if (pChatLine->pEmpireFlagImageInstance)
#endif
		{
			if (GetDefaultCodePage() == CP_ARABIC)
			{
				pChatLine->pEmpireFlagImageInstance->SetPosition(fx + fWidth - c_fFlagTargetX, fHeight);
				fWidth -= c_fFlagTargetX + 2;
			}
			else
			{
				pChatLine->pEmpireFlagImageInstance->SetPosition(fx + fWidth, fHeight);
				fWidth += c_fFlagTargetX + 2;
			}

#if defined(__BL_CLIP_MASK__)
			pChatLine->pEmpireFlagImageInstance->Render(&Rect);
#else
			pChatLine->pEmpireFlagImageInstance->Render();
#endif

			if (pChatLine->pEmpireFlagImageInstance->IsMouseOverIn(gs_mx, gs_my))
				gb_Empire = pChatLine->bEmpire;
		}

		pChatLine->Instance.SetPosition(fx + fWidth, fHeight);
#else
		pChatLine->Instance.SetPosition(fx, fHeight);
#endif
		pChatLine->Instance.Render(&Rect);

		if (fHeight < fy)
			break;
	}
}

void CWhisper::__Initialize()
{
	m_fLineStep = 15.0f;
	m_fWidth = 300.0f;
	m_fHeight = 120.0f;
	m_fcurPosition = 1.0f;
}

void CWhisper::Destroy()
{
	std::for_each(m_ChatLineDeque.begin(), m_ChatLineDeque.end(), SChatLine::Delete);
	m_ChatLineDeque.clear();
	m_ShowingChatLineList.clear();
}

CWhisper::CWhisper()
{
	__Initialize();
}

CWhisper::~CWhisper()
{
	Destroy();
}

///////////////////////////////////////////////////////////////////////////////////////////////////

CDynamicPool<CWhisper::SChatLine> CWhisper::SChatLine::ms_kPool;

CWhisper::SChatLine* CWhisper::SChatLine::New()
{
	return ms_kPool.Alloc();
}

void CWhisper::SChatLine::Delete(CWhisper::SChatLine* pkChatLine)
{
	pkChatLine->Instance.Destroy();
#if defined(__BL_MULTI_LANGUAGE_PREMIUM__)
	if (pkChatLine->pCountryFlagImageInstance)
	{
		CGraphicExpandedImageInstance::Delete(pkChatLine->pCountryFlagImageInstance);
		pkChatLine->pCountryFlagImageInstance = NULL;
	}
	if (pkChatLine->pEmpireFlagImageInstance)
	{
		CGraphicExpandedImageInstance::Delete(pkChatLine->pEmpireFlagImageInstance);
		pkChatLine->pEmpireFlagImageInstance = NULL;
	}
	pkChatLine->strCountry = "";
	pkChatLine->bEmpire = 0;
#endif
	ms_kPool.Free(pkChatLine);
}

void CWhisper::SChatLine::DestroySystem()
{
	ms_kPool.Destroy();
}
//martysama0134's 2e58d0b8baeb072acdf3afc4a5d1999f

#if defined(__BL_MULTI_LANGUAGE_ULTIMATE__)
void CPythonChat::ArrangeAllShowingChat()
{
	for (TChatSetMap::const_iterator itor = m_ChatSetMap.begin(); itor != m_ChatSetMap.end(); ++itor)
		ArrangeShowingChat(itor->first);
}
#endif