//////////////////////////////////////////////////////////////////////
//
//  CryEngine Source code
//	
//	File:CrySizerImpl.h
//  Implementation of the ICrySizer interface, which is used to
//  calculate the memory usage by the subsystems and components, to help
//  the artists keep the memory budged low.
//
//	History:
//	December 03, 2002 : Created by Sergiy Migdalskiy <sergiy@crytek.de>
//
//////////////////////////////////////////////////////////////////////

#ifndef _CRY_SYSTEM_CRY_SIZER_CLASS_IMPLEMENTATION_HDR_
#define _CRY_SYSTEM_CRY_SIZER_CLASS_IMPLEMENTATION_HDR_

// prerequisities

//////////////////////////////////////////////////////////////////////////
// implementation of interface ICrySizer
// ICrySizer is passed to all subsystems and has a lot of helper functions that 
// are compiled in the appropriate subsystems. CrySizerImpl is created in CrySystem
// and is passed to all the other subsystems
class CrySizerImpl: public ICrySizer
{
public:
	CrySizerImpl();
	~CrySizerImpl();

	// adds an object identified by the unique pointer (it needs not be
	// the actual object position in the memory, though it would be nice,
	// but it must be unique throughout the system and unchanging for this object)
	// RETURNS: true if the object has actually been added (for the first time)
	//          and calculated
	virtual bool AddObject (const void* pIdentifier, size_t nSizeBytes);

	// finalizes data collection, should be called after all objects have been added
	void end();

	void clear();
protected:
	// these functions must operate on the component name stack
	// they are to be only accessible from within class CrySizerComponentNameHelper
	// which should be used through macro SIZER_COMPONENT_NAME
	virtual void Push (const char* szComponentName);
	virtual void PushSubcomponent (const char* szSubcomponentName);
	virtual void Pop ();
	
	// searches for the name in the name array; adds the name if it's not there and returns the index
	size_t getNameIndex (size_t nParent, const char* szComponentName);

	// returns the index of the current name on the top of the name stack
	size_t getCurrentName()const;
protected:
	friend class CrySizerStatsBuilder;

	// the stack of subsystem names; the indices in the name array are kept, not the names themselves
	typedef std::vector<size_t> NameStack;
	NameStack m_stackNames;

	// the array of names; each name ever pushed on the stack is present here
	struct ComponentName
	{
		ComponentName (){}
		ComponentName (const char* szName, size_t parent = 0):
			strName (szName),
			nParent (parent),
			numObjects(0),
			sizeObjects (0),
			sizeObjectsTotal (0)
			{
			}

		void assign (const char* szName, size_t parent = 0)
		{
			strName = szName;
			nParent = parent;
			numObjects = 0;
			sizeObjects = 0;
			sizeObjectsTotal = 0;
			arrChildren.clear();
		}

		// the component name, not including the parents' names
		string strName;
		// the index of the parent, 0 being the root
		size_t nParent;
		// the number of objects within this component
		size_t numObjects;
		// the size of the objects belonging to this component, in bytes
		size_t sizeObjects;
		// the total size of all objects; gets filled by the end() method of the CrySizerImpl
		size_t sizeObjectsTotal;
		// the children components
		std::vector<size_t> arrChildren;
	};
	typedef std::vector<ComponentName> NameArray;
	NameArray m_arrNames;

	// the set of objects and their sizes: the key is the object address/id,
	// the value is the size of the object and its name (the index of the name actually)
	struct Object
	{
		const void * pId; // unique pointer identifying the object in memory
		size_t nSize;   // the size of the object in bytes
		size_t nName;   // the index of the name in the name array

		Object ()
		{clear();}

		Object (const void* id, size_t size = 0, size_t name = 0):
			pId(id), nSize(size), nName(name) {}

			// the objects are sorted by their Id																 
		bool operator < (const Object& right)const {return (UINT_PTR)pId < (UINT_PTR)right.pId;}
		bool operator < (const void* right)const {return (UINT_PTR)pId < (UINT_PTR)right;}
		//friend bool operator < (const void* left, const Object& right);

		bool operator == (const Object& right) const {return pId == right.pId;}

		void clear()
		{
			pId = NULL;
			nSize = 0;
			nName = 0;
		}
	};
	typedef std::set <Object> ObjectSet;
	// 2^g_nHashPower == the number of subsets comprising the hash
	enum {g_nHashPower = 7};
	// hash size (number of subsets)
	enum {g_nHashSize = 1 << g_nHashPower};
	// hash function for an address; returns value 0..1<<g_nHashSize
	unsigned getHash (const void* pId);

	ObjectSet m_setObjects[g_nHashSize];

	// the last object inserted; this is a small optimization for our template implementaiton
	// that often can add two times the same object
	Object m_LastObject;
};

#endif