// 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/>.



#ifndef RY_DEPOSIT_H
#define RY_DEPOSIT_H

#include "nel/ligo/primitive.h"
#include "egs_sheets/egs_static_deposit.h"
#include "game_share/time_weather_season/time_and_season.h"
#include "game_share/ecosystem.h"
#include "game_share/rm_family.h"
#include "harvest_info.h"
#include "mission_manager/ai_alias_translator.h"
#include "egs_variables.h"
#include "nel/misc/random.h"
#include "nel/misc/variable.h"


class CDeposit;

const uint16 MaxNbActiveSources = std::numeric_limits<uint16>::max();

/**
 * A recent forage site prevents from extracting too much material from the same place in a short time.
 * When an extraction is succesful, a timer is launched. If no more extraction is done then, the site
 * is destroyed after the time is elapsed. If an extraction fails (no more stock available), the site
 * will be blocked for extraction (isDepleted() will be true) during the specified time, then freed.
 * Note: the timer resolution is abstract. The actual time in ticks will depend on the rate of update.
 */
class CRecentForageSite
{
public:

	/// Create forage site. Precondition: dep not NULL.
	CRecentForageSite( CDeposit *dep, const NLMISC::CVector& pos ) : _Deposit(dep), _Pos(pos), _TimeToLive(ForageSiteNbUpdatesToLive.get()), _LowScopeStock(ForageSiteStock.get()), _NbActiveSources(0) {}

	/// Add a source
	bool					addActiveSource() { if ( _NbActiveSources == MaxNbActiveSources ) return false; ++_NbActiveSources; return true; }

	/// Remove a source
	void					removeActiveSource() { nlassert(_NbActiveSources!=0); --_NbActiveSources; } // TEMP: assert

	/// Return the quantity available in the deposit (or FLT_MAX if there is no quantity constraint)
	float					getQuantityInDeposit();

	/**
	 * Consume 1 unit of forage site stock by a source in the (independant on the quantity extracted).
	 * Reset life time of forage site if successful.
	 * Additionally, consume n units of deposit stock (dependant on the quantity extracted).
	 * Return the actual quantity that is extracted (can be less that requested if the deposit is (nearly or fully) empty.
	 */
	float					consume( float n );

	/// Consume all stock at once
	void					depleteAll() { _LowScopeStock = 0; _TimeToLive = ForageSiteNbUpdatesToLive.get(); }

	/** Update forage site. Return false if the forage site lifetime is ended and the object must be destroyed (which won't occur while there are active sources)
	 * This method does not need to be called every tick, but at the rate of CDeposit::lowFreqUpdate().
	 */
	bool					lowFreqUpdate() { if ( _TimeToLive != 0 ) { --_TimeToLive; return true; } else return hasActiveSources(); }

	/// Return deposit (never NULL).
	const CDeposit			*deposit() const { return _Deposit; }

	/// Return center position
	const NLMISC::CVector&	pos() const { return _Pos; }

	/// Test if site is depleted
	bool					isDepleted() const { return _LowScopeStock == 0; }

	/// Test if site contains a position
	bool					contains( const NLMISC::CVector& pos ) const;

	/// Display debug or stat info
	void					display( NLMISC::CLog& log ) const;

	/// True if the owned deposit allo depletion risk
	bool					allowDepletionRisk() const;

protected:

	/// Test if site has sources
	bool					hasActiveSources() const { return _NbActiveSources!=0; }

private:

	/// Pointer to deposit (deposits don't move in memory). Never NULL.
	CDeposit			*_Deposit;

	/// Center of site area
	NLMISC::CVector		_Pos;

	///
	uint16				_TimeToLive;

	///
	uint16				_LowScopeStock;

	///
	uint16				_NbActiveSources;
};

typedef std::list<CRecentForageSite> CRecentForageSites;


/**
 * Type of ecosystem or terrain.
 * CEcotype ojects are loaded from primitives, are used to build CDeposit objects, then erased.
 */
class CEcotypeZone : public NLLIGO::CPrimZone
{
public:
	
	/// Init
	bool			build( const NLLIGO::CPrimZone* zone );

	/// Return ecotype
	TEcotype		ecotype() const { return _Ecotype; }

private:

	///
	TEcotype		_Ecotype;
};

typedef std::vector< CEcotypeZone* > CEcotypeZones;


/**
 * Properties of auto-spawn sources of a deposit
 */
struct CAutoSpawnProperties
{
	NL_INSTANCE_COUNTER_DECL(CAutoSpawnProperties);
public:
	/// In game cycles, but depends of the update frequency of the deposits
	uint32			SpawnPeriodGc;

	/// Time before disappearance when no extraction has started (game cycles)
	uint32			LifeTimeGc;

	/// Time remaining since the beginning of the first extraction
	uint32			ExtractionTimeGc;

	/// Minimium Number of Auto-Spawned Sources that must always exist
	uint32			MinimumSpawnedSources;
};


/**
 * Quantity constraints
 */
struct CQuantityConstraints
{
	NL_INSTANCE_COUNTER_DECL(CQuantityConstraints);
public:
	/// Current quantity (shared by all materials in the deposit)
	float			CurrentQuantity;

	/// Day of the next respawn (valid if CurrentQuantity is 0)
	uint32			NextRespawnDay;

	/// Initial quantity
	uint16			InitialQuantity;

	/// Time before the initial quantity becomes available backs, in Ryzom Days (note: 30 days for a whole season)
	uint16			RespawnTimeRyzomDays;

	/// Return the current quantity. If 0 and the respawn time is elapsed, unlock. 
	float			getCurrentQuantity();

	/// Consume. If the current quantity falls to 0, lock. Return the actual consumed quantity.
	float			consumeQuantity( float consumed );
};


namespace NLMISC
{
	class IVariable;
	class CWordsDictionary;
}

/**
 * \author Nicolas Brigand, Alain Saffray, Olivier Cado
 * \author Nevrax France
 * \date 2003
 */
class CDeposit : public NLLIGO::CPrimZone, public NLMISC::CRefCount
{
public:

	/// Constructor
	CDeposit() : _AutoSpawnSourcePt(NULL), _QuantityConstraintsPt(NULL), _Ecotype(ECOSYSTEM::common_ecosystem), _FilterPhase(0), _KamiAnger(0.0f), _MinQuality(-1), _MaxQuality(-1), _SourceFXIndex(0), _CanProspect(false), _Enabled(false), _CurrentNbAutoSpawnedSources(0), _AllowDepletionRisk(true) {}

	/// Destructor
	~CDeposit();

	/// Add an ecotype information
	static void		addEcotype( CEcotypeZone *ecotypeZone ) { _EcotypeZones.push_back( ecotypeZone ); }

	/// Init deposit
	bool			build( const NLLIGO::CPrimZone* zone );

	/// Clear all ecotype information, after having built the deposits
	static void		clearEcotypes();

	// Update deposit (especially recent forage sites).
	void			lowFreqUpdate();	

	// Update deposit that need to auto spawn because number of harvest sources is too low
	void			autoSpawnUpdate();	
	
	// fill CHarvestInfos with deposit founded
	///void harvestInfo( const NLMISC::CEntityId& charId, HARVEST_INFOS::CHarvestInfos& infos );
	
	// character take MP, kami eat this fool character ?
	//void characterTakeRM( const NLMISC::CEntityId&  charId, uint32 depositIndexContent, uint16 quantity );
	
	// Display deposit content
	void			displayContent( NLMISC::CLog * log = NLMISC::InfoLog, bool extendedInfo=false, NLMISC::CWordsDictionary *itemDictionary=NULL );

	const std::string& name() const { return _Name; }

	/// Return the number of MPS in the deposit
	uint			getContentSize() const { return (uint)_RawMaterials.size(); }

	/// Return the MPS
	const			std::vector<CStaticDepositRawMaterial>& getContents() const { return _RawMaterials; }

	/// Return the terrain type
	TEcotype		ecotype() const { return _Ecotype; }

	/// Return the MinQuality
	sint16			minQuality() const { return _MinQuality; }

	/// Return the MaxQuality or -1 if it has to be taken from the raw material information
	sint16			maxQuality() const { return _MaxQuality; }

	/// Return the index of the visual shape/FX of the sources from this deposit
	uint16			sourceFXIndex() const { return _SourceFXIndex; }

	/// Return true if the deposit is currently enabled
	bool			enabled() const { return _Enabled; }
	
	/// Enable(true)/Disable(false) the deposit 
	void			enable(bool bEnable) { _Enabled = bEnable; }
	
	/// Return true if the deposit can be prospected
	bool			canProspect() const { return _CanProspect; }

	/// Return true if the submitted terrain matches the deposit
	bool			matchEcotype( TEcotype t ) const
					{ return t==_Ecotype; }

	/// Return true if the submitted season matches the deposit
	bool			matchSeason( CRyzomTime::ESeason s ) const
					{ return _SeasonFilter.empty() || (std::find( _SeasonFilter.begin(), _SeasonFilter.end(), s ) != _SeasonFilter.end()); }

	/// Return true if the submitted weather matches the deposit
	bool			matchWeather( CRyzomTime::EWeather w ) const
					{ return _WeatherFilter.empty() || (std::find( _WeatherFilter.begin(), _WeatherFilter.end(), w ) != _WeatherFilter.end()); }

	/// Return true if the submitted time of day matches the deposit
	bool			matchTimeOfDay( CRyzomTime::ETimeOfDay t ) const
					{ return _TimeOfDayFilter.empty() || (std::find( _TimeOfDayFilter.begin(), _TimeOfDayFilter.end(), t ) != _TimeOfDayFilter.end()); }

	/// Return true if the deposit contains at least one RM of the specified family
	bool			hasFamily( RM_FAMILY::TRMFamily family ) const;

	/// Return true if the deposit contains at least one RM of the specified group
	bool			hasGroup( RM_GROUP::TRMGroup group ) const;

	/// Return true if the deposit contains at least one RM than can craft the specified item part
	bool			hasRMForItemPart( uint itemPartIndex ) const;

	/// Return true if the deposit contains at least one RM with energy lower_eq than the specified value
	bool			hasLowerStatEnergy( uint8 maxStatEnergy ) const;

	/// Return true if the deposit contains at least one RM with energy equalling the specifing value
	bool			hasExactStatEnergy( uint8 statEnergy ) const;

	/// Return the kami anger level (or -1 if disabled)
	float			kamiAnger() const { return _KamiAnger; }

	/// Set the kami anger level
	void			setKamiAnger( float newKamiAnger ) { _KamiAnger = newKamiAnger; }

	/// Increment the kami anger level. React if a threshold is reached. Return the kami anger level (see kamiAnger())
	float			incKamiAnger( float delta, const std::vector<TDataSetRow>& foragers );

	/// Decrement the kami anger level (result clamped to 0)
	float			decKamiAnger( float delta ) { if ( _KamiAnger != -1.0f ) { _KamiAnger -= delta; if ( _KamiAnger < 0 ) _KamiAnger = 0; } return _KamiAnger; }

	/// True if the deposit allow depletion risk for recent forage site
	bool			allowDepletionRisk() const {return _AllowDepletionRisk;}

	/// Return the auto spawn properties (if auto-spawn is on, otherwise return NULL)
	const CAutoSpawnProperties *getAutoSpawnProperties() const { return _AutoSpawnSourcePt; }

	/// Return the quantuty constraints (if any, otherwise return NULL)
	const CQuantityConstraints *getQuantityConstraints() const { return _QuantityConstraintsPt; }

	/// Return the quantity available in the deposit (or FLT_MAX if there is no quantity constraint)
	float			getMaxQuantity() { return _QuantityConstraintsPt ? _QuantityConstraintsPt->getCurrentQuantity() : FLT_MAX; }

	/// Consume. Return the actual consumed quantity (may be lower if there is no more to get)
	float			consumeQuantity( float requested ) { if ( _QuantityConstraintsPt ) return _QuantityConstraintsPt->consumeQuantity( requested ); else return requested; }

	/**
	 * Get a random RM from the neighbourhood of the specified position.
	 * OptFastFloorBegin()/OptFastFloorEnd() must enclose one or more calls to this method.
	 */
	const CStaticDepositRawMaterial	*getRandomRMAtPos( const NLMISC::CVector& pos, bool testIfSiteDepleted, bool& isDepleted );

	/**
	 * Get the RM at the specified position (no random for map generation).
	 * OptFastFloorBegin()/OptFastFloorEnd() must enclose one or more calls to this method.
	 * \param testIfSiteDepleted Set it to false for map generation.
	 */
	const CStaticDepositRawMaterial *getRMAtPos( const NLMISC::CVector& pos, bool testIfSiteDepleted, bool& isDepleted );
	
	/// Return always a forage site
	CRecentForageSite				*findOrCreateForageSite( const NLMISC::CVector& pos );

	/// Display forage sites info
	void			displayRecentForageSites( NLMISC::CLog& log ) const;

	/// Empty all forage sites
	void			depleteAllRecentForageSites();

	// For auto-spawn source minimum number. Internaly used by CHarvestSource only
	void			decreaseAutoSpawnedSources();
	void			increaseAutoSpawnedSources();
	
protected:

	/// Select the raw materials, using the specified filters and _Ecotype
	void			selectRMsByFilters( std::vector<std::string>& exactRMCodesS, const std::vector<std::string>& rmFamilyFilterS, const std::vector<std::string>& itemPartsFilterS, const std::vector<std::string>& craftCivS, uint minEnergy, uint maxEnergy );

	std::string		getSeasonStr() const;
	std::string		getTimeOfDayStr() const;
	std::string		getWeatherStr() const;

	/**
	 * Get the ecotype zone under the position.
	 * This information is valid only at init time. After the deposits are built, this information
	 * can be found only in deposits.
	 * If not found, a NULL pointer is returned.
	 */
	static CEcotypeZone *getEcotypeZone( const NLMISC::CVector& pos );

	/// auto spawn a source in the deposit, in the given bbox
	void		autoSpawnSource(const NLMISC::CVector &cornerMin, const NLMISC::CVector &cornerMax);

private:

	/// The ecotype zones (only valid at init, cleared after deposit built)
	static CEcotypeZones						_EcotypeZones;


	/// List of raw materials (const)
	std::vector< CStaticDepositRawMaterial >	_RawMaterials;

	/// Type of terrain (const)
	TEcotype									_Ecotype;

	/// Season filter (const)
	std::vector<CRyzomTime::ESeason>			_SeasonFilter;

	/// Weather filter (const)
	std::vector<CRyzomTime::EWeather>			_WeatherFilter;

	/// Time of day filter (const)
	std::vector<CRyzomTime::ETimeOfDay>			_TimeOfDayFilter;

	/// Phase for noise value generator (deduced from season, weather, time... filters)
	uint										_FilterPhase;

	/// Recent forage site list (per deposit, which means forage won't affect another overlapped deposit)
	CRecentForageSites							_RecentForageSites;

	/// Deposit name
	std::string									_Name;

	/// Not null if the deposit can spawn sources without foraging action
	CAutoSpawnProperties						*_AutoSpawnSourcePt;

	/// From 0 to KAMI_ANGER_THRESHOLD 1 & 2, or -1 for N/A; will be persistant some day...
	float										_KamiAnger;

	/// Min quality or -1 if there is no inferior limit
	sint16										_MinQuality;

	/// Max quality or -1 if it has to be taken from the raw material information
	sint16										_MaxQuality;

	/// Not null if the deposit has main quantity constraints
	CQuantityConstraints						*_QuantityConstraintsPt;

	/// Index of the visual shape/FX of the sources from this deposit
	uint16										_SourceFXIndex;

	/// Can a player prospect on this deposit
	bool										_CanProspect;

	/// Is this deposit enabled or disabled (for deposits that are not permanent)
	bool										_Enabled;

	/// Is this deposit allows depletion risk. True by default
	bool										_AllowDepletionRisk;

	// deposit id
	//uint										_Id;

	/// Current Number of AutoSpawned Sources in this deposit
	uint32										_CurrentNbAutoSpawnedSources;
};


/**
 * Predicate to compare two pointed deposits using their kami anger level.
 * If a value is -1, it is not considered as lower.
 */
struct CHasLowerKamiAngerPred : std::binary_function< CDeposit*, CDeposit*, bool >
{
	bool operator() ( CDeposit *d1, CDeposit *d2 )
	{
		return (d1->kamiAnger() >= 0) && (d1->kamiAnger() < d2->kamiAnger());
	}
};


/*
 * Return the quantity available in the deposit (or FLT_MAX if there is no quantity constraint)
 */
inline float	CRecentForageSite::getQuantityInDeposit()
{
	return _Deposit->getMaxQuantity();
}


/*
 * Consume 1 unit of forage site stock by a source in the (independant on the quantity extracted).
 * Reset life time of forage site if successful.
 * Additionally, consume n units of deposit stock (dependant on the quantity extracted).
 * Return the actual quantity that is extracted (can be less that requested if the deposit is (nearly or fully) empty.
 */
inline float	CRecentForageSite::consume( float n )
{
	if ( _LowScopeStock != 0 )
	{
		--_LowScopeStock;
		_TimeToLive = ForageSiteNbUpdatesToLive.get();
	}
	return _Deposit->consumeQuantity( n );
}


/*
 * Return true if the deposit allows depletion risk
 */
inline bool CRecentForageSite::allowDepletionRisk() const
{
	return _Deposit && _Deposit->allowDepletionRisk();
}



#endif // RY_DEPOSIT_H

/* End of deposit.h */