#pragma once

#include "SGameScene.h"
#include "KPrimitiveSprite.h"
#include "KTextPhrase.h"
#include <map>
#include <list>

namespace rp {

	class SGameCutScene : public SGameScene 
	{
	public:

		/// 생성자
		SGameCutScene( 
			  SGameSceneManager& sceneMgr
			, SGameScene* parent = 0
			, const char* sceneName = ""
			, const char* sceneFile = "" 
			, const K3DVector& position = K3DVector( 0.f, 0.f, 0.1f )			
			, const K3DVector2& size = K3DVector2(-1.f, -1.f) );

		/// 소멸자
		virtual ~SGameCutScene();

		/// 씬 등록 콜백
		virtual void onEnter();

		/// 씬 해제 콜백
		virtual void onLeave();

		/// 씬 활성화 콜백
		virtual void onActivate();

		/// 씬 비활성화 콜백
		virtual void onDeactivate();

		/// 씬 틱 콜백
		virtual void onTick();

		/// 씬 렌더 콜백
		virtual void onRender( KViewportObject* viewport );

		struct Primitive
		{
			Primitive( const char* strName ) : mName( strName ) {}
			virtual ~Primitive() {}	/// 2012.04.16 virtual 추가 - prodongi

			virtual void SetPosition( int nX, int nY ) = 0;
			virtual void SetVisibility( float fVis ) = 0;
			virtual void SetScale( float fW, float fH ) = 0;
			virtual void SetSize( float fW, float fH ) = 0;
			virtual void Render( KViewportObject* viewport ) = 0;

			std::string			mName;
		};
		struct Image : public Primitive
		{
			Image( SGameSceneManager& sceneMgr, const char* szName, const char* szFileName );
			virtual ~Image();		/// 2012.04.16 virtual 추가 - prodongi

			virtual void SetPosition( int nX, int nY );
			virtual void SetVisibility( float fVis );
			virtual void SetScale( float fW, float fH );
			virtual void SetSize( float fW, float fH );
			virtual void Render( KViewportObject* viewport );

			std::string mFileName;
			KSpritePrimitive	mPrimitive;
			KResSpriteSPtr		mSprite;
			K3DTextureSPtr		mTexture;
		};
		struct Text : public Primitive
		{
			Text( const char* szName, const char* szText, int nWidth, int nHeight );
			Text( const char* szName, const int nTextID, int nWidth, int nHeight );
			virtual ~Text();		/// 2012.04.16 virtual 추가 - prodongi

			virtual void SetPosition( int nX, int nY );
			virtual void SetVisibility( float fVis );
			virtual void SetScale( float fW, float fH );
			virtual void SetSize( float fW, float fH );
			virtual void Render( KViewportObject* viewport );

			std::string mText;
#ifdef _COUNTRY_ME_
			KTextLayout2* m_pText;
#else
			KTextPhrase* m_pText;
#endif
		};
		typedef std::map < std::string, Primitive* > mapPrimitive;
		typedef mapPrimitive::iterator imapPrimitive;

		struct attr_snapshot;

		struct attribute
		{
			attribute( DWORD _dwStartTime, DWORD _dwEndTime, int _nType )
				: dwStartTime( _dwStartTime ), dwEndTime( _dwEndTime ), nType( _nType )
			{}

			bool IsInTime( DWORD dwTime )
			{
				return (dwTime >= dwStartTime) && ( dwTime < dwEndTime );
			}
			int GetType() { return nType; }
			virtual void Apply( DWORD dwTime, attr_snapshot& attr ) = 0;

			DWORD dwStartTime;
			DWORD dwEndTime;
			int nType;
		};
		struct attr_pos : public attribute
		{
			attr_pos( DWORD _dwStartTime, int _nSX, int _nSY, DWORD _dwEndTime = 0xFFFFFFFF, int _nEX = 0, int _nEY = 0 )
				: attribute( _dwStartTime, _dwEndTime, 0 ), nSX( _nSX ), nSY( _nSY ), nEX( _nEX ), nEY( _nEY )
			{}

			void GetPosAt( DWORD dwTime, int &nX, int &nY );
			virtual void Apply( DWORD dwTime, attr_snapshot& attr );

			int nSX, nSY, nEX, nEY;
		};
		struct attr_scale : public attribute
		{
			attr_scale( DWORD _dwStartTime, float _fSW, float _fSH, DWORD _dwEndTime = 0xFFFFFFFF, float _fEW = 0, float _fEH = 0 )
				: attribute( _dwStartTime, _dwEndTime, 1 ), fSW( _fSW ), fSH( _fSH ), fEW( _fEW ), fEH( _fEH )
			{}

			void GetScaleAt( DWORD dwTime, float& fW, float& fH );
			virtual void Apply( DWORD dwTime, attr_snapshot& attr );

			float fSW, fSH, fEW, fEH;
		};
		struct attr_vis : public attribute
		{
			attr_vis( DWORD _dwStartTime, float _fSV, DWORD _dwEndTime = 0xFFFFFFFF, float _fEV = 0 )
				: attribute( _dwStartTime, _dwEndTime, 2 ), fSVis( _fSV ), fEVis( _fEV )
			{}

			void GetVisibilityAt( DWORD dwTime, float& fVis );
			virtual void Apply( DWORD dwTime, attr_snapshot& attr );

			float fSVis, fEVis;
		};

		typedef std::list < attribute* > listAttr;
		typedef listAttr::iterator ilistAttr;

		struct attr_snapshot
		{
			attr_snapshot() : nX(0), nY(0), fW(1.0f), fH(1.0f), fV(1.0f) {};
			int nX, nY;
			float fW, fH;
			float fV;
		};
		struct animation
		{
			animation( const char* szName );
			~animation();

			std::string mObjName;
			listAttr mAttrs;

			attr_snapshot GetAttrAt( DWORD dwTime );
			bool IsVisibleAt( DWORD dwTime );
			bool IsEnd( DWORD dwTime );
		};
		typedef std::list < animation* > listAnimation;
		typedef listAnimation::iterator ilistAnimation;

	private:
		std::string m_strBGMFileName;
		std::string mSceneFile;
		mapPrimitive mPrimitives;
		listAnimation mAnimations;

		std::list<Image *> mImagelist; ///< 삭제용으로만 쓰인다.

		DWORD mStartTime;
		DWORD mLastTime;

		K3DVector			mPosition;
		K3DVector2			mSize;
	};

}