#include "match3/match3field.h"

#include "main_code.h"
#include <algorithm>


void TChipTemplateParams::Serialize(boost::property_tree::ptree& propertyTree)
{
	
	std::string selectedShaderName = propertyTree.get<std::string>("SelectedShaderName");
	std::string selectedTexName = propertyTree.get<std::string>("SelectedTexName");
	std::string selectedNormTexName = propertyTree.get<std::string>("SelectedNormTexName");
	std::string finishingTexName = propertyTree.get<std::string>("FinishingTexName");

	SelectedRenderParams.ShaderName = selectedShaderName;
	SelectedRenderParams.TexName = selectedTexName;
	SelectedRenderParams.NormTexName = selectedNormTexName;
	SelectedRenderParams.Transparency = 1.f;

	FinishingRenderParams.ShaderName = "";
	FinishingRenderParams.TexName = finishingTexName;
	FinishingRenderParams.NormTexName = "";
	FinishingRenderParams.Transparency = 1.f;

	std::string selectedAnimFileName = propertyTree.get<std::string>("SelectedAnimFileName");
	std::string finishingAnimFileName = propertyTree.get<std::string>("FinishingAnimFileName");

	boost::shared_ptr<boost::property_tree::ptree> px = FileToPropertyTree(selectedAnimFileName);
	SelectedTemplateAnimObject.Serialize(*px);
	px = FileToPropertyTree(finishingAnimFileName);
	FinishingTemplateAnimObject.Serialize(*px);
	
}


void TMatch3FieldParams::Serialize(boost::property_tree::ptree& propertyTree)
{
	
	TChipTemplateParams chipTemplateParams;

	FieldWidth = propertyTree.get<cardinal>("Match3Params.FieldWidth");
	FieldHeight = propertyTree.get<cardinal>("Match3Params.FieldHeight");
	CellWidth = propertyTree.get<float>("Match3Params.CellWidth");
	CellHeight = propertyTree.get<float>("Match3Params.CellHeight");
	ChipLowestSpeed = propertyTree.get<float>("Match3Params.ChipLowestSpeed");
	ChipAcceleration = propertyTree.get<float>("Match3Params.ChipAcceleration");
	ChipPositionEpsilon = propertyTree.get<float>("Match3Params.ChipPositionEpsilon");
	ChipVelocityEpsilon = propertyTree.get<float>("Match3Params.ChipVelocityEpsilon");
	ChipK = propertyTree.get<float>("Match3Params.ChipK");
	ChipMatchTime = propertyTree.get<cardinal>("Match3Params.ChipMatchTime");
	ChipTypeCount = propertyTree.get<cardinal>("Match3Params.ChipTypeCount");

	BOOST_FOREACH(boost::property_tree::ptree::value_type &v, propertyTree.get_child("Match3Params.ChipList"))
	{
		boost::property_tree::ptree& p = v.second.get_child("");
		chipTemplateParams.Serialize(p);
		ChipTemplateParamsArr.push_back(chipTemplateParams);
	}

	
}

int TChip::StaticAnimationIndex = 0;

TChip::TChip(int chipType, TRenderPairList::iterator renderPair, cardinal vertexListShift, TChipState chipState)
	: ChipType(chipType)
	, RenderPair(renderPair)
	, VertexListShift(vertexListShift)
	, ChipState(chipState)
	, Velocity(0)
{
	AnimName = "test_anim"+tostr(StaticAnimationIndex++);
}

TChip::~TChip()
{
}

vec2 TChip::GetLeftBottomPos()
{
	std::vector<vec3>::iterator i = RenderPair->second.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].begin() + VertexListShift;

	return vec2(i->v[0], i->v[1]);
}

void TChip::SetLeftBottomPos(vec2 newPos)
{
	vec2 shift = newPos - GetLeftBottomPos();

	MoveLeftBottomPos(shift);
}

void TChip::MoveLeftBottomPos(vec2 shift)
{
	for (int i=0; i<6; i++)
	{
		*(RenderPair->second.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].begin() + VertexListShift + i) += vec3(shift, 0);
	}
}




TMatch3Logic::TMatch3Logic()
	//: TemplateAnimObject(TRenderPairList::iterator(), 0, 1)
{
	//TemplateAnimObject.Serialize(FileToPropertyTree("chip1_xml.xml"));
}


TMatch3Logic::~TMatch3Logic()
{

	//Match3FieldParams.ChipTemplateParamsArr.clear();

}

void TMatch3Logic::FillRandomChipMatrix(std::vector<TRenderPairList::iterator> renderPairIteratorVector, vec2 leftBottomPos)
{

	RenderPairIteratorVector = renderPairIteratorVector;
	
	LeftBottomPosField = leftBottomPos;

	ChipTypeCount = Match3FieldParams.ChipTypeCount;
	
	ChipMatrix.resize(Match3FieldParams.FieldWidth);

	for (cardinal i = 0; i < Match3FieldParams.FieldWidth; ++i)
	{
		for (cardinal j=0; j < Match3FieldParams.FieldHeight; ++j)
		{
			int chipType = rand() % ChipTypeCount;

			if (i == 0 && j == 6)
			{
				//AddChipToUp(i, chipType, GetExpectedLeftBottomPos(i, j), TChip::CS_LOCKED);
				AddChipToUp(i, chipType, GetExpectedLeftBottomPos(i, j), TChip::CS_STANDBY);
			}
			else
			{
				AddChipToUp(i, chipType, GetExpectedLeftBottomPos(i, j), TChip::CS_STANDBY);
			}
		}
	}

	

	std::vector<ivec2> chipList = GetAvailableMatchingChips();

	while (chipList.size() != 0)
	{
		UnmatchChips(chipList);
		chipList = GetAvailableMatchingChips();
	}

}


vec2 TMatch3Logic::GetExpectedLeftBottomPos(cardinal x, cardinal y)
{
	return LeftBottomPosField + vec2(x*Match3FieldParams.CellWidth, y*Match3FieldParams.CellHeight);
}



void TMatch3Logic::StartAnimateChip(cardinal x, cardinal y)
{
	ResourceManager->HalibutAnimationManager.StartAnimation(ChipMatrix[x][y].AnimName);
}

void TMatch3Logic::StopAnimateChip(cardinal x, cardinal y)
{
	
	ResourceManager->HalibutAnimationManager.StopAnimation(ChipMatrix[x][y].AnimName);
	
}


bool TMatch3Logic::ChipIsLocked(ivec2 chip)
{
	return ChipMatrix[chip.v[0]][chip.v[1]].ChipState == TChip::CS_LOCKED;
}

bool TMatch3Logic::ChipIsFinishing(ivec2 chip)
{
	return ChipMatrix[chip.v[0]][chip.v[1]].ChipState == TChip::CS_FINISHING;
}

bool TMatch3Logic::ChipIsStable(ivec2 chip)
{
	return ChipMatrix[chip.v[0]][chip.v[1]].ChipState == TChip::CS_STANDBY ||
		ChipMatrix[chip.v[0]][chip.v[1]].ChipState == TChip::CS_LOCKED;
}

bool TMatch3Logic::ChipCanBeSelected(ivec2 chip)
{

	if (ChipMatrix[chip.v[0]][chip.v[1]].ChipState != TChip::CS_STANDBY)
	{
		return false;
	}


	if (chip.v[1] == 0)
	{
		return true;
	}

	int i = chip.v[1] - 1;

	while (i >= 0 && ChipIsStable(ivec2(chip.v[0], i)) && !ChipIsLocked(ivec2(chip.v[0], i)))
	{
		i--;
	}

	if (i < 0 || ChipIsLocked(ivec2(chip.v[0], i)))
	{
		return true;
	}

	return false;


}

bool TMatch3Logic::ChipsCanBeSwapped(ivec2 p1, ivec2 p2)
{
	float distance_x = static_cast<float>(p1.v[0] - p2.v[0]);
	float distance_y = static_cast<float>(p1.v[1] - p2.v[1]);

	if ((((fabs(distance_x) == 1) && (fabs(distance_y) == 0))
		|| ((fabs(distance_x) == 0) && (fabs(distance_y) == 1))) &&
		ChipCanBeSelected(p1) &&
		ChipCanBeSelected(p2))
	{

		return true;
	}

	return false;
}

bool TMatch3Logic::ChipCanBeMatchedUp(ivec2 chip)
{
	if (chip.v[1] <= Match3FieldParams.FieldHeight - 3)
	{
		if ((ChipMatrix[chip.v[0]][chip.v[1]].ChipType == ChipMatrix[chip.v[0]][chip.v[1] + 1].ChipType)
			&& (ChipMatrix[chip.v[0]][chip.v[1]].ChipType == ChipMatrix[chip.v[0]][chip.v[1] + 2].ChipType))
		{

			if (ChipMatrix[chip.v[0]][chip.v[1]].ChipState == TChip::CS_STANDBY &&
				ChipMatrix[chip.v[0]][chip.v[1] + 1].ChipState == TChip::CS_STANDBY &&
				ChipMatrix[chip.v[0]][chip.v[1] + 2].ChipState == TChip::CS_STANDBY)
			{
				return true;
			}

			
		}
	}

	return false;
}

bool TMatch3Logic::ChipCanBeMatchedDown(ivec2 chip)
{
	if (chip.v[1] >= 2)
	{
		if ((ChipMatrix[chip.v[0]][chip.v[1]].ChipType == ChipMatrix[chip.v[0]][chip.v[1] - 1].ChipType)
			&& (ChipMatrix[chip.v[0]][chip.v[1]].ChipType == ChipMatrix[chip.v[0]][chip.v[1] - 2].ChipType))
		{
			if (ChipMatrix[chip.v[0]][chip.v[1]].ChipState == TChip::CS_STANDBY &&
				ChipMatrix[chip.v[0]][chip.v[1] - 1].ChipState == TChip::CS_STANDBY &&
				ChipMatrix[chip.v[0]][chip.v[1] - 2].ChipState == TChip::CS_STANDBY)
			{
				return true;
			}
		}
	}

	return false;
}

bool TMatch3Logic::ChipCanBeMatchedLeft(ivec2 chip)
{
	if (chip.v[0] >= 2)
	{
		if ((ChipMatrix[chip.v[0]][chip.v[1]].ChipType == ChipMatrix[chip.v[0] - 1][chip.v[1]].ChipType)
			&& (ChipMatrix[chip.v[0]][chip.v[1]].ChipType == ChipMatrix[chip.v[0] - 2][chip.v[1]].ChipType))
		{
			if (ChipMatrix[chip.v[0]][chip.v[1]].ChipState == TChip::CS_STANDBY &&
				ChipMatrix[chip.v[0] - 1][chip.v[1]].ChipState == TChip::CS_STANDBY &&
				ChipMatrix[chip.v[0] - 2][chip.v[1]].ChipState == TChip::CS_STANDBY)
			{
				return true;
			}
		}
	}

	return false;
}

bool TMatch3Logic::ChipCanBeMatchedRight(ivec2 chip)
{
	if (chip.v[0] <= Match3FieldParams.FieldWidth - 3)
	{
		if ((ChipMatrix[chip.v[0]][chip.v[1]].ChipType == ChipMatrix[chip.v[0] + 1][chip.v[1]].ChipType)
			&& (ChipMatrix[chip.v[0]][chip.v[1]].ChipType == ChipMatrix[chip.v[0] + 2][chip.v[1]].ChipType))
		{
			if (ChipMatrix[chip.v[0]][chip.v[1]].ChipState == TChip::CS_STANDBY &&
				ChipMatrix[chip.v[0] + 1][chip.v[1]].ChipState == TChip::CS_STANDBY &&
				ChipMatrix[chip.v[0] + 2][chip.v[1]].ChipState == TChip::CS_STANDBY)
			{
				return true;
			}
		}
	}

	return false;
}


void TMatch3Logic::UnmatchChips(std::vector<ivec2> chipList)
{
	std::vector<ivec2>::iterator i;

	for (i = chipList.begin(); i != chipList.end(); ++i)
	{

		ChangeChipType(*i);
	}
}

void TMatch3Logic::ReplaceAnimation(ivec2 p)
{
	

	TChip& chip = ChipMatrix[p.v[0]][p.v[1]];
	
	if (ResourceManager->HalibutAnimationManager.AnimationExists(chip.AnimName))
	{
		ResourceManager->HalibutAnimationManager.ReplaceAnimationObject(chip.AnimName, chip.RenderPair, chip.VertexListShift / 6);
	}
	else
	{
		
		THalibutExternalAnimObject testAnimObject(Match3FieldParams.ChipTemplateParamsArr[chip.ChipType].SelectedTemplateAnimObject);
		
		testAnimObject.ReplaceAnimObject(chip.RenderPair, chip.VertexListShift / 6);
		
		ResourceManager->HalibutAnimationManager.AddAnimationObject(chip.AnimName, testAnimObject);
		
	}

	ResourceManager->HalibutAnimationManager.StopAnimation(chip.AnimName);	
}


void TMatch3Logic::MoveVertexListShiftBack(TRenderPairList::iterator renderPairItr, cardinal moveFrom)
{
	for (cardinal i = 0; i < ChipMatrix.size(); i++)
	{
		for (cardinal j = 0; j < ChipMatrix[i].size(); j++)
		{
			if (ChipMatrix[i][j].RenderPair == renderPairItr)
			{
				if (ChipMatrix[i][j].VertexListShift > moveFrom)
				{
					ChipMatrix[i][j].VertexListShift -= 6;

					ReplaceAnimation(ivec2(i, j));
				}
			}
		}
	}
}

void TMatch3Logic::AddChipToUp(cardinal colNum, int chipType, vec2 spawnPos, TChip::TChipState chipState)
{
	cardinal yPos = ChipMatrix[colNum].size();

	vec2 posFrom = spawnPos;
	vec2 posTo = posFrom + vec2(Match3FieldParams.CellWidth, Match3FieldParams.CellHeight);

	cardinal renderPairIndex;

	if (chipState == TChip::CS_LOCKED)
	{
		renderPairIndex = chipType + Match3FieldParams.ChipTypeCount;
	}
	else
	{
		renderPairIndex = chipType;
	}

	TTriangleList& triangleList = RenderPairIteratorVector[renderPairIndex]->second;

	std::vector<vec3> vertexCoordArr = MakeVertexCoordVec(posFrom, posTo);

	std::vector<vec2> texCoordArr = MakeTexCoordVec();

	triangleList.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].insert(triangleList.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].end(), vertexCoordArr.begin(), vertexCoordArr.end());

	triangleList.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].insert(triangleList.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].end(), texCoordArr.begin(), texCoordArr.end());

	cardinal vertexListShift = RenderPairIteratorVector[renderPairIndex]->second.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].size()-6;

	ChipMatrix[colNum].push_back(TChip(chipType, RenderPairIteratorVector[renderPairIndex], vertexListShift, chipState));

	ReplaceAnimation(ivec2(colNum, yPos));

	triangleList.NeedRefreshBuffer = true;
}


void TMatch3Logic::InsertEmptyChip(cardinal colNum, cardinal rowNum, int chipType)
{

	vec2 posFrom = GetExpectedLeftBottomPos(colNum, rowNum);
	vec2 posTo = posFrom + vec2(Match3FieldParams.CellWidth, Match3FieldParams.CellHeight);
	
	cardinal renderPairIndex = Match3FieldParams.ChipTypeCount * 2 + chipType;

	TChip::TChipState chipState = TChip::CS_X;

	TTriangleList& triangleList = RenderPairIteratorVector[renderPairIndex]->second;

	std::vector<vec3> vertexCoordArr = MakeVertexCoordVec(posFrom, posTo);

	std::vector<vec2> texCoordArr = MakeTexCoordVec();

	triangleList.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].insert(triangleList.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].end(), vertexCoordArr.begin(), vertexCoordArr.end());

	triangleList.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].insert(triangleList.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].end(), texCoordArr.begin(), texCoordArr.end());

	cardinal vertexListShift = RenderPairIteratorVector[renderPairIndex]->second.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].size()-6;

	ChipMatrix[colNum].insert(ChipMatrix[colNum].begin() + rowNum, TChip(chipType, RenderPairIteratorVector[renderPairIndex], vertexListShift, chipState));

	ReplaceAnimation(ivec2(colNum, rowNum));


	triangleList.NeedRefreshBuffer = true;

	vec2 pos = GetExpectedLeftBottomPos(colNum, rowNum);

	ChipDeletingVector.push_back(TChipDeletingData(ivec2(colNum, rowNum), pos));
}



void TMatch3Logic::UpdateChipSwapping(cardinal dt)
{
	
	std::vector<TChipSwappingPair>::iterator i = ChipSwappingPairVector.begin();

	std::vector<std::pair<ivec2, ivec2> > chipsToSwapAgain;

	while (i != ChipSwappingPairVector.end())
	{
	
		i->T += dt / static_cast<float>(Match3FieldParams.ChipMatchTime);

		if (i->T >= 1.f)
		{

			ivec2 chip1pos = i->Chip1;
			ivec2 chip2pos = i->Chip2;

			bool isReturning = i->IsReturning;

			TChip& chip1 = ChipMatrix[chip1pos.v[0]][chip1pos.v[1]];
			TChip& chip2 = ChipMatrix[chip2pos.v[0]][chip2pos.v[1]];

		
			TChip c = chip1;
			chip1 = chip2;
			chip2 = c;


			ResetChipPos(chip1pos);
			ResetChipPos(chip2pos);

			chip1.ChipState = TChip::CS_STANDBY;
			chip2.ChipState = TChip::CS_STANDBY;


			i = ChipSwappingPairVector.erase(i);


			//Check if chips do 
			if (!isReturning)
			{
				std::vector<ivec2> matchingChipList = GetAvailableMatchingChips();

				if (matchingChipList.size() == 0)
				{
					//SwapChips(chip1pos, chip2pos);
					chipsToSwapAgain.push_back(std::pair<ivec2, ivec2>(chip1pos, chip2pos));
				}
			}
	
		}
		else
		{
			
			TChip& chip1 = ChipMatrix[i->Chip1.v[0]][i->Chip1.v[1]];
			TChip& chip2 = ChipMatrix[i->Chip2.v[0]][i->Chip2.v[1]];

			vec3 newPosChip1 = vec3(i->Chip1RealPosFrom + (i->Chip2RealPosFrom - i->Chip1RealPosFrom) * i->T, 0);
			vec3 newPosChip2 = vec3(i->Chip2RealPosFrom + (i->Chip1RealPosFrom - i->Chip2RealPosFrom) * i->T, 0);
			
			vec3 shiftChip1 = newPosChip1 - chip1.RenderPair->second.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB][chip1.VertexListShift];
			vec3 shiftChip2 = newPosChip2 - chip2.RenderPair->second.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB][chip2.VertexListShift];

			for (int k = 0; k < 6; k++)
			{

				chip1.RenderPair->second.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB][chip1.VertexListShift + k] += shiftChip1;
				chip2.RenderPair->second.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB][chip2.VertexListShift + k] += shiftChip2;
			}

			chip1.RenderPair->second.NeedRefreshBuffer = true;
			chip2.RenderPair->second.NeedRefreshBuffer = true;
		}


		if (i != ChipSwappingPairVector.end())
		{
			++i;
		}

	}

	std::vector<std::pair<ivec2, ivec2> >::iterator pairVecItr;

	for (pairVecItr = chipsToSwapAgain.begin(); pairVecItr != chipsToSwapAgain.end(); ++pairVecItr)	
	{
		SwapChips(pairVecItr->first, pairVecItr->second, true);
	}
}


void TMatch3Logic::UpdateChipPosition(cardinal dt)
{

	for (cardinal i=0; i<ChipMatrix.size(); i++)
	{
		for (cardinal j=1; j<ChipMatrix[i].size(); j++)
		{
			TChip& chip = ChipMatrix[i][j];

			TChip& chipBelow = ChipMatrix[i][j-1];
			if (chipBelow.ChipState == TChip::CS_FINISHING)
			{
				if (chip.ChipState != TChip::CS_LOCKED && chip.ChipState != TChip::CS_FINISHING && chip.ChipState != TChip::CS_X)
				{
					TChip c = chip;
					chip = chipBelow;
					chipBelow = c;
					chipBelow.ChipState = TChip::CS_FALLING;
				}
			}
		}
	}


	for (cardinal i=0; i<ChipMatrix.size(); i++)
	{
		for (cardinal j=0; j<ChipMatrix[i].size(); j++)
		{
			TChip& chip = ChipMatrix[i][j];
			if (chip.ChipState == TChip::CS_FALLING)
			{

				chip.Velocity += Match3FieldParams.ChipAcceleration * dt;

				if (chip.Velocity < Match3FieldParams.ChipLowestSpeed)
				{
					chip.Velocity = Match3FieldParams.ChipLowestSpeed;
				}

				float yShift = chip.Velocity * dt;

				chip.MoveLeftBottomPos(vec2(0, yShift));

				vec2 expectedPos = GetExpectedLeftBottomPos(i, j);
				vec2 realPos = chip.GetLeftBottomPos();

				if (realPos.v[1] < expectedPos.v[1] && chip.Velocity <= 0 && !(j > 0 && ChipIsFinishing(ivec2(i, j-1))))
				{
					
					chip.Velocity = -chip.Velocity * Match3FieldParams.ChipK;
					chip.SetLeftBottomPos(GetExpectedLeftBottomPos(i, j));
					
					
				}
				
				if (fabs(chip.Velocity) <= Match3FieldParams.ChipVelocityEpsilon)
				{
					
					if (fabs(expectedPos.v[0] - realPos.v[0]) <= Match3FieldParams.ChipPositionEpsilon &&
						fabs(expectedPos.v[1] - realPos.v[1]) <= Match3FieldParams.ChipPositionEpsilon
						)
					{
						chip.ChipState = TChip::CS_STANDBY;
						chip.SetLeftBottomPos(GetExpectedLeftBottomPos(i, j));
						chip.Velocity = 0.f;
					}
				}
				

				chip.RenderPair->second.NeedRefreshBuffer = true;

				for (cardinal k = j + 1; k < ChipMatrix[i].size(); k++)
				{

					TChip& chipAbove = ChipMatrix[i][k];

					vec2 posAbove = chipAbove.GetLeftBottomPos();

					if (chipAbove.GetLeftBottomPos().v[1] - chip.GetLeftBottomPos().v[1] < Match3FieldParams.CellHeight)
					{
						if (!ChipIsLocked(ivec2(i, k)) && !ChipIsFinishing(ivec2(i, k)))
						{
							chipAbove.ChipState = TChip::CS_FALLING;
							chipAbove.SetLeftBottomPos(chip.GetLeftBottomPos() + vec2(0, Match3FieldParams.CellHeight));
							chipAbove.Velocity = chip.Velocity;
							chipAbove.RenderPair->second.NeedRefreshBuffer = true;
						}
					}
				}
			}
		}
	}
}


void TMatch3Logic::RemoveBubbles()
{
	cardinal max_y = ChipMatrix.size()-1;

	for (cardinal i=0; i < ChipMatrix[max_y].size(); i++)
	{
		if (ChipMatrix[i][max_y].ChipState == TChip::CS_FINISHING)
		{
			DestroyChip(ivec2(i, max_y));
			AddChipToUp(i, rand() % ChipTypeCount, GetExpectedLeftBottomPos(i, ChipMatrix[i].size())+vec2(0, Match3FieldParams.CellHeight));
		}
	}
}

void TMatch3Logic::TryMatchAllChips()
{
	
	std::vector<ivec2> matchingChips = GetAvailableMatchingChips();
	
	std::vector<ivec2>::iterator i;

	for (i = matchingChips.begin(); i != matchingChips.end(); ++i)
	{
		ivec2 p = *i;

		int chipType = ChipMatrix[p.v[0]][p.v[1]].ChipType;
		DestroyChip(p);
		InsertEmptyChip(p.v[0], p.v[1], chipType);
	}

}

void TMatch3Logic::DestroyChip(ivec2 p)
{
	ChipMatrix[p.v[0]][p.v[1]].RenderPair->second.NeedRefreshBuffer = true;

	ResourceManager->HalibutAnimationManager.DeleteAnimationObject(ChipMatrix[p.v[0]][p.v[1]].AnimName);

	ChipMatrix[p.v[0]][p.v[1]].RenderPair->second.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].erase(
		ChipMatrix[p.v[0]][p.v[1]].RenderPair->second.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].begin() + ChipMatrix[p.v[0]][p.v[1]].VertexListShift,
		ChipMatrix[p.v[0]][p.v[1]].RenderPair->second.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].begin() + ChipMatrix[p.v[0]][p.v[1]].VertexListShift + 6);

	ChipMatrix[p.v[0]][p.v[1]].RenderPair->second.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].erase(
		ChipMatrix[p.v[0]][p.v[1]].RenderPair->second.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].begin() + ChipMatrix[p.v[0]][p.v[1]].VertexListShift,
		ChipMatrix[p.v[0]][p.v[1]].RenderPair->second.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].begin() + ChipMatrix[p.v[0]][p.v[1]].VertexListShift + 6);

	MoveVertexListShiftBack(ChipMatrix[p.v[0]][p.v[1]].RenderPair, ChipMatrix[p.v[0]][p.v[1]].VertexListShift);

	ChipMatrix[p.v[0]].erase(ChipMatrix[p.v[0]].begin() + p.v[1]);
	/*
	for (cardinal i=p.v[1]; i < ChipMatrix[p.v[0]].size(); i++)
	{
		if (!ChipIsLocked(ivec2(p.v[0], i)) && !ChipIsFinishing(ivec2(p.v[0], i)))
		{
			ChipMatrix[p.v[0]][i].ChipState = TChip::CS_FALLING;
		}
	}*/

}

void TMatch3Logic::ChangeChipType(ivec2 p)
{
	cardinal newChipType = rand() % ChipTypeCount;

	TChip& chip = ChipMatrix[p.v[0]][p.v[1]];

	std::vector<vec3>::iterator vertexCoordItrBegin = chip.RenderPair->second.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].begin() + chip.VertexListShift;
	std::vector<vec3>::iterator vertexCoordItrEnd = vertexCoordItrBegin + 6;

	std::vector<vec2>::iterator texCoordItrBegin = chip.RenderPair->second.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].begin() + chip.VertexListShift;
	std::vector<vec2>::iterator texCoordItrEnd = texCoordItrBegin + 6;

	std::vector<vec3> vertexCoordSubVec(vertexCoordItrBegin, vertexCoordItrEnd);
	std::vector<vec2> texCoordSubVec(texCoordItrBegin, texCoordItrEnd);

	chip.RenderPair->second.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].erase(vertexCoordItrBegin, vertexCoordItrEnd);
	chip.RenderPair->second.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].erase(texCoordItrBegin, texCoordItrEnd);

	MoveVertexListShiftBack(chip.RenderPair, chip.VertexListShift);

	chip.RenderPair->second.NeedRefreshBuffer = true;

	chip.ChipType = newChipType;

	RenderPairIteratorVector[newChipType]->second.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].insert(RenderPairIteratorVector[newChipType]->second.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].end(), vertexCoordSubVec.begin(), vertexCoordSubVec.end());
	RenderPairIteratorVector[newChipType]->second.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].insert(RenderPairIteratorVector[newChipType]->second.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].end(), texCoordSubVec.begin(), texCoordSubVec.end());

	RenderPairIteratorVector[newChipType]->second.NeedRefreshBuffer = true;

	chip.RenderPair = RenderPairIteratorVector[newChipType];
	chip.VertexListShift = RenderPairIteratorVector[newChipType]->second.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].size() - 6;

	//Hack to make sure animation is replaced by new one
	ResourceManager->HalibutAnimationManager.DeleteAnimationObject(chip.AnimName);
	ReplaceAnimation(ivec2(p.v[0], p.v[1]));


}


void TMatch3Logic::SelectChip(ivec2 pos)
{
	if (!(selectedChip == ivec2(-1, -1)))
	{
		StopAnimateChip(selectedChip.v[0], selectedChip.v[1]);
	}

	StartAnimateChip(pos.v[0], pos.v[1]);

	selectedChip = pos;
}


void TMatch3Logic::UnselectChip()
{
	if (!(selectedChip == ivec2(-1, -1)))
	{
		StopAnimateChip(selectedChip.v[0], selectedChip.v[1]);
		selectedChip = ivec2(-1, -1);
	}
}

ivec2 TMatch3Logic::GetSelectedChip()
{
	return selectedChip;
}

std::vector<ivec2> TMatch3Logic::GetAvailableMatchingChips()
{
	std::vector<ivec2> result;

	for (cardinal x=0; x<Match3FieldParams.FieldWidth; x++)
	{
		for (cardinal y=0; y<Match3FieldParams.FieldHeight; y++)
		{
			ivec2 chip = ivec2(x, y);


			
			if (ChipCanBeMatchedUp(chip))
			{
				if (std::find(result.begin(), result.end(), chip) ==  result.end())
				{
					result.push_back(chip);
				}

				if (std::find(result.begin(), result.end(), chip + ivec2(0, 1)) ==  result.end())
				{
					result.push_back(chip + ivec2(0, 1));
				}

				if (std::find(result.begin(), result.end(), chip + ivec2(0, 2)) ==  result.end())
				{
					result.push_back(chip + ivec2(0, 2));
				}
			}


			if (ChipCanBeMatchedDown(chip))
			{
				if (std::find(result.begin(), result.end(), chip) ==  result.end())
				{
					result.push_back(chip);
				}

				if (std::find(result.begin(), result.end(), chip - ivec2(0, 1)) ==  result.end())
				{
					result.push_back(chip - ivec2(0, 1));
				}

				if (std::find(result.begin(), result.end(), chip - ivec2(0, 2)) ==  result.end())
				{
					result.push_back(chip - ivec2(0, 2));
				}
			}


			if (ChipCanBeMatchedLeft(chip))
			{
				if (std::find(result.begin(), result.end(), chip) ==  result.end())
				{
					result.push_back(chip);
				}

				if (std::find(result.begin(), result.end(), chip - ivec2(1, 0)) ==  result.end())
				{
					result.push_back(chip - ivec2(1, 0));
				}

				if (std::find(result.begin(), result.end(), chip - ivec2(2, 0)) ==  result.end())
				{
					result.push_back(chip - ivec2(2, 0));
				}
			}


			if (ChipCanBeMatchedRight(chip))
			{
				if (std::find(result.begin(), result.end(), chip) ==  result.end())
				{
					result.push_back(chip);
				}

				if (std::find(result.begin(), result.end(), chip + ivec2(1, 0)) ==  result.end())
				{
					result.push_back(chip + ivec2(1, 0));
				}

				if (std::find(result.begin(), result.end(), chip + ivec2(2, 0)) == result.end())
				{
					result.push_back(chip + ivec2(2, 0));
				}
			}


		}
	}


	return result;
}


void TMatch3Logic::SwapChips(ivec2 p1, ivec2 p2, bool isReturning)
{
	vec2 chip1PosFrom(LeftBottomPosField.v[0] + p1.v[0]*Match3FieldParams.CellWidth, LeftBottomPosField.v[1] + p1.v[1]*Match3FieldParams.CellHeight);
	vec2 chip2PosFrom(LeftBottomPosField.v[0] + p2.v[0]*Match3FieldParams.CellWidth, LeftBottomPosField.v[1] + p2.v[1]*Match3FieldParams.CellHeight);
	ChipSwappingPairVector.push_back(TChipSwappingPair(p1, p2, chip1PosFrom, chip2PosFrom));

	(ChipSwappingPairVector.end() - 1)->IsReturning = isReturning;

	ChipMatrix[p1.v[0]][p1.v[1]].ChipState = TChip::CS_SWAPPING;
	ChipMatrix[p2.v[0]][p2.v[1]].ChipState = TChip::CS_SWAPPING;


}

void TMatch3Logic::ResetChipPos(ivec2 p)
{
	vec2 posFrom(LeftBottomPosField.v[0] + p.v[0]*Match3FieldParams.CellWidth, LeftBottomPosField.v[1] + p.v[1]*Match3FieldParams.CellHeight);
	vec2 posTo(LeftBottomPosField.v[0] + (p.v[0] + 1)*Match3FieldParams.CellWidth, LeftBottomPosField.v[1] + (p.v[1] + 1)*Match3FieldParams.CellHeight);
	
	std::vector<vec3> vertexCoordVec = MakeVertexCoordVec(posFrom, posTo);

	TChip& chip = ChipMatrix[p.v[0]][p.v[1]];

	for (cardinal i = 0; i<vertexCoordVec.size(); i++)
	{
		chip.RenderPair->second.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB][chip.VertexListShift + i] = vertexCoordVec[i];
	}

	chip.RenderPair->second.NeedRefreshBuffer = true;
	
	
}

void TMatch3Logic::UpdateLogic(cardinal dt)
{

	if (dt > 1000)
	{
		dt = 1000; //To prevent float overflow during looong laaaag
	}

	UpdateChipSwapping(dt);
	UpdateChipPosition(dt);
	TryMatchAllChips();
	
	std::vector<TChipDeletingData>::iterator i;

	bool erased = false;

	for (i = ChipDeletingVector.begin(); i != ChipDeletingVector.end();)
	{
		erased = false;

		i->T += dt / 150.f;

		if (i->T > 1.f)
		{
			i->T = 1.f;
		}

		ivec2 p = i->Chip;
		vec2 leftBottomPos = i->Pos;

		vec2 halfPos = vec2(Match3FieldParams.CellWidth / 2.f, Match3FieldParams.CellHeight / 2.f);

		vec2 centerPos = leftBottomPos + halfPos;

		std::vector<vec3> vertexCoordArr = MakeVertexCoordVec(centerPos - (1.f - i->T)*halfPos, centerPos + (1.f - i->T)*halfPos);

		for (int t = 0; t < 6; t++)
		{
			ChipMatrix[p.v[0]][p.v[1]].RenderPair->second.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB][ChipMatrix[p.v[0]][p.v[1]].VertexListShift + t] = vertexCoordArr[t];
		}


		if (i->T == 1.f)
		{
			
			ChipMatrix[p.v[0]][p.v[1]].ChipState = TChip::CS_FINISHING;

			i = ChipDeletingVector.erase(i);
			erased = true;
		}

		if (i  != ChipDeletingVector.end() && !erased)
		{
			++i;
		}
	}

	RemoveBubbles();
}



void TMatch3Logic::HitFieldWithPattern(ivec2 pos, std::vector<std::vector<char> > pattern, std::vector<std::vector<char> > jumpingPattern)
{

	const float CONST_VELOCITY_TO_ADD = 0.2f;

	for (cardinal i = 0; i < pattern.size(); i++)
	{
		for (int j = static_cast<int>(pattern[i].size()-1); j >=0; j--)
		{

			ivec2 fieldPos = pos + ivec2(i,j);

			if (fieldPos.v[0] >= 0 && fieldPos.v[0] < static_cast<int>(ChipMatrix.size()) &&
				fieldPos.v[1] >= 0 && fieldPos.v[1] < static_cast<int>(ChipMatrix[fieldPos.v[0]].size()))
			{

				if (ChipIsStable(fieldPos))
				{
					if (pattern[i][j] > 0)
					{
						DestroyChip(fieldPos);
						InsertEmptyChip(fieldPos.v[0], fieldPos.v[1], 0);
					}
				}

				if (ChipIsLocked(fieldPos))
				{
					ChipMatrix[fieldPos.v[0]][fieldPos.v[1]].ChipState = TChip::CS_STANDBY;
				}
			}
		}
	}

	for (cardinal i = 0; i < jumpingPattern.size(); i++)
	{
		
		ivec2 abovePos = pos + ivec2(i, jumpingPattern[i].size());
		
		if (abovePos.v[0] >= 0 && abovePos.v[0] < static_cast<int>(ChipMatrix.size()) &&
			abovePos.v[1] >= 0 && abovePos.v[1] < static_cast<int>(ChipMatrix[i].size()))
		{

			if (ChipMatrix[abovePos.v[0]][abovePos.v[1]].ChipState == TChip::CS_FALLING ||
				ChipMatrix[abovePos.v[0]][abovePos.v[1]].ChipState == TChip::CS_STANDBY)
			{
				ChipMatrix[abovePos.v[0]][abovePos.v[1]].ChipState = TChip::CS_FALLING;
				ChipMatrix[abovePos.v[0]][abovePos.v[1]].Velocity += CONST_VELOCITY_TO_ADD;
			}

		}

		
		for (cardinal j = 0; j < jumpingPattern[i].size(); j++)
		{

			ivec2 fieldPos = pos + ivec2(i,j);

			if (fieldPos.v[0] >= 0 && fieldPos.v[0] < static_cast<int>(ChipMatrix.size()) &&
				fieldPos.v[1] >= 0 && fieldPos.v[1] < static_cast<int>(ChipMatrix[fieldPos.v[0]].size()))
			{
				if (ChipMatrix[fieldPos.v[0]][fieldPos.v[1]].ChipState == TChip::CS_FALLING ||
					ChipMatrix[fieldPos.v[0]][fieldPos.v[1]].ChipState == TChip::CS_STANDBY)
				{
					if (jumpingPattern[i][j] > 0)
					{
						ChipMatrix[fieldPos.v[0]][fieldPos.v[1]].ChipState = TChip::CS_FALLING;
						ChipMatrix[fieldPos.v[0]][fieldPos.v[1]].Velocity += CONST_VELOCITY_TO_ADD;
					}
				}
			}
		}
	}


}



//================================================
//============ TMatch3Field ======================
//================================================


TMatch3Field::TMatch3Field()
{
	LastTappedPos = vec2(0,0);
}

TMatch3Field::TMatch3Field(const TMatch3Field& m)
{
	LastTappedPos = m.LastTappedPos;
	LastMovePos = m.LastMovePos;
}

TMatch3Field& TMatch3Field::operator=(const TMatch3Field& m)
{
	LastTappedPos = m.LastTappedPos;
	LastMovePos = m.LastMovePos;
	return *this;
}

TMatch3Field::TMatch3Field(TMatch3Controller& match3Controller)
	//: Match3Controller(match3Controller)
{
	//Match3Controller.Match3Field = this;

	FillBasicChipMatrixAndTriangleList();
}

TMatch3Field::~TMatch3Field()
{
}

void TMatch3Field::FillBasicChipMatrixAndTriangleList()
{
	TRenderParams renderParams;

	renderParams.Transparency = 1.f;

	
	boost::shared_ptr<boost::property_tree::ptree> px(FileToPropertyTree("match3params.xml"));
	Match3FieldParams.Serialize(*px);

	std::vector<TRenderPairList::iterator> triangleListVec;

	for (cardinal i = 0; i < Match3FieldParams.ChipTypeCount; i++)
	{
		TriangleListVector.push_back(TRenderPair(Match3FieldParams.ChipTemplateParamsArr[i].SelectedRenderParams, TTriangleList()));
	}

	
	renderParams.TexName = "chip1locked";
	TriangleListVector.push_back(TRenderPair(renderParams, TTriangleList()));
	
	renderParams.TexName = "chip2locked";
	TriangleListVector.push_back(TRenderPair(renderParams, TTriangleList()));

	renderParams.TexName = "chip3locked";
	TriangleListVector.push_back(TRenderPair(renderParams, TTriangleList()));

	renderParams.TexName = "chip4locked";
	TriangleListVector.push_back(TRenderPair(renderParams, TTriangleList()));
	
	
	
	
	for (cardinal i = 0; i < Match3FieldParams.ChipTypeCount; i++)
	{
		TriangleListVector.push_back(TRenderPair(Match3FieldParams.ChipTemplateParamsArr[i].FinishingRenderParams, TTriangleList()));
	}

	for (TRenderPairList::iterator i = TriangleListVector.begin(); i != TriangleListVector.end(); ++i)
	{
		

		triangleListVec.push_back(i);
	}

	LeftBottomPos = vec2(150, 0);

	FillRandomChipMatrix(triangleListVec, LeftBottomPos);
	
	//Init everything
	selectedChip = ivec2(-1, -1);

	for (TRenderPairList::iterator i = TriangleListVector.begin(); i != TriangleListVector.end(); ++i)
	{
		
		i->second.RefreshBuffer();
	}
	
}


ivec2 TMatch3Field::PosToChip(vec2 pos)
{
	
	int x, y;
	vec2 fieldPos = pos - LeftBottomPos;
	x = static_cast<int>(fieldPos.v[0] / Match3FieldParams.CellWidth);
	y = static_cast<int>(fieldPos.v[1] / Match3FieldParams.CellHeight);
	
	return ivec2(x, y);

}

void TMatch3Field::Update(cardinal dt)
{
	
	TMatch3Logic::UpdateLogic(dt);


		TRenderPairList::iterator i;
		for (i = TriangleListVector.begin(); i != TriangleListVector.end(); ++i)
		{
			if (i->second.NeedRefreshBuffer)
			{
				i->second.RefreshBuffer();
			}
		}

		int y = 6;
		y = 6 + y;
	

}

void TMatch3Field::OnTapDown(vec2 pos)
{
	//See also OnMove
	
	LastTappedPos = pos;
	LastMovePos = LastTappedPos;

	ivec2 chip = PosToChip(pos);
	


	/*
	To hit field by pattern
	std::vector<std::vector<char> > pattern;
	pattern.resize(3);
	pattern[0].resize(3);
	pattern[1].resize(3);
	pattern[2].resize(3);

	pattern[0][0] = 0; pattern[1][0] = 1; pattern[2][0] = 0;
	pattern[0][1] = 1; pattern[1][1] = 1; pattern[2][1] = 1;
	pattern[0][2] = 0; pattern[1][2] = 1; pattern[2][2] = 0;

	std::vector<std::vector<char> > jumpingPattern;
	jumpingPattern.resize(3);
	jumpingPattern[0].resize(3);
	jumpingPattern[1].resize(3);
	jumpingPattern[2].resize(3);

	jumpingPattern[0][0] = 0; jumpingPattern[1][0] = 0; jumpingPattern[2][0] = 0;
	jumpingPattern[0][1] = 0; jumpingPattern[1][1] = 0; jumpingPattern[2][1] = 0;
	jumpingPattern[0][2] = 1; jumpingPattern[1][2] = 0; jumpingPattern[2][2] = 1;


	HitFieldWithPattern(chip - ivec2(1, 1), pattern, jumpingPattern);

	return;*/


	
	if (selectedChip == chip)
	{
		UnselectChip();
	}
	else
	{

		if (ChipsCanBeSwapped(selectedChip, chip))
		{
			SwapChips(selectedChip, chip);
			UnselectChip();
		}
		else
		{
			if (ChipCanBeSelected(chip))
			{
				SelectChip(chip);
			}
		}

	}
}


void TMatch3Field::OnTapUp(vec2 pos)
{
	
}

void TMatch3Field::OnMove(vec2 shift)
{
	
	if (selectedChip == ivec2(-1, -1))
	{
		return;
	}

	LastMovePos += shift;

	if ((LastTappedPos - LastMovePos).v[0] >= Match3FieldParams.CellWidth * 0.5f)
	{
		ivec2 newPosChip = selectedChip + ivec2(1, 0);

		if (selectedChip.v[0] <= Match3FieldParams.FieldWidth - 2)
		{
			if (ChipsCanBeSwapped(selectedChip, newPosChip))
			{
				SwapChips(selectedChip, newPosChip);
				UnselectChip();
			}
		}
	}
	else if ((LastMovePos - LastTappedPos).v[0] >= Match3FieldParams.CellWidth * 0.5f)
	{
		ivec2 newPosChip = selectedChip - ivec2(1, 0);

		if (selectedChip.v[0] >= 1)
		{
			if (ChipsCanBeSwapped(selectedChip, newPosChip))
			{
				SwapChips(selectedChip, newPosChip);
				UnselectChip();
			}
		}
	}
	else if ((LastMovePos - LastTappedPos).v[1] >= Match3FieldParams.CellHeight * 0.5f)
	{
		ivec2 newPosChip = selectedChip + ivec2(0, 1);

		if (selectedChip.v[1] <= Match3FieldParams.FieldHeight - 2)
		{
			if (ChipsCanBeSwapped(selectedChip, newPosChip))
			{
				SwapChips(selectedChip, newPosChip);
				UnselectChip();
			}
		}
	}
	else if ((LastTappedPos - LastMovePos).v[1] >= Match3FieldParams.CellHeight * 0.5f)
	{
		ivec2 newPosChip = selectedChip - ivec2(0, 1);

		if (selectedChip.v[1] >= 1)
		{
			if (ChipsCanBeSwapped(selectedChip, newPosChip))
			{
				SwapChips(selectedChip, newPosChip);
				UnselectChip();
			}
		}
	}
	
}


bool TMatch3Field::CheckClick(vec2 mousePos)
{
	
	vec2 fieldPos = mousePos - LeftBottomPos;
	if (fieldPos.v[0] >= 0  && fieldPos.v[0] <= Match3FieldParams.FieldWidth*Match3FieldParams.CellWidth)
	{
		if (fieldPos.v[1] >= 0  && fieldPos.v[1] <= Match3FieldParams.FieldHeight*Match3FieldParams.CellHeight)
		{
			return true;
		}
	}
	
	return false;
}



void TMatch3Field::HighlightMatch3()
{
	
	std::vector<ivec2> chips = GetAvailableMatchingChips();

	std::vector<ivec2>::iterator i;

	for (i = chips.begin(); i != chips.end(); ++i)
	{
		ResourceManager->HalibutAnimationManager.StartAnimation(ChipMatrix[i->v[0]][i->v[1]].AnimName);
		
	}
}