// 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 CDB_BRANCH_H
#define CDB_BRANCH_H

#include "cdb.h"
#include "game_share/ryzom_database_banks.h"

/**
 * Database Node which contains a set of properties
 * \author Stephane Coutelas
 * \author Nevrax France
 * \date 2002
 */
class CCDBNodeBranch : public ICDBNode
{
public:
	/// Triggered when the branch observers are updated
	class IBranchObserverCallFlushObserver : public NLMISC::CRefCount{
	public:
		virtual ~IBranchObserverCallFlushObserver(){}
		virtual void onObserverCallFlush() = 0;
	};

	// default constructor
	CCDBNodeBranch(const std::string &name) : ICDBNode(name)
	{
		_Parent = NULL;
		_IdBits = 0;
		_Sorted = false;
	}

	/**
	 *	Build the structure of the database from a file
	 * \param f is the stream
	 */
	void init( xmlNodePtr node, class NLMISC::IProgressCallback &progressCallBack, bool mapBanks=false );

	/**
	 * Add a new sub node
	 * \param node is the new subnode
	 * \param nodeName is the name of the node
	 */
	void attachChild( ICDBNode * node, std::string nodeName );

	/**
	 * Get a node . Create it if it does not exist yet
	 * \param id : the CTextId identifying the node
	 */
	ICDBNode * getNode (const CTextId& id, bool bCreate=true);

	/**
	 * Get a node. Return NULL if out of bounds (no warning)
	 * \param idx is the node index
	 */
	ICDBNode * getNode( uint16 idx );

	/**
	 * Get a node index
	 * \param node is a pointer to the node
	 */
	virtual bool getNodeIndex( ICDBNode* node , uint& index)
	{
		index=0;
		for ( std::vector<ICDBNode*>::const_iterator it = _Nodes.begin(); it != _Nodes.end(); it++)
		{
			if (*it == node)
				return true;
			index++;
		}
		return false;
	}

	// return the child with the given node id, creating it if requested
	CCDBNodeLeaf *getLeaf( const char *id, bool bCreate );
	CCDBNodeLeaf *getLeaf( const std::string &id, bool bCreate ) { return getLeaf(id.c_str(), bCreate); }

	/**
	 * Save a backup of the database
	 * \param id is the text id of the property/grp
	 * \param f is the stream
	 */
	void write( CTextId& id, FILE * f);

	/// Update the database from the delta, but map the first level with the bank mapping (see _CDBBankToUnifiedIndexMapping)
	void readAndMapDelta( NLMISC::TGameCycle gc, NLMISC::CBitMemStream& s, TCDBBank bank );

	/// Update the database from a stream coming from the FE
	void readDelta( NLMISC::TGameCycle gc, NLMISC::CBitMemStream & f );

	/**
	 * Return the value of a property (the update flag is set to false)
	 * \param id is the text id of the property/grp
	 * \param name is the name of the property
	 * \return the value of the property
	 */
	sint64 getProp( CTextId& id );

	/**
	 * Set the value of a property (the update flag is set to true)
	 * \param id is the text id of the property/grp
	 * \param name is the name of the property
	 * \param value is the value of the property
	 * \return bool : 'true' if property found.
	 */
	bool setProp( CTextId& id, sint64 value );

	/// Clear the node and his children
	void clear();

	/// Reset the data corresponding to the bank (works only on top level node)
	void resetBank( NLMISC::TGameCycle gc, TCDBBank bank)
	{
		//nlassert( getParent() == NULL );
		for ( uint i=0; i!=_Nodes.size(); ++i )
		{
			if ( _UnifiedIndexToBank[i] == bank )
				_Nodes[i]->resetData(gc);
		}
	}

	/// Reset all leaf data from this point
	void resetData(NLMISC::TGameCycle gc, bool forceReset=false)
	{
		for ( uint i=0; i!=_Nodes.size(); ++i )
		{
			_Nodes[i]->resetData(gc, forceReset);
		}
	}

	/**
	 *	Destructor
	 */
	virtual ~CCDBNodeBranch() { clear(); }

	// the parent node for a branch (NULL by default)
	virtual void setParent(CCDBNodeBranch *parent) { _Parent=parent; }

	virtual CCDBNodeBranch*  getParent()
	{
		return _Parent;
	}

	//get the number of nodes
	uint16 getNbNodes()
	{
		return (uint16)_Nodes.size();
	}

	/// Count the leaves
	virtual uint	countLeaves() const;

	/// Find the leaf which count is specified (if found, the returned value is non-null and count is 0)
	virtual CCDBNodeLeaf	*findLeafAtCount( uint& count );

	virtual void display (const std::string &prefix);

	void removeNode (const CTextId& id);

	/**
	* add an observer to a property
	* \param observer : pointer to an observer
	* \param id text id identifying the property
	* \return false if the node doen t exist
	*/
	virtual bool addObserver(IPropertyObserver* observer, CTextId& id);

	/** remove an obsever
	 * \param observer : pointer to an observer
	 * \return false if the node or observer doesn t exist
	 */
	virtual bool removeObserver(IPropertyObserver* observer, CTextId& id);

	// Add an observer to this branch. It will be notified of any change in the sub-leaves

	/**
	 * Add observer to all sub-leaves, except if a positive filter is set:
	 * If positiveLeafNameFilter is non-empty, only changes to leaves having names found in it
	 * will be notified (this is equivalent to creating a sub-branch containing only the specified leaves
	 * and setting a branch observer on it, except you don't need to change your database paths
	 * and update large amounts of code!).
	 */
	void addBranchObserver(IPropertyObserver* observer, const std::vector<std::string>& positiveLeafNameFilter=std::vector<std::string>());

	/**
	 * Easy version of addBranchObserver() (see above).
	 * Examples of dbPathFromThisNode:
	 * "" -> this node
	 * "FOO:BAR" ->  sub-branch "BAR" of "FOO" which is a sub-branch of this node
	 */
	void addBranchObserver(const char *dbPathFromThisNode, ICDBNode::IPropertyObserver& observer, const char **positiveLeafNameFilter=NULL, uint positiveLeafNameFilterSize=0);

	// Remove observer from all sub-leaves
	bool removeBranchObserver(IPropertyObserver* observer);

	/// Easy version of removeBranchObserver() (see above and see easy version of addBranchObserver())
	void removeBranchObserver(const char *dbPathFromThisNode, ICDBNode::IPropertyObserver& observer);

	virtual bool isLeaf() const { return false; }

	/** Update all observers of branchs that have been modified
	  */
	static void flushObserversCalls();

private:
	static void triggerFlushObservers();

public:
	static void addFlushObserver( IBranchObserverCallFlushObserver *observer );
	static void removeFlushObserver( IBranchObserverCallFlushObserver *observer );

	// mark this branch and parent branch as 'modified'. This is usually called by sub-leaves
	void linkInModifiedNodeList(NLMISC::TStringId modifiedLeafName);

	/// Find a subnode at this level
	ICDBNode * find (const std::string &nodeName);

	/// Main init
	static void resetNodeBankMapping() { _UnifiedIndexToBank.clear(); }

	// reset all static mappings
	static void reset();

	/// Internal use only
	static void mapNodeByBank( ICDBNode *node, const std::string& bankStr, bool clientOnly, uint nodeIndex );

protected:


		/** Struct identifying an observer of a db branch
	  * This struct can be linked in a list so that we can update observers only once per pass.
	  * An observer that watch a whole branch can be updated once and only once after each element of the branch has been modified
	  */
	class CDBBranchObsInfo
	{
		public:
			NLMISC::CRefPtr<IPropertyObserver> Observer;
			// 2 linked list are required : while the observer is notified, it can triger one other observer, so we must link it in another list
			bool               Touched[2];
			CDBBranchObsInfo   *PrevNotifiedObserver[2]; // NULL means this is the head
			CDBBranchObsInfo   *NextNotifiedObserver[2];
			ICDBNode		   *Owner;

			// If non-empty, only a leaf whose name is found here will notify something
			// This is equivalent to creating a sub-branch containing only the specified leaves
			// and setting a branch observer on it, except you don't need to change your database paths
			// and update large amounts of code and script!
			std::vector<NLMISC::TStringId> PositiveLeafNameFilter;

		public:

			/// Constructor. See above for usage of positiveLeafNameFilter.
			CDBBranchObsInfo(IPropertyObserver *obs = NULL, ICDBNode *owner = NULL, const std::vector<std::string>& positiveLeafNameFilter=std::vector<std::string>())
			{
				Owner = owner;
				Observer = obs;
				Touched[0] = Touched[1] = false;
				PrevNotifiedObserver[0] = PrevNotifiedObserver[1] = NULL;
				NextNotifiedObserver[0] = NextNotifiedObserver[1]  = NULL;
				for (std::vector<std::string>::const_iterator ipf=positiveLeafNameFilter.begin(); ipf!=positiveLeafNameFilter.end(); ++ipf)
				{
					PositiveLeafNameFilter.push_back(ICDBNode::getStringId(*ipf)); // the ids are also mapped at database init, we don't need to unmap them in destructor
				}
			}
			~CDBBranchObsInfo()
			{
				// should have been unlinked
				nlassert(Touched[0] == false);
				nlassert(Touched[1] == false);
				nlassert(PrevNotifiedObserver[0] == NULL);
				nlassert(PrevNotifiedObserver[1] == NULL);
				nlassert(NextNotifiedObserver[0] == NULL);
				nlassert(NextNotifiedObserver[1] == NULL);
			}
			// Unlink from the given list. This also clear the '_Touched' flag
			void unlink(uint list);			
			void link(uint list, NLMISC::TStringId modifiedLeafName);
	};

	typedef std::list<CDBBranchObsInfo> TObsList; // must use a list because pointers on CDBObserverInfo instances must remains valids

protected:


	CCDBNodeBranch			*_Parent;

	/// database subnodes not sorted
	std::vector<ICDBNode*>	_Nodes;

	/// subnodes sorted by name
	std::vector<ICDBNode*>	_NodesByName;

	// number of bits required to stock my children's ids
	uint8					_IdBits : 7;
	bool					_Sorted : 1;

	// observers for this node or branch
	TObsList				_Observers;

	friend class CDBBranchObsInfo;
	// Global list of modified nodes
	static CDBBranchObsInfo *_FirstNotifiedObs[2];
	static CDBBranchObsInfo *_LastNotifiedObs[2];
	static uint			   _CurrNotifiedObsList; // 0 or 1 => tell in which list observers of modified values must be added
	// current & next observers being notified : if such observer if removed during notification, pointer will be valids
	static CDBBranchObsInfo *_CurrNotifiedObs;
	static CDBBranchObsInfo *_NextNotifiedObs;

	/// Mapping from server database index to client database index (first-level nodes)
	static std::vector<uint> _CDBBankToUnifiedIndexMapping [NB_CDB_BANKS];

	// Mapping from client database index to TCDBBank (first-level nodes)
	static std::vector<TCDBBank> _UnifiedIndexToBank;

	/// Last index mapped
	static uint				_CDBLastUnifiedIndex;

	/// Number of bits for first-level branches, by bank
	static uint				_FirstLevelIdBitsByBank [NB_CDB_BANKS];

	/// called by clear
	void			removeAllBranchObserver();
	void			removeBranchInfoIt(TObsList::iterator it);


private:
	static std::vector< IBranchObserverCallFlushObserver* > flushObservers;

};


#endif // CDB_BRANCH_H