#ifndef __KRESOURCEMANAGER__
#define __KRESOURCEMANAGER__

#include <toolkit/ILock.h>
#include <toolkit/khash.h>

#include "K3DTypes.h"

#include "KResourceManagerBase.h"
#include "KSmartPtr.h"
#include <kfile/TRFMetaData.h>

// prodongi
#include <map>

class KStream;
class KFileStream;
class KMemoryStream;


/// NX3 Load Option
struct NX3LoadPack
{
	NX3LoadPack()
	{
		Init(); 
	}

	void Init()
	{
		bLoad_Cube    = false;
		bLoad_Edge    = false;
		bLoad_PolyGon = false; 
		c1 = c2 = c3 = c4 = 0;
	}

	static bool       SetTextureLevel( int nLevel );
	static const int  GetTextureLevel() { return nLoad_Level; }

	static int  nLoad_Level;   ///< Quality Level 0 Base
	bool bLoad_Cube;    ///< Cube
	bool bLoad_Edge;    ///< Edge
	bool bLoad_PolyGon; ///< Collision PolyGon

	DWORD c1,c2,c3,c4;
};


typedef KHash< std::string, hashPr_string_nocase > FILE_HASH;

const unsigned char TEXFLAG_ORIGINAL = 0x80;

class K3DTexture;
class KTextureManager : public KSingletoneResourceManager<KTextureManager>
{
public:
	KTextureManager();
	virtual ~KTextureManager();
	
	enum SearchPolicy {
		ORG_ONLY		= 1 << 0,				///< 파일명을 그대로 검색
		DDS_ONLY		= 1	<< 1,				///< 파일명 확장자를 dds로 바꿔 검색.
		ORG_THEN_DDS	= ORG_ONLY | DDS_ONLY	///< 파일명을 그대로 검색. 실패하면 확장자를 dds 로 바꿔 다시 검색
	};

	void SetTextureSearchPolicy( SearchPolicy policy = ORG_THEN_DDS )					{ m_policy = policy; }
	
	bool		IsExistTexture( const char *texname, const NX3LoadPack * pLoadPack );
	K3DTexture* GetTexture( const char *texname, const NX3LoadPack * pLoadPack, bool bRegMissingRes = true, int nTextureQualityLevel = 0 );
	K3DTexture* GetTexture( const char *texname, const NX3LoadPack * pLoadPack, DWORD c1, DWORD c2 = 0, DWORD c3 = 0, DWORD c4 = 0, int nTextureQualityLevel = 0, short nMode = 0 );
	K3DTexture* GetTexture( K3DTexture *tex, const NX3LoadPack * pLoadPack, DWORD c1, DWORD c2 = 0, DWORD c3 = 0, DWORD c4 = 0, int nTextureQualityLevel = 0, short nMode = 0 );
	K3DTexture* GetTexture(KStream& stream,const char *texname, const NX3LoadPack * pLoadPack, int nTextureQualityLevel = 0);
	K3DTexture* RefreshTexture( const char *texname, const NX3LoadPack * pLoadPack, DWORD c1 = 0, DWORD c2 = 0, DWORD c3 = 0, DWORD c4 = 0 );

	virtual void ReloadRes( bool bRepair = false, unsigned char withFlags = 0, unsigned char withoutFlags = 0 );
	virtual void DiscardAll();
	
	K3DTexture* GetTextureOriginal( const char *texname, const NX3LoadPack * pLoadPack, bool bRegMissingRes = true );
	void RemoveTexture( K3DTexture *tex );

	int GetMipMapBiasLevel();
	void SetMipMapBiasLevel( int nLevel );

	/// 시간에 따른 각종 Event 처리~
	virtual void EventTime( DWORD dwTime );
	virtual void PrintList( const char * pOutFileName );

	void init(void);


protected:

	void makeHashString( char *buf, const char *filename, DWORD c1, DWORD c2, DWORD c3, DWORD c4 );
	void makeFileName( char *buf, const char *hashname );
	void makeColor( const char *hashname, DWORD& c1, DWORD& c2, DWORD& c3, DWORD& c4 );
	K3DTexture* loadTexture( const char *texname, const NX3LoadPack * pLoadPack, bool bRegMissingRes = true, int nTextureQualityLevel = 0 );
	K3DTexture* loadTexture( KStream& stream, const NX3LoadPack * pLoadPack, int nTextureQualityLevel = 0 );
	K3DTexture* loadColorizedTexture( const char *texname, const NX3LoadPack * pLoadPack, DWORD c1, DWORD c2, DWORD c3, DWORD c4, int nTextureQualityLevel = 0, short nMode = 0 );
	KHash<K3DTexture*, hashPr_string_nocase>	m_texByName;
	
	int			m_nTextureQualityLevel;
	SearchPolicy m_policy;
};

struct KNX3MeshTM;
class KSeqObject;
class KNX3Mesh;
class KNX3FX;
class KSequencer;
class KFXSeq;
class KMeshSeqObject;
class KLightSeq;
class KCameraSeq;
class KEventSeq;
class KFXParticleSeq;
class KResFXParticle;
class KBoneSeqObject;

// Request Clip Bound Sphere
/*
// "RESOURCE_ACK = 'KMRA';
class KMsgRES_ACK : public KArg
{
public:
	KMsgRES_ACK() 
	{
		m_pSeq = NULL;
	}
	~KMsgRES_ACK()
	{
		SAFE_DELETE( m_pSeq );
	}
	KSequencer* GetSequencer()
	{
		if ( m_pSeq )
			return m_pSeq->Clone();
		return NULL;
	}

protected:
	int		m_nFlag;
	KSequencer*	m_pSeq;
};
*/
class KNX3Manager : public KSingletoneResourceManager<KNX3Manager>
{
public:
	KNX3Manager();
	virtual ~KNX3Manager();
	enum
	{
		SEQTYPE_MESH	= 1<<0,
		SEQTYPE_CAMERA	= 1<<1,
		SEQTYPE_LIGHT	= 1<<2,
		SEQTYPE_FX		= 1<<3,
		SEQTYPE_SOUND   = 1<<4,
		SEQTYPE_BONE	= 1<<5,
		SEQTYPE_PFX		= 1<<6,
		SEQTYPE_ALL		= 0xfffff,
	};

	/// 시스템 요구 사항
	enum SYSTEM_REQUIREMENTS
	{
		MINIMUM_SYSTEM = 0,	///< 최저 사양
		MAXIMUM_SYSTEM,		///< 최고 사양
		MIXED_SYSTEM,		///< 혼합 ㅡ,.ㅡ
		MINIMUM_SYSTEM_BY_USER_SELECT, ///< 유저 선택에 의한 최저 사양ㅡ.,ㅡ
	};
	
	KSequencer *CreateSequencer( const char *resname, const NX3LoadPack * plodpack, int reqtype = SEQTYPE_ALL );
	void ReleaseRes( const char *resname );

	void		 RequestThreadLoading( const char *resname, const NX3LoadPack * plodpack );
	size_t		 GetThreadLoadingCount() const;

	virtual void EventTime( DWORD dwTime );
	virtual void PrintList( const char * pOutFileName );

	void		 ClearUnreferencedResource();

	virtual void ReloadRes( bool bRepair = false );
	virtual void DiscardAll();
	
	/// cache 예외 처리
	void AddToExceptList( const char * pName );
	void RemoveFromExceptList( const char * pName );
	bool IsInExceptList( const char * pName );
	void ClearExceptList();
	void ExceptListPrint();

	trf::MetaData& GetMetaData() { return m_metaData; }

	static void SetSystemRequirements( SYSTEM_REQUIREMENTS system ) { s_nSysRequirements = system; }
	static SYSTEM_REQUIREMENTS GetSystemRequirements() { return s_nSysRequirements; }
protected:
	//XBossWorker		m_xWorker;
	void addSeqObjectToSeq( KSequencer* & seq, std::vector< KSeqObject* > & vObj );
	KSequencer* getSequencerFromNX3Set( struct NX3SET *nx3set, int reqtype );
	KSequencer* createSequencer( const char *resname, const NX3LoadPack * plodpack, int reqtype = SEQTYPE_ALL );	

	// void loadMesh( std::vector<KSeqObject*> &vecMeshSeq, std::vector<KSeqObject*> &vecFXSeq, std::vector<KSeqObject*> &vecEvSeq, KNX3Mesh *mesh, std::vector<KNX3MeshTM*> &tmList );
	// bool loadNX3( KStream &stream, struct NX3SET *set );

	friend struct NX3Data;
	struct NX3Data *m_pNX3Data;
	trf::MetaData m_metaData;

	static SYSTEM_REQUIREMENTS	s_nSysRequirements;
};


class KResSprite;
class KSpriteSeq;

DECL_SPTR(KResSpriteAnimation)
struct SPRITE_SET
{
	SPRITE_SET();
	~SPRITE_SET();

	int GetResCount();
	int GetSpriteResAniCount( LPCSTR lpszAniName );
	KResSpriteAnimation* GetSpriteResAni( int nIndex);
	KResSpriteAnimation* GetSpriteResAni( LPCSTR lpszAniName);
	KResSprite* GetSpriteRes(LPCSTR lpszAniName, int nIndex);
	void AddResSpriteAni(KResSpriteAnimation * pRes);
	void ModifyResSpriteAni( KResSpriteAnimation* pRes );

	void EraseSpriteResAni( LPCSTR lpszAniName );

	std::string											m_strResName;
	std::vector<KResSpriteAnimationSPtr>				m_vtResSpriteAni;
	KHash<KResSpriteAnimation*, hashPr_string_nocase >	m_resByAniName;
};


/*
struct KSpriteLibrary
{
public:
	KSpriteLibrary( const char *name, const char *filename, const KRect &_rect )
	{
		strName = name;
		strFileName = filename;
		rect = _rect;
	}

	std::string strName;
	std::string strFileName;
	KRect		rect;
};

class KSpriteLibraryManager
{
public:
	KSpriteLibraryManager();
	virtual ~KSpriteLibraryManager();

	void AddLibrary( const char *name, const char *filename );

};
*/

/// @brief 2010.04.29 전체 spr파일 목록과 중복된 리스트를 뽑기 위해서, - prodongi
//#define SPR_LIST_EXTRACTOR

#ifdef SPR_LIST_EXTRACTOR
struct sSprListExtractor
{
	sSprListExtractor() : m_file(NULL) {}
	~sSprListExtractor()	{	m_list.clear();	}
	void initialize();
	void extract(KResSpriteAnimation* res, char const* sprName);
	void closeFile();

	FILE* m_file;
	FILE* m_dupliFile;
	/// @brief 중복된걸 걸러내기 위한 리스트, pair<filename, sprname>
	std::map<std::string, std::string> m_list;
	char m_temp[MAX_PATH];
};
#endif

class KSpriteManager : public KSingletoneResourceManager<KSpriteManager>
{
public:
	KSpriteManager();
	virtual ~KSpriteManager();

	bool LoadSpriteSet( const char *resname );

	SPRITE_SET* GetSpriteSet( const char *resname );
	SPRITE_SET* GetSpriteSet( KStream &Stream, const char *resname );	
	KResSpriteAnimation* GetResSpriteAni(LPCSTR lpszSprName, LPCSTR lpszAniName);
	int GetAnimationFrameCount(LPCSTR lpszSprName, LPCSTR lpszAniName);
	KResSprite*	GetResSprite(LPCSTR lpszSprName, LPCSTR lpszAniName,int nIndex);

	/// .spr 화일이 아닌 실시간 추가 관련
	//void AddIconSprite( const char *resname, const char *file_name, bool bEncrypt, bool bUseColorKey, KColor color );
	void AddIconSprite( const char *resname, const char *file_name, bool bEncrypt, bool bUseColorKey, KColor color, bool bLoad=false ); // 수정.  bintitle. 2010.04.30 

	void ReleaseSpriteSet(LPCSTR lpszSprName);

	virtual void PrintList( const char * pOutFileName );

	virtual void ReloadRes( bool bRepair = false );
	virtual void DiscardAll();

protected:
	bool _LoadSpriteSet( KStream &stream, SPRITE_SET *pSet);
	bool _AddSpriteSet( const char *name, SPRITE_SET *pSet);

	//void _AddSpriteAnimation( const char *file_name, SPRITE_SET *pSet, bool bEncrypt = false, bool bUseColorKey = false, KColor color=KColor(0,0,0) );
	void _AddSpriteAnimation( const char *file_name, SPRITE_SET *pSet, bool bEncrypt = false, bool bUseColorKey = false, KColor color=KColor(0,0,0), bool bLoad=false );

protected:
	KHash<SPRITE_SET*, hashPr_string_nocase >	m_setByName;

#ifdef SPR_LIST_EXTRACTOR
	/// @brief 2010.04.28 ui 목록 뽑기 위한 변수 prodongi
	sSprListExtractor m_sprListExtractor;
#endif
};



#endif