// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010  Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.



#include "stdpch.h"
#include "precipitation.h"
#include "time_client.h"
//
#include "nel/misc/matrix.h"
#include "nel/misc/vector.h"
#include "nel/3d/u_particle_system_instance.h"

extern NL3D::UScene *Scene;


H_AUTO_DECL(RZ_Precipitation)

CPrecipitation::TClipGridMap CPrecipitation::_PrecipitationClipGripMap;

static const float DEFAUT_PRECIPITATION_TIMEOUT = 10.f; // at most 10 second before precipitations are removed


//============================================================
CPrecipitation::CPrecipitation() : _ClipGrid(NULL), _Strenght(0), _TimeOut(0.f), _XSize(0), _YSize(0), _OldX(0), _OldY(0), _Touched(false)
{
	H_AUTO_USE(RZ_Precipitation)
}

//============================================================
void CPrecipitation::init(const CPrecipitationDesc &desc)
{
	H_AUTO_USE(RZ_Precipitation)
	nlassert(desc.GridSize > 0);
	release();
	_Strenght = 0;
	_Desc = desc;
	if (!_Desc.ReleasableModel)
	{
		allocateFXs(); // keep fxs allocated;
		forceSetStrenght(0); // no precipitation is the default
	}
	_ClipGrid = NULL;
	_Touched = true;
}

//============================================================
void CPrecipitation::allocateFXs()
{
	H_AUTO_USE(RZ_Precipitation)
	if (!Scene) return;
	nlassert(_Blocks.empty()); // should be called only once
	_Blocks.resize(_Desc.GridSize * _Desc.GridSize);
	std::fill(_Blocks.begin(), _Blocks.end(), NL3D::UParticleSystemInstance ());
	for(uint k = 0; k < _Desc.GridSize * _Desc.GridSize; ++k)
	{
		_Blocks[k].cast (Scene->createInstance(_Desc.FxName.c_str()));
		if (_Blocks[k].empty())
		{
			nlwarning("can't find %s", _Desc.FxName.c_str());
			release();
			return;
		}
		_Blocks[k].forceInstanciate();
	}
	if (_Desc.UseBBoxSize)
	{
		NLMISC::CAABBox bbox;
		getBlock(0, 0).getShapeAABBox(bbox);
		_XSize = 2.f * bbox.getHalfSize().x;
		_YSize = 2.f * bbox.getHalfSize().y;
	}
	else
	{
		_XSize = _YSize = _Desc.Size;
	}

	// get the associated precipitation clipGrid if it hasn't yet
	/*
	if (!_ClipGrid)
	{
		NLMISC::CVector2f gridSize(_XSize, _YSize);
		TClipGridMap::iterator it = _PrecipitationClipGripMap.find(gridSize);
		if (it != _PrecipitationClipGripMap.end())
		{
			_ClipGrid = &it->second;
		}
		else
		{
			_ClipGrid = &(_PrecipitationClipGripMap[gridSize]);
			_ClipGrid->initGrid(_Desc.GridSize, _XSize, _YSize);
		}
	}
	*/
}

//============================================================
void CPrecipitation::deallocateFXs()
{
	H_AUTO_USE(RZ_Precipitation)
	if (Scene)
	{
		for(uint k = 0; k < _Blocks.size(); ++k)
		{
			Scene->deleteInstance(_Blocks[k]);
		}
		NLMISC::contReset(_Blocks);
	}
	_TimeOut = 0.f;
	_Touched = true;
}


//============================================================
void CPrecipitation::setStrenght(float strenght)
{
	H_AUTO_USE(RZ_Precipitation)
	if (strenght == _Strenght) return;
	forceSetStrenght(strenght);
}

//============================================================
void CPrecipitation::forceSetStrenght(float strenght)
{
	H_AUTO_USE(RZ_Precipitation)
	if (_Desc.ReleasableModel)
	{
		if (strenght > 0)
		{
			if (!areFXsAllocated())
			{
				allocateFXs();
			}
		}
	}
	 NLMISC::clamp(strenght, 0, 1);
	if (_Desc.GridSize == 0) return;
	if (!areFXsAllocated()) return;
	if (strenght <= 0.f)
	{
		if (_Strenght != 0.f)
		{
			_TimeOut = DEFAUT_PRECIPITATION_TIMEOUT;
		}
		for(uint k = 0; k < _Blocks.size(); ++k)
		{
			_Blocks[k].activateEmitters(false);
			_Blocks[k].setUserParam(0, strenght);
		}
	}
	else
	{
		_TimeOut = 0.f;
		for(uint k = 0; k < _Blocks.size(); ++k)
		{
			if (_Strenght == 0.f)
			{
				_Blocks[k].activateEmitters(true);
			}
			_Blocks[k].setUserParam(0, strenght);

		}
	}
	_Strenght = strenght;
}

//============================================================
void CPrecipitation::release()
{
	H_AUTO_USE(RZ_Precipitation)
	deallocateFXs();
}

//============================================================
bool CPrecipitation::isRunning() const
{
	H_AUTO_USE(RZ_Precipitation)
	if (!areFXsAllocated()) return false;
	// if the last particles have been removed, we can remove the models
	for(uint k = 0; k < _Blocks.size(); ++k)
	{
		if (_Blocks[k].hasParticles()) return true;
	}
	return false;
}

//============================================================
// snap a float by the given factor
static inline float fsnapf(float v, float mod)
{
	H_AUTO_USE(RZ_Precipitation)
	return mod * floorf(v / mod);
}

//============================================================
void CPrecipitation::update(const NLMISC::CMatrix &camMat, NLPACS::UGlobalRetriever * /* retriever */)
{
	H_AUTO_USE(RZ_Precipitation)
	if (_TimeOut != 0.f)
	{
		nlassert(_Strenght == 0.f);
		_TimeOut -= DT;
		if (_TimeOut <= 0.f)
		{
			_TimeOut = 0.f;
			deallocateFXs();
			return;
		}
	}
	if (_Desc.ReleasableModel)
	{
		if (_Strenght == 0.f && areFXsAllocated()) // no more precipitations & FXs are still allocated ? This means that there are particles left
		{
			if (!isRunning())
			{
				deallocateFXs();
				return;
			}
		}
	}
	if (!areFXsAllocated()) return;
	NLMISC::CVector userPos = camMat.getPos();
	//
	if (_XSize == 0 || _YSize == 0) return;

	// get world position of the user in grid units
	sint worldX = (sint) floorf(userPos.x / _XSize);
	sint worldY = (sint) floorf(userPos.y / _YSize);

	// See if we need to update pos
	if (_Touched || worldX != _OldX || worldY != _OldY)
	{
		_Touched = false;
		_OldX = worldX;
		_OldY = worldY;

		/*
		if (_ClipGrid)
		{
			_ClipGrid->updateGrid(userPos, retriever);
		}
		*/

		//
		// snap the user pos
		//
		NLMISC::CVector snappedPos(fsnapf(userPos.x, _XSize), fsnapf(userPos.y, _YSize), userPos.z);
		snappedPos -= NLMISC::CVector((float(_Desc.GridSize >> 1) - 0.5f) * _XSize, (float(_Desc.GridSize >> 1) - 0.5f) * _YSize, 0);
		// get world position of grid corner
//		sint gridCornerX = worldX - (_Desc.GridSize >> 1);
//		sint gridCornerY = worldY - (_Desc.GridSize >> 1);
		// move / show / hide each block
		for(uint k = 0; k < _Desc.GridSize; ++k)
		{
			NLMISC::CVector hPos = snappedPos;
			for(uint l = 0; l < _Desc.GridSize; ++l)
			{
				nlassert(!getBlock(l, k).empty());
				/*if (!_ClipGrid)
				{*/
					getBlock(l, k).setPos(hPos);
					hPos.x += _XSize;
				/*
				}
				else // use the clip grid to see if that block should be activated, and at what height it should be put
				{
					typedef CPrecipitationClipGrid::CGridPoint CGridPoint; // alias CGridPoint
					const CGridPoint *p0 = _ClipGrid->get(l + gridCornerX, k + gridCornerY);
					const CGridPoint *p1 = _ClipGrid->get(l + gridCornerX + 1, k + gridCornerY);
					const CGridPoint *p2 = _ClipGrid->get(l + gridCornerX + 1, k + gridCornerY + 1);
					const CGridPoint *p3 = _ClipGrid->get(l + gridCornerX, k + gridCornerY + 1);
					if (p0 && p1 && p2 && p3)
					{
						// if one of the 4 corners is in an interior, don't display the precipiations
						if (p0->Clipped || p1->Clipped || p2->Clipped || p3->Clipped)
						{
							getBlock(l, k).hide();
						}
						else
						{
							NL3D::UParticleSystemInstance psi = getBlock(l, k);
							psi.show();
							// take the mean height
							hPos.z = 0.25f * (p0->MeanHeight + p1->MeanHeight + p2->MeanHeight + p3->MeanHeight);
							psi.setPos(hPos);
						}
					}
					else
					{
						getBlock(l, k).setPos(hPos);
					}
					hPos.x += _XSize;
				}
				*/
			}
			snappedPos.y += _YSize;
		}
	}
}

//============================================================
void CPrecipitation::drawClipGrid(NL3D::UDriver &drv) const
{
	if (!_ClipGrid) return;
	_ClipGrid->display(drv);
}