// 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 "ai_player.h"
#include "ai_bot_fauna.h"
#include "ai_bot_npc.h"

using namespace MULTI_LINE_FORMATER;


//////////////////////////////////////////////////////////////////////////////
// CBotPlayer                                                               //
//////////////////////////////////////////////////////////////////////////////

CBotPlayer::CBotPlayer(CManagerPlayer* owner, TDataSetRow const& DataSetRow, NLMISC::CEntityId const& id, uint32 level)
: CChild<CManagerPlayer>(owner)
, CAIEntityPhysical(static_cast<CPersistentOfPhysical&>(*this), DataSetRow, id, 0.5f, level, RYAI_MAP_CRUNCH::Nothing)
, _CurrentTeamId(CTEAM::InvalidTeamId)
, _FollowMode(false)
, _Aggroable(true)
{
#ifdef NL_DEBUG
	nlassert(owner->playerList().find(dataSetRow())==owner->playerList().end());
#endif
	owner->playerList().insert(std::make_pair(dataSetRow(), this));
	NLMISC::CSheetId sheetId = CMirrors::sheet(DataSetRow);
	_Sheet = AISHEETS::CSheets::getInstance()->lookupRaceStats(sheetId);
}

CBotPlayer::~CBotPlayer()
{
	getOwner()->playerList().erase(dataSetRow());
	if (isSpawned())
	{
		despawnBot();
	}
}

std::string	CBotPlayer::getIndexString()	const
{
	return	getOwner()->getIndexString()+NLMISC::toString(":p%u", getChildIndex());
}

std::string CBotPlayer::getEntityIdString() const
{
	return getEntityId().toString() ;
}

std::string	CBotPlayer::getOneLineInfoString() const
{
	return std::string("Player '") + getEntityId().toString() + "'";
}

std::vector<std::string> CBotPlayer::getMultiLineInfoString() const
{
	std::vector<std::string> container;
	
	
	pushTitle(container, "CBotPlayer");
	pushEntry(container, "id=" + getIndexString());
	container.back() += " eid=" + getEntityIdString();
	container.back() += " teamid=" + NLMISC::toString("%u", _CurrentTeamId);
	pushFooter(container);
	
	
	return container;
}

void CBotPlayer::processEvent(CCombatInterface::CEvent const& event)
{
	//	if heal happends, dispatch aggro on targetters.	
	if (event._nature==ACTNATURE::CURATIVE_MAGIC && event._weight>=0)
	{
		float aggro = -event._weight;
		if (aggro>-0.5f)
			aggro = -0.5f;
		else if (aggro<-1.f)
			aggro = -1.f;
		
		CAIEntityPhysical const* const targetBot = CAIS::instance().getEntityPhysical(event._targetRow);
		
		if (targetBot)
		{
			CAIEntityPhysical* targeter = targetBot->firstTargeter();
			while (targeter)
			{
				if (targeter->dataSetRow()!=event._originatorRow)
				{
					switch (targeter->getRyzomType())
					{
					case RYZOMID::creature:
						{
							CSpawnBotFauna* const fauna = NLMISC::safe_cast<CSpawnBotFauna*>(targeter);
							fauna->addAggroFor(event._originatorRow, aggro, true);
						}
						break;
					case RYZOMID::npc:
						{
							CSpawnBotNpc* const npc = NLMISC::safe_cast<CSpawnBotNpc*>(targeter);
							npc->addAggroFor(event._originatorRow, aggro, true);
						}
						break;
					default:
						break;
					}
				}
				targeter = targeter->nextTargeter();
			}
		}
	}
}

void CBotPlayer::updatePos()
{
	RYAI_MAP_CRUNCH::CWorldPosition	wpos;
	if (!CWorldContainer::getWorldMap().setWorldPosition(pos().h(), wpos,CAIVector(pos())))
	{
		_PlayerPosIsInvalid = true;
		return;
	}
	_PlayerPosIsInvalid = false;
	setWPos(wpos);
	linkEntityToMatrix(this->pos(),getOwner()->getOwner()->playerMatrix());
	
	if (wpos.getFlags()&RYAI_MAP_CRUNCH::Water)
		setActionFlags(RYZOMACTIONFLAGS::InWater);
	else
		removeActionFlags(RYZOMACTIONFLAGS::InWater);
}

CAIPos CBotPlayer::aipos() const
{
	if (_PlayerPosIsInvalid)
		return CAIPos(wpos().toAIVector(), wpos().h(), 0); // This is last valid position on AI collision map
	else
		return CAIPos(pos());
}

void CBotPlayer::update()
{
	updatePos();
}

CAIInstance* CBotPlayer::getAIInstance() const
{
	return getOwner()->getAIInstance();
}

bool CBotPlayer::spawn()
{
	setSpawn(this);
	return true;
}

void CBotPlayer::despawnBot()
{
	setSpawn(NULL);
}

bool CBotPlayer::isUnReachable() const
{
	// _PlayerPosIsInvalid does not reflect the fact that the player is unreachable
	// _PlayerPosIsInvalid is true when player is in delta between PACS and WorldMap
	// collisions, and is reachable in those cases if the bot is near
	if (useOldUnreachable)
	{
		return	_PlayerPosIsInvalid;
	}
	else
	{
		return false;
	}
}

bool CBotPlayer::setPos(CAIPos const& pos)
{
#ifdef NL_DEBUG
	nlassert(1==0);
#endif
	return	true;
}

float CBotPlayer::walkSpeed() const
{
	nlerror("Non-virtual overriden function walkSpeed in CBotPlayer");
	return 3.f/10.f;
}

float CBotPlayer::runSpeed() const
{
	nlerror("Non-virtual overriden function runSpeed in CBotPlayer");
	return 6.f/10.f;
}

bool CBotPlayer::isAggressive() const
{
	MBEHAV::TMode const mode = getMode();
	return mode==MBEHAV::COMBAT_FLOAT || mode==MBEHAV::COMBAT;
}

void CBotPlayer::addAggroer(TDataSetRow const& row)
{
#if !FINAL_VERSION
	for	(sint32 i=(sint32)_AggroerList.size()-1;i>=0;i--)
		nlassert(_AggroerList[i]!=row);
#endif
	_AggroerList.push_back(row);
}

void CBotPlayer::removeAggroer(TDataSetRow const& row)
{
	for	(sint32 i=(sint32)_AggroerList.size()-1;i>=0;i--)
	{
		if (_AggroerList[i]==row)
		{
			_AggroerList.at(i)=_AggroerList.back();
			_AggroerList.pop_back();
			break;
		}
	}
}

void CBotPlayer::updateInsideTriggerZones(const std::set<uint32>& newInsideTriggerZone, std::vector<uint32>& onEnterZone, std::vector<uint32>& onLeaveZone)
{
	std::set<uint32>::const_iterator firstInside(_InsideTriggerZones.begin()), lastInside( _InsideTriggerZones.end());
	std::set<uint32>::const_iterator firstNewInside(newInsideTriggerZone.begin()), lastNewInside( newInsideTriggerZone.end());
	
	std::set_difference(firstInside, lastInside, firstNewInside, lastNewInside, std::back_inserter(onLeaveZone));
	std::set_difference(firstNewInside, lastNewInside, firstInside, lastInside, std::back_inserter(onEnterZone));
	
	_InsideTriggerZones = newInsideTriggerZone;
}

//////////////////////////////////////////////////////////////////////////////
// CManagerPlayer                                                           //
//////////////////////////////////////////////////////////////////////////////

CManagerPlayer::~CManagerPlayer()
{
	TPlayerMap::iterator it = _spawnedPlayers.begin();
	while (it != _spawnedPlayers.end())
	{
		CBotPlayer* player = (*it).second;

		// a CBotPlayer object removes itself from _spawnedPlayers at destruction
		// increment the iterator before it becomes invalid
		++it;
		player->despawnBot();
		removeChildByIndex(player->getChildIndex());
		// now the player object is destroyed
	}
}

void CManagerPlayer::update()
{
	FOREACH(it, TPlayerMap, _spawnedPlayers)
	{
		it->second->CBotPlayer::update();
	}
}

void CManagerPlayer::addSpawnedPlayer(TDataSetRow const& dataSetRow, NLMISC::CEntityId const& id)
{
	CBotPlayer*	player = new CBotPlayer(this,dataSetRow,id,1); // :TODO: default player level calculation (skill & hp ?).
	addChild(player);
	player->spawn();
	
	player->linkToWorldMap(player,	player->pos(), getOwner()->playerMatrix());
	player->updatePos();
	
	// update team id and composition
	CMirrorPropValueRO<TYPE_TEAM_ID> value( *CMirrors::DataSet, dataSetRow, DSPropertyTEAM_ID );
	player->setCurrentTeamId(value());
	if (value() != CTEAM::InvalidTeamId)
	{
		_teams[value()].insert(dataSetRow);
	}
}

void CManagerPlayer::removeDespawnedPlayer(TDataSetRow const& dataSetRow)
{
	//	Remove player from Manager.
	TPlayerMap::iterator it = _spawnedPlayers.find(dataSetRow);
	if (it==_spawnedPlayers.end())
	{
		// need to log some warning
		nlwarning("Player Despawn Error");
	#ifdef NL_DEBUG
		nlerror("Player Despawn Error");
	#endif
		return;
	}
	else
	{
		CBotPlayer* const player = (*it).second;
		
		// update team composition
		if (player->getCurrentTeamId() != CTEAM::InvalidTeamId)
		{
			CHashMap<int, std::set<TDataSetRow> >::iterator it(_teams.find(player->getCurrentTeamId()));
			if (it != _teams.end())
			{
				it->second.erase(dataSetRow);
				if (it->second.empty())
					_teams.erase(it);
			}
		}
		player->despawnBot();
		removeChildByIndex(player->getChildIndex());
	}
}

void CManagerPlayer::updatePlayerTeam(TDataSetRow const& dataSetRow)
{
	TPlayerMap::iterator it(_spawnedPlayers.find(dataSetRow));
	if (it!=_spawnedPlayers.end())
	{
		uint16 const oldTeam = it->second->getCurrentTeamId();
		if (oldTeam!=CTEAM::InvalidTeamId)
		{
			CHashMap<int, std::set<TDataSetRow> >::iterator it(_teams.find(oldTeam));
			if (it != _teams.end())
			{
				it->second.erase(dataSetRow);
				if (it->second.empty())
					_teams.erase(it);
			}
		}
		// update team id and composition
		CMirrorPropValueRO<TYPE_TEAM_ID> value(*CMirrors::DataSet, dataSetRow, DSPropertyTEAM_ID);
		it->second->setCurrentTeamId(value());
		if (value() != CTEAM::InvalidTeamId)
		{
			_teams[value()].insert(dataSetRow);
		}
	}
	else
	{
		nlwarning("CManagerPlayer::updatePlayerTeam : dataSetRow %u, can't find spawned player !", dataSetRow.getIndex());
	}
}

// This static data is just to have a ref return type anytime, bad habit.
std::set<TDataSetRow> CManagerPlayer::emptySet;

std::set<TDataSetRow> const& CManagerPlayer::getPlayerTeam(TDataSetRow const& playerRow)
{
	TPlayerMap::iterator it(_spawnedPlayers.find(playerRow));
	
	if (it != _spawnedPlayers.end())
	{
		uint16 const teamId = it->second->getCurrentTeamId();
		return getPlayerTeam(teamId);
	}
	else
	{
		nlwarning("CManagerPlayer::getPlayerTeam can't find player from dataset %u", playerRow.getIndex());
		return emptySet;
	}
}

std::set<TDataSetRow> const& CManagerPlayer::getPlayerTeam(uint16 teamId)
{
	if (teamId == CTEAM::InvalidTeamId)
	{
		return emptySet;
	}
	else
	{
		TTeamMap::iterator itTeam = _teams.find(teamId);
		if (itTeam != _teams.end())
		{
			return itTeam->second;
		}
		else
		{
			nlwarning("CManagerPlayer::getPlayerTeam : no player in team %u", teamId);
			return emptySet;
		}
	}
}

void CManagerPlayer::getTeamIds(std::vector<uint16>& teamIds)
{
	FOREACH(itTeam, TTeamMap, _teams)
	{
		teamIds.push_back(itTeam->first);
	}
}

void CBotPlayer::forgotAggroForAggroer()
{

	for	(sint32 i=(sint32)_AggroerList.size()-1; i>=0; --i)
	{
		CAIEntityPhysical* const phys = CAIS::instance().getEntityPhysical(_AggroerList[i]);
		if (!phys)
			continue;
		CBotAggroOwner* aggroOwner = NULL;
		
		switch(phys->getRyzomType())
		{
		case RYZOMID::creature:
			aggroOwner = NLMISC::safe_cast<CBotAggroOwner*>(NLMISC::safe_cast<CSpawnBotFauna*>(phys));
			break;
		case RYZOMID::npc:
			aggroOwner = NLMISC::safe_cast<CBotAggroOwner*>(NLMISC::safe_cast<CSpawnBotNpc*>(phys));
			break;
		}
		if (!aggroOwner)
			continue;
		aggroOwner->forgetAggroFor(dataSetRow());
	}
}

bool CBotPlayer::useOldUnreachable = false;

NLMISC_COMMAND(playerUseOldUnreachable, "Old unreachable state computing is used","")
{
	if(args.size()>1) return false;
	if(args.size()==1) StrToBool(CBotPlayer::useOldUnreachable, args[0]);
	log.displayNL("playerUseOldUnreachable is %s", CBotPlayer::useOldUnreachable?"true":"false");
	return true;
}

sint32 CBotPlayer::getFame(std::string const& faction, bool modulated, bool returnUnknownValue) const
{
	sint32 fame = CAIEntityPhysical::getFame(faction, modulated, true);
	if (fame==NO_FAME)
	{
		fame = CStaticFames::getInstance().getStaticFame(_Sheet->Race(), faction);
	}
	if (!returnUnknownValue && fame==NO_FAME)
		fame = 0;
	return fame;
}

sint32 CBotPlayer::getFameIndexed(uint32 factionIndex, bool modulated, bool returnUnknownValue) const
{
	sint32 fame = CAIEntityPhysical::getFameIndexed(factionIndex, modulated, true);
	if (fame==NO_FAME)
	{
		uint32 playerFaction = CStaticFames::getInstance().getFactionIndex(_Sheet->Race());
		fame = CStaticFames::getInstance().getStaticFameIndexed(playerFaction, factionIndex);
	}
	if (!returnUnknownValue && fame==NO_FAME)
		fame = 0;
	return fame;
}