// 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 "editor.h"
#include "tool_select_move.h"
#include "entity_sorter.h"
//
#include "../interface_v3/interface_manager.h"
#include "../client_cfg.h"
#include "../entities.h"
#include "../global.h"
#include "displayer_visual.h"
#include "../sheet_manager.h"

#include "dmc/com_lua_module.h"
//
#include "nel/misc/matrix.h"


using namespace NLMISC;


namespace R2
{

// ***************************************************************
CToolSelectMove::CToolSelectMove()
{
	_MouseX = -1;
	_MouseY = -1;
	_DeltaX = 0;
	_DeltaY = 0;
	_ValidPos = false;
	_State = Idle;
	_Moved = false;
	_Duplicating = false;
	_InitiallyAccessible = false;
	_InitiallyValidShape = true;
	_DeltaAnchor.set(0, 0, 0);
	_StartPos.set(0, 0, 0);
	_LastValidPos.set(0, 0, 0);
}


// ***************************************************************
bool CToolSelectMove::checkAdditionnalRoomLeftFor(CInstance &instance)
{
	//H_AUTO(R2_CToolSelectMove_checkAdditionnalRoomLeftFor)
	CLuaObject &luaProj = instance.getLuaProjection();
	CLuaState &ls = getEditor().getLua();
	CLuaStackRestorer lsr(&ls, 0);
	// check ai & static cost : if they are too big, can't create the duplicate
	if (!luaProj.callMethodByNameNoThrow("getAiCost", 0, 1)
		|| !ls.isNumber(-1))
	{
		return false;
	}
	uint aiCost = (uint) ls.toNumber(-1);
	ls.pop();
	if (!luaProj.callMethodByNameNoThrow("getStaticObjectCost", 0, 1))
	{
		return false;
	}
	uint staticCost = (uint) ls.toNumber(-1);
	ls.pop();
	if (!getEditor().verifyRoomLeft(aiCost, staticCost))
	{
		return false;
	}
	return true;
}


// ***************************************************************
CInstance *CToolSelectMove::createGhost(CInstance &instance)
{
	//H_AUTO(R2_CToolSelectMove_createGhost)
	CLuaState &ls = getEditor().getLua();
	// copy then do a local paste
	CLuaStackRestorer lsr(&ls, 0);
	//
	CLuaObject &luaProj = instance.getLuaProjection();
	CLuaObject &classDef = instance.getClass();
	if (luaProj.callMethodByNameNoThrow("copy", 0, 1))
	{
		// now we got a table that is an exact (canonical) copy of the original object, with the
		// same instance ids..
		// prepare for new insertion by renaming these instance id's (which 'newCopy' does)
		if (classDef["newCopy"].callNoThrow(1, 1))
		{
			// now, insert the new copy as a ghost in the new scene
			if (classDef["pasteGhost"].callNoThrow(1, 1))
			{

				CLuaObject ghost(ls); // pop the ghost from stack
				CInstance *newInst = getEditor().getInstanceFromId(ghost["InstanceId"].toString());
				if (newInst)
				{
					if (!newInst->getGhost())
					{
						nlwarning("When duplicating an object using the 'select/move' tool, temporary duplicate should be inserted \
								   as a ghost in the scene, removing object...");
						getEditor().getDMC().requestEraseNode(newInst->getId(), "", -1);
					}
					// set the flag so that the cost of this object isn't taken in account in the displayed quotas
					newInst->getLuaProjection()["User"].setValue("GhostDuplicate", true);
					getEditor().setSelectedInstance(newInst);
					newInst->getDisplayerVisual()->setDisplayFlag(CDisplayerVisual::FlagHideActivities, true);
					nlwarning("CToolSelectMove: beginning duplicate with instance with id %s", newInst->getId().c_str());
					// show in "frozen" state
					{
						/*CObjectNumber *numberValue = new CObjectNumber(2); // 2 = frozen state
						getEditor().getDMC().requestSetNode(newInst->getId(), "DisplayMode", numberValue);
						delete numberValue;
						*/
						newInst->getDisplayerVisual()->setDisplayMode(CDisplayerVisual::DisplayModeFrozen);
						getEditor().getEntitySorter()->clipEntitiesByDist();
						return newInst;
					}
				}
			}
		}
	}
	return NULL;
}

// ***************************************************************
void CToolSelectMove::beginAction(CInstance &instance)
{
	_DeltaAnchor.set(0, 0, 0);
	//H_AUTO(R2_CToolSelectMove_beginAction)
	_StartTime = T1;
	CDisplayerVisual *dv = instance.getDisplayerVisual();
	if(!dv)
	{
		cancel();
		return;
	}
	_InitiallyAccessible = dv->isAccessible();
	_InitiallyValidShape = true;
	CDisplayerVisual *parentDV = dv->getParent();
	if (parentDV && parentDV->isGroup())
	{
		_InitiallyAccessible = _InitiallyAccessible && parentDV->isAccessible();
		_InitiallyValidShape = parentDV->isValidShape();
	}
	//
	getMousePos(_MouseX, _MouseY);
	// must work with eval link point because world pos may be realy far from link pos (for regions)
	ISelectableObject::TSelectionType selectionType = dv->getSelectionType();
	switch(selectionType)
	{
		case ISelectableObject::GroundProjected:
		{
			// because displayed instance is projected on scene (like roads, regions ...)
			// anchor point is scene / mouse ray intersection point
			CTool::CWorldViewRay worldViewRay;
			computeWorldViewRay(_MouseX, _MouseY, worldViewRay);
			CVector inter;     // intersection of view ray with landscape
			_ValidPos = false;
			switch(computeLandscapeRayIntersection(worldViewRay, inter))
			{
				case NoIntersection:
						return;
				break;
				case ValidPacsPos:
				case InvalidPacsPos:
					_StartPos = inter;
				break;
				default:
					nlassert(0);
				break;
			}
		}
		break;
		case ISelectableObject::LocalSelectBox:
		case ISelectableObject::WorldSelectBox:
			dv->snapToGround();
			_StartPos = dv->evalLinkPoint(false);
		break;
		default:
			nlassert(0);
		break;
	}
	_DeltaAnchor = _StartPos - dv->getWorldPos();
	// nico : tmp fix to have correct z until luaSnapToGround is fixed
	if (instance.getEntity())
	{
		instance.getEntity()->snapToGround();
		_StartPos.z = instance.getEntity()->pos().z;
	}
	//nlwarning("starting to move instance at pos %s", NLMISC::toString(_StartPos.asVector()).c_str());
	const NL3D::CFrustum &fru = MainCam.getFrustum();
	CVector posInCam = MainCam.getMatrix().inverted() * _StartPos;
	CVector projectedPos = fru.projectZ(posInCam);
	/** Compute delta in screen space between instance position and the click position
	  * We maintain that delta when the instance moves
	  */
	uint32 w, h;
	getScreenSize(w, h);
	if (!isMouseOnWorldMap())
	{
		_DeltaX = _MouseX - (sint32) (w * projectedPos.x);
		_DeltaY = _MouseY - (sint32) (h * projectedPos.y);
	}
	else
	{
		_DeltaX = 0;
		_DeltaY = 0;
	}
	///////////////////////
	// TMP TMP TMP
	_PosRefX = (sint32) (w * projectedPos.x);
	_PosRefY = (sint32) (h * projectedPos.y);

	//
	/*
	CVector debugPos;
	CVector rayOrigin;
	CVector rayDir;
	computeWorldViewRay(_MouseX - _DeltaX, _MouseY - _DeltaY, rayOrigin, rayDir);
	computeLandscapeRayIntersection(rayOrigin, rayOrigin + 1000.f * rayDir, debugPos);
	*/
	//nlwarning("ref point = %s", NLMISC::toString(debugPos).c_str());
	//
	_RefX = _MouseX - _DeltaX;
	_RefY = _MouseY - _DeltaY;
	//
	_MouseRefX = _MouseX;
	_MouseRefY = _MouseY;
	///////////////////////
	_ValidPos = false;
	_Moved = false;

	if (isShiftDown())
	{
		// see in advance if there will be room left to create a duplicate for this object
		if (!checkAdditionnalRoomLeftFor(instance))
		{
			_State = Idle;
			getEditor().setCurrentTool(NULL);
			return;
		}
		_Duplicating = true;
		_ValidPos = true; // valid pos for first frame
		_FinalPos = _StartPos;
		_GhostInstance = NULL;
	}
	_LastValidPos = _StartPos;
	dv->setMoveInProgress(true);
}

// ***************************************************************
void CToolSelectMove::cancelAction(CInstance &instance)
{
	//H_AUTO(R2_CToolSelectMove_cancelAction)
	CDisplayerVisual *dv = instance.getDisplayerVisual();
	nlassert(dv);
	dv->setMoveInProgress(false);
	if (_Moved)
	{
		std::string posInstanceId = instance.getPosInstanceId();
		if (posInstanceId.empty()) return;
		getEditor().requestRollbackLocalNode(posInstanceId, "");
	}
	if (_Duplicating)
	{
		// remove the ghost node
		if (_GhostInstance)
		{
			nlassert(_GhostInstance->getGhost()); // should have been inserted as a ghost in the scene
			//
			getEditor().getDMC().requestEraseNode(_GhostInstance->getId(), "", -1);
		}
	}
	_Duplicating = false;
}

// ***************************************************************
void CToolSelectMove::commitAction(CInstance &instance)
{
	//H_AUTO(R2_CToolSelectMove_commitAction)
	CDisplayerVisual *dv = instance.getDisplayerVisual();
	nlassert(dv);
	dv->setMoveInProgress(false);
	if (!_ValidPos)
	{
		cancelAction(instance);
	}
	else
	{
		if (_Duplicating && _Moved)
		{

			if (!_GhostInstance)
			{
				cancelAction(instance);
				return;
			}
			if (!_GhostInstance->getGhost())
			{
				cancelAction(instance);
				return;
			}

			CLuaState &ls = getEditor().getLua();
			CLuaObject luaProj = _GhostInstance->getLuaProjection();
			if (!checkAdditionnalRoomLeftFor(*_GhostInstance))
			{
				cancelAction(instance);
				return;
			}


			CLuaStackRestorer lsr(&ls, ls.getTop());
			// duplicate the ghost, and insert in the scene for real
			CLuaObject classDef = instance.getClass();
			std::string oldName = luaProj["Name"].toString(); // keep name, because the newCopy call
														   // will generate a newone, causing indices to increase 2 by 2

			// restore default value for display mode
			//getEditor().getDMC().requestEraseNode(_GhostInstance->getId(), "DisplayMode", -1);
			if (_GhostInstance->getDisplayerVisual())
			{
				_GhostInstance->getDisplayerVisual()->setDisplayMode(CDisplayerVisual::DisplayModeVisible);
			}

			if (_Moved)
			{
				if (luaProj.callMethodByNameNoThrow("copy", 0, 1))
				{
					{
						std::string posInstanceId = instance.getPosInstanceId();
						if (!posInstanceId.empty())
						{
							getEditor().requestRollbackLocalNode(posInstanceId, ""); // Locally modified coords have
																					 // (of a local object ...)
																					 // have been read during the copy,
																					 // get rid of them...
						}
					}
					getDMC().newAction(CI18N::get("uiR2EDCopyAction") + _GhostInstance->getDisplayName());
					getEditor().getDMC().requestEraseNode(_GhostInstance->getId(), "", -1);
					// now, instanciate cannonical copy
					if (classDef["newCopy"].callNoThrow(1, 1))
					{
						// set real pos for the copy & the name
						CLuaObject newCopy(ls);
						CLuaObject pos = newCopy["Position"];
						try
						{
							newCopy.setValue("Name", oldName);
							pos.setValue("x", _FinalPos.x);
							pos.setValue("y", _FinalPos.y);
							pos.setValue("z", _FinalPos.z);
						}
						catch(ELuaNotATable &)
						{
							nlwarning("Error while setting position of copied object");
						}
						// ... and paste for real
						if (_AutoGroup.getGroupingCandidate())
						{
							newCopy.push();
							std::auto_ptr<CObject> desc(CComLuaModule::getObjectFromLua(ls.getStatePointer()));
							_AutoGroup.group(desc.get(), _FinalPos);
						}
						else
						{
							newCopy.push();
							ls.push(false); // second parameter is for "not a new place"
							ls.push(instance.getId()); // last param give the original instance id of the object being copied
							classDef["paste"].callNoThrow(3, 1);
							getEditor().getDMC().getActionHistoric().endAction();
							getEditor().getDMC().flushActions();
						}
					}
				}
				else
				{
					std::string posInstanceId = instance.getPosInstanceId();
					if (!posInstanceId.empty())
					{
						getEditor().requestRollbackLocalNode(posInstanceId, ""); // Locally modified coords
																				 // (of a local object ...)
																				 // have been read during the copy,
																				 // get rid of them...
					}
				}
			}
			_Duplicating = false;
		}
		else
		if (_Moved)
		{
			if (!_ValidPos)
			{
				cancelAction(instance);
			}
			else
			{
				ucstring instanceName = instance.getDisplayName();
				if(instanceName == CI18N::get("uiR2EDNoName"))
					instanceName = ucstring(instance.getClassName());

				//getDMC().newAction(CI18N::get("uiR2EDMoveAction") + instance.getDisplayName());
				getDMC().newAction(CI18N::get("uiR2EDMoveAction") + instanceName);
				std::string posInstanceId = instance.getPosInstanceId();
				if (posInstanceId.empty()) return;
				std::string instanceId = instance.getObjectTable()->getAttr("InstanceId")->toString();
				R2::getEditor().getLua().push(instanceId);
				R2::getEditor().callEnvFunc( "checkLeaderDistAndUngroup", 1, 0);
				getEditor().requestCommitLocalNode(posInstanceId, "");
			}
		}
		else
		{
			cancelAction(instance);
		}
	}
}

// ***************************************************************
const char *CToolSelectMove::getCursorForPossibleAction() const
{
	//H_AUTO(R2_CToolSelectMove_getCursorForPossibleAction)
	return isShiftDown() ? "curs_can_pan_dup.tga" : "curs_can_pan.tga";
}

// ***************************************************************
const char *CToolSelectMove::getDefaultCursor() const
{
	//H_AUTO(R2_CToolSelectMove_getDefaultCursor)
	if (isMouseOnUI() && !isMouseOnWorldMap()) return DEFAULT_CURSOR;
	return isShiftDown() ? "curs_dup.tga" : DEFAULT_CURSOR;
}

// ***************************************************************
const char *CToolSelectMove::getPickCursor() const
{
	//H_AUTO(R2_CToolSelectMove_getPickCursor)
	return isShiftDown() ? "curs_pick_dup.tga" : "curs_pick.tga";
}


// ***************************************************************
void CToolSelectMove::updateAction(CInstance &instance)
{
	//H_AUTO(R2_CToolSelectMove_updateAction)
	CDisplayerVisual *vd = _GhostInstance ? _GhostInstance->getDisplayerVisual() : instance.getDisplayerVisual();
	if(!vd) return;
	setMouseCursor(_Duplicating ? "curs_pan_dup.tga" : "curs_pan.tga");
	sint32 mx, my;
	getMousePos(mx, my);
	sint32 autoPanDx, autoPanDy;
	handleWorldMapAutoPan(autoPanDx, autoPanDy);
	CDisplayerVisual *vdParent = vd->getParent();
	if (mx != _MouseX || my != _MouseY || autoPanDx || autoPanDy)
	{
		if (!autoPanDx && !autoPanDy)
		{
			const sint32 moveThreshold = 2;
			const sint32 timeThreshold = 300; // if some time elapsed, then do the move
			if (!_Moved && abs(mx - _MouseRefX) < moveThreshold && abs(my - _MouseRefY) < moveThreshold &&
				 (T1 - _StartTime) < timeThreshold
			   )
			{
				// discard small displacement when clicking (move is unwanted most of the time)
				return;
			}
		}

		if (_Duplicating && !_GhostInstance)
		{
			_GhostInstance = createGhost(instance);
			if (!_GhostInstance)
			{
				_State = Idle;
				getEditor().setCurrentTool(NULL);
				return;
			}
			vd = _GhostInstance->getDisplayerVisual();
			if (!vd) return;
			vdParent = vd->getParent();
		}
		//
		_Moved = true;
		// mouse has moved
		// TODO : onMouseMove msg
		// update mouse pos
		_MouseX = mx;
		_MouseY = my;
		//
		CTool::CWorldViewRay worldViewRay;
		//
		_ValidPos = true;
		//
		if (!isMouseOnWorldMap())
		{
			if (isMouseOnUI())
			{
				_FinalPos = _LastValidPos;
				_ValidPos = false;
			}
			else
			{
				computeWorldViewRay(mx - _DeltaX, my - _DeltaY, worldViewRay);
			}
		}
		else
		{
			computeWorldViewRay(mx, my, worldViewRay);
			if (!worldViewRay.OnMiniMap)
			{
				_FinalPos = _LastValidPos;
				_ValidPos = false;
			}
		}
		if (_ValidPos)
		{
			CVector inter;     // intersection of view ray with landscape
			_ValidPos = false;
			switch(computeLandscapeRayIntersection(worldViewRay, inter))
			{
				case NoIntersection:
					// no collision, can't drop instance, so let it at its start position
					_FinalPos = _LastValidPos;
					_ValidPos = false;
				break;
				case ValidPacsPos:
					//nlwarning("moving instance at pos %s", NLMISC::toString(inter).c_str());
					_FinalPos = inter;
					_ValidPos = isValid2DPos(inter);
					if (_ValidPos)
					{
						_LastValidPos = _FinalPos;
					}

				break;
				case InvalidPacsPos:
					// If the object moved is a region or a group, invalid pacs pos
					// may still be acceptable as long as an intersection was found
					if (vd->isInvalidPacsPosAcceptable())
					{
						_FinalPos = inter;
						_ValidPos = true; // good pos to drop instance
					}
					else
					{
						_FinalPos = inter;
						_ValidPos = false;
					}
				break;
				default:
					nlassert(0);
				break;
			}
		}
		_FinalPos = _FinalPos - _DeltaAnchor;
		// make final pos relative to parent
		if (!_Duplicating && vd->inheritPos() && instance.getParent())
		{
			if (vdParent)
			{
				_FinalPos = _FinalPos - vdParent->getWorldPos();
			}
		}
		//
		setInstancePos(_FinalPos, instance);
	}
	if (_InitiallyAccessible)
	{
		// NB : do not do the test if initially inaccessible to allow user to go to an 'accessible' state more easily
		if (!vd->isAccessible())
		{
			_ValidPos = false;
		}
		if (vdParent && !vdParent->isAccessible())
		{
			_ValidPos = false;
		}
	}
	//
	if (_InitiallyValidShape)
	{
		// is started from an invalid shape, allow to use intermediate invalid shapes to correct it
		if (vdParent && vdParent->isGroup() && !vdParent->isValidShape())
		{
			_ValidPos = false;
		}
	}

	if (_Moved && _ValidPos)
	{
		std::string instanceId = instance.getObjectTable()->getAttr("InstanceId")->toString();
		R2::getEditor().getLua().push(instanceId);
		R2::getEditor().callEnvFunc( "checkGroupDistance", 1, 1);
		if (!R2::getEditor().getLua().isBoolean(-1))
		{
			nlassert(0 && "checkGroupDistance return wrong type");
		}
		bool positionOk = R2::getEditor().getLua().toBoolean(-1);
		R2::getEditor().getLua().pop();
		_ValidPos = positionOk;
	}


	//
	if (!_ValidPos && _Moved)
	{
		setMouseCursor("curs_stop.tga");
	}
	// TMP TMP
	/*
	{
		uint32 w, h;
		getScreenSize(w, h);
		Driver->setMatrixMode3D(MainCam);
		Driver->setModelMatrix(CMatrix::Identity);
		drawBox(_StartPos - CVector(0.02f, 0.02f, 0.02f), _StartPos + CVector(0.02f, 0.02f, 0.02f), CRGBA::Magenta);
		Driver->setMatrixMode2D11();
		Driver->drawLine((_RefX - 5) / (float) w, _RefY / (float) h, (_RefX + 5) / (float) w, _RefY / (float) h, CRGBA::Red);
		Driver->drawLine(_RefX / (float) w, (_RefY - 5) / (float) h, _RefX / (float) w, (_RefY + 5) / (float) h, CRGBA::Red);
		//
		Driver->drawLine((_PosRefX - 5) / (float) w, _PosRefY / (float) h, (_PosRefX + 5) / (float) w, _PosRefY / (float) h, CRGBA::Green);
		Driver->drawLine(_PosRefX / (float) w, (_PosRefY - 5) / (float) h, _PosRefX / (float) w, (_PosRefY + 5) / (float) h, CRGBA::Green);
		//
		Driver->drawLine((_MouseRefX - 5) / (float) w, _MouseRefY / (float) h, (_MouseRefX + 5) / (float) w, _MouseRefY / (float) h, CRGBA::Yellow);
		Driver->drawLine(_MouseRefX / (float) w, (_MouseRefY - 5) / (float) h, _MouseRefX / (float) w, (_MouseRefY + 5) / (float) h, CRGBA::Yellow);
		//
	}
	*/
}

// ***************************************************************
void CToolSelectMove::setInstancePos(const NLMISC::CVectorD &pos, CInstance &instance)
{
	//H_AUTO(R2_CToolSelectMove_setInstancePos)
	std::string posInstanceId = instance.getPosInstanceId();
	if (posInstanceId.empty()) return;
	CObject *newPos = buildVector(pos, posInstanceId);
	getEditor().requestSetLocalNode(_GhostInstance ? _GhostInstance->getId() : instance.getId(), "Position", newPos);
	delete newPos;
}

// ***************************************************************
bool CToolSelectMove::isActionPossibleOn(const CInstance &instance) const
{
	//H_AUTO(R2_CToolSelectMove_isActionPossibleOn)
	CInstance &mutableInstance = const_cast<CInstance &>(instance);
	CDisplayerVisual *dv = mutableInstance.getDisplayerVisual();
	if (dv && dv->getActualDisplayMode() != CDisplayerVisual::DisplayModeVisible)
	{
		return false;
	}
	if (isShiftDown())
	{
		CLuaStackRestorer lsr(&getEditor().getLua(), 0);
		mutableInstance.getLuaProjection().callMethodByNameNoThrow("isCopyable", 0, 1); // isCopyable should be 'const', so no worries here ...
		if (getEditor().getLua().toBoolean(1))
		{
			return true;
		}
		return false;
	}
	return true;
}

// ***************************************************************
void CToolSelectMove::onActivate()
{
	//H_AUTO(R2_CToolSelectMove_onActivate)
	setContextHelp(CI18N::get("uiR2EDToolSelectMove"));
}

// ***************************************************************
void CToolSelectMove::updateBeforeRender()
{
	//H_AUTO(R2_CToolSelectMove_updateBeforeRender)
	if (_Duplicating && _GhostInstance)
	{
		_AutoGroup.update(_FinalPos, _GhostInstance->getPaletteId(), _ValidPos && !isCtrlDown());
		_GhostInstance->getDisplayerVisual()->setDisplayFlag(CDisplayerVisual::FlagHideActivities, _AutoGroup.getGroupingCandidate() != NULL);
	}
	else
	{
		if (!_Duplicating && _GhostInstance) _GhostInstance->getDisplayerVisual()->setDisplayFlag(CDisplayerVisual::FlagHideActivities, false);
	}
}

/////////////////////
// ACTION HANDLERS //
/////////////////////


/**
  * Make the select/move tool current
  */
class CAHSelectMove : public IActionHandler
{
	virtual void execute(CCtrlBase * /* pCaller */, const std::string &/* sParams */)
	{
		getEditor().setCurrentTool(new CToolSelectMove);
	}
};
REGISTER_ACTION_HANDLER(CAHSelectMove, "r2ed_select_move");



} // R2