#include "NN_GameLogic.h"

bool CNNGameLogic::IsValidCard(uint8 cbCard)
{
	const uint8 cbColor = GetCardColorEx(cbCard);
	const uint8 cbValue = GetCardValue(cbCard);
	return (cbColor<=3 && cbValue>=0x01 && cbValue<=0x0D) ? true : false;
}

uint8 CNNGameLogic::GetLogicValue(uint8 cbCard)
{
	CC_ASSERT(IsValidCard(cbCard));
	const uint8 cbValue = GetCardValue(cbCard);
	return (cbValue>10) ? 10 : cbValue;
}

void CNNGameLogic::SortCardList(uint8 cbCardData[], uint8 cbCardCount)
{
	CC_ASSERT((NN_MAX_COUNT - 2) == cbCardCount || NN_MAX_COUNT == cbCardCount);
	if ((NN_MAX_COUNT - 2) != cbCardCount || NN_MAX_COUNT != cbCardCount) return;

	uint8 cbCardValue[NN_MAX_COUNT] = { 0 };
	for (uint8 i=0; i<cbCardCount; ++i)
	{
		cbCardValue[i] = GetCardValue(cbCardData[i]);
	}

	bool bSorted = true;
	uint8 cbTempData = 0;
	uint8 cbLast = cbCardCount - 1;
	do
	{
		bSorted = true;
		for (uint8 i = 0; i < cbLast; ++i)
		{
			if ((cbCardValue[i] < cbCardValue[i + 1]) || (cbCardValue[i] == cbCardValue[i + 1] && cbCardData[i] < cbCardData[i + 1]))
			{
				cbTempData = cbCardData[i];
				cbCardData[i] = cbCardData[i + 1];
				cbCardData[i + 1] = cbTempData;
				cbTempData = cbCardValue[i];
				cbCardValue[i] = cbCardValue[i + 1];
				cbCardValue[i + 1] = cbTempData;
				bSorted = false;
			}
		}
		cbLast--;
	} while (!bSorted);
}

bool CNNGameLogic::RemoveCard(uint8 cbCardData[], uint8 cbCardCount, uint8 cbRemoveCard[], uint8 cbRemoveCount)
{
	CC_ASSERT(cbRemoveCount <= cbCardCount);
	if (cbRemoveCount > cbCardCount) return false;

	uint8 cbDeleteCount = 0, cbDeleteCard[NN_FULL_COUNT] = { 0 };
	CC_ASSERT(cbCardCount <= sizeof(cbDeleteCard) / sizeof(cbDeleteCard[0]));
	if (cbCardCount > sizeof(cbDeleteCard) / sizeof(cbDeleteCard[0])) return false;
	memcpy(cbDeleteCard, cbCardData, sizeof(cbCardData[0])*cbCardCount);

	for (uint8 i = 0; i < cbRemoveCount; ++i)
	{
		for (uint8 j = 0; j < cbCardCount; ++j)
		{
			if (cbRemoveCard[i] == cbDeleteCard[j])
			{
				cbDeleteCount++;
				cbDeleteCard[j] = 0;
				break;
			}
		}
	}

	CC_ASSERT(cbDeleteCount == cbRemoveCount);
	if (cbDeleteCount != cbRemoveCount) return false;

	uint8 cbCardPos = 0;
	for (uint8 i = 0; i < cbCardCount; ++i)
	{
		if (0 != cbDeleteCard[i])
		{
			cbCardData[cbCardPos++] = cbDeleteCard[i];
		}
	}
	return true;
}

uint8 CNNGameLogic::GetCardType(const uint8 cbCardData[], const uint8 cbCardCount, uint8 cbSortCard[])
{
	CC_ASSERT((NN_MAX_COUNT - 2) == cbCardCount || NN_MAX_COUNT == cbCardCount);

	uint8 cbTempData[NN_MAX_COUNT] = { 0 };
	memcpy(cbTempData, cbCardData, sizeof(uint8)*cbCardCount);

	if (NN_MAX_COUNT == cbCardCount && IsWuHuaNiu(cbTempData, cbCardCount))
	{
		if (nullptr != cbSortCard)
		{
			memcpy(cbSortCard, cbCardData, sizeof(uint8)*cbCardCount);
		}
		return NIU_TYPE_WHN;
	}
	if (NN_MAX_COUNT == cbCardCount && IsWuXiaoNiu(cbTempData, cbCardCount))
	{
		if (nullptr != cbSortCard)
		{
			memcpy(cbSortCard, cbCardData, sizeof(uint8)*cbCardCount);
		}
		return NIU_TYPE_WXN;
	}
	if (NN_MAX_COUNT == cbCardCount && IsZhaDan(cbTempData, cbCardCount))
	{
		if (nullptr != cbSortCard)
		{
			CopyMemory(cbSortCard, cbCardData, sizeof(BYTE)*cbCardCount);
		}
		return NIU_TYPE_SHN;
	}

	uint8 cbValueSum = 0;
	uint8 cbLogicValue[NN_MAX_COUNT] = { 0 };
	for (uint8 i = 0; i < cbCardCount; ++i)
	{
		cbLogicValue[i] = GetLogicValue(cbTempData[i]);
		cbValueSum += cbLogicValue[i];
	}

	if ((NN_MAX_COUNT - 2) == cbCardCount)
	{
		for (uint8 i = 0; i < cbCardCount; ++i)
		{
			if (0 == (cbValueSum - cbLogicValue[i]) % 10)
			{
				if (nullptr != cbSortCard)
				{
					memcpy(cbSortCard, cbTempData, sizeof(uint8)*cbCardCount);
					if (false==RemoveCard(cbSortCard, cbCardCount, &cbTempData[i], 1))
					{
						CC_ASSERT(false);
						return NIU_TYPE_0;
					}
					cbSortCard[cbCardCount - 1] = cbTempData[i];
				}
				return cbLogicValue[i];
			}
		}
	}
	else
	{
		for (uint8 i=0; i<cbCardCount-1; ++i)
		{
			for (uint8 j=i+1; j<cbCardCount; ++j)
			{
				uint8 cbCowValue = cbLogicValue[i] + cbLogicValue[j];
				if (0 == (cbValueSum-cbCowValue)%10)
				{
					if (nullptr != cbSortCard)
					{
						uint8 cbDeleteCard[2] = { cbTempData[i],cbTempData[j] };
						memcpy(cbSortCard, cbTempData, sizeof(uint8)*cbCardCount);
						if (false == RemoveCard(cbSortCard, cbCardCount, cbDeleteCard, 2))
						{
							CC_ASSERT(false);
							return NIU_TYPE_0;
						}
						cbSortCard[cbCardCount-2] = cbTempData[i];
						cbSortCard[cbCardCount-1] = cbTempData[j];
					}
					return (cbCowValue>10) ? cbCowValue-10 : cbCowValue;
				}
			}
		}
	}

	if (nullptr != cbSortCard)
	{
		memcpy(cbSortCard, cbCardData, sizeof(uint8)*cbCardCount);
	}
	return NIU_TYPE_0;
}

uint8 CNNGameLogic::GetWinNiuFan(const uint8 cbCardType)
{
	switch (cbCardType)
	{
	case NIU_TYPE_WXN:
		return 6;
	case NIU_TYPE_SHN:
		return 5;
	case NIU_TYPE_WHN:
		return 4;
	case NIU_TYPE_10:
		return 3;
	case NIU_TYPE_9:
	case NIU_TYPE_8:
		return 2;
	}

	CC_ASSERT(cbCardType>=NIU_TYPE_0 && cbCardType<=NIU_TYPE_7);
	return 1;
}

uint8 CNNGameLogic::GetMaxCard(const uint8 cbCardData[], const uint8 cbCardCount)
{
	uint8 cbTempData[NN_MAX_COUNT] = { 0 };
	memcpy(cbTempData, cbCardData, sizeof(uint8)*cbCardCount);
	SortCardList(cbTempData, cbCardCount);
	return cbTempData[0];
}

bool CNNGameLogic::CompareCard(const tagOpenCardRlt stFirstData, const tagOpenCardRlt stNextData)
{
	if (stFirstData.cbCardType != stNextData.cbCardType)
	{
		return (stFirstData.cbCardType > stNextData.cbCardType) ? true : false;
	}
	uint8 cbFirstValue = GetCardValue(stFirstData.cbMaxCard);
	uint8 cbNextValue = GetCardValue(stNextData.cbMaxCard);
	if (cbFirstValue != cbNextValue)
	{
		return (cbFirstValue > cbNextValue) ? true : false;
	}
	uint8 cbFirstColor = GetCardColorEx(stFirstData.cbMaxCard);
	uint8 cbNextColor = GetCardColorEx(stNextData.cbMaxCard);
	return (cbFirstColor > cbNextColor) ? true : false;
}

bool CNNGameLogic::IsWuHuaNiu(const uint8 cbCardData[], const uint8 cbCardCount)
{
	CC_ASSERT(NN_MAX_COUNT == cbCardCount || (NN_MAX_COUNT - 2) == cbCardCount);
	if (NN_MAX_COUNT != cbCardCount && (NN_MAX_COUNT - 2) != cbCardCount) return false;

	for (uint8 i=0; i<cbCardCount; ++i)
	{
		uint8 cbCardValue = GetCardValue(cbCardData[i]);
		if (cbCardValue < 11) return false;
	}
	return true;
}

bool CNNGameLogic::IsWuXiaoNiu(const uint8 cbCardData[], const uint8 cbCardCount)
{
	CC_ASSERT(NN_MAX_COUNT == cbCardCount || (NN_MAX_COUNT - 2) == cbCardCount);
	if (NN_MAX_COUNT != cbCardCount && (NN_MAX_COUNT - 2) != cbCardCount) return false;

	uint8 cbValueSum = 0;
	for (uint8 i=0; i<cbCardCount; ++i)
	{
		uint8 cbCardValue = GetCardValue(cbCardData[i]);
		if (cbCardValue >= 5)
		{
			return false;
		}
		cbValueSum += cbCardValue;
	}

	return (cbValueSum<=10) ? true : false;
}

//تا·ٌتاص¨µ¯;
bool CNNGameLogic::IsZhaDan(const BYTE cbCardData[], const BYTE cbCardCount)
{
	ASSERT(NN_MAX_COUNT == cbCardCount || (NN_MAX_COUNT - 2) == cbCardCount);
	if (NN_MAX_COUNT != cbCardCount && (NN_MAX_COUNT - 2) != cbCardCount) return false;

	BYTE aryCardCount[14] = { 0 };

	for (BYTE i = 0; i < cbCardCount; ++i)
	{
		BYTE cbCardValue = GetCardValue(cbCardData[i]);
		aryCardCount[cbCardValue]++;
	}

	for (BYTE j = 0; j < 14; j++)
	{
		if (4 == aryCardCount[j])
		{
			return true;
		}
	}

	return false;
}