#pragma once

#include <Windows.h>
#include "SGameMessage.h"
#include <map>

#include "SGameUIMgr.h"

class SSkillSlotMgr;

//////////////////////////////////////////////////////////////////////////
//SSkillSlot
class SSkillSlot
{
public:

	/// 생성자
	SSkillSlot();

	/// 소멸자
	virtual ~SSkillSlot(); // sonador #2.1.2.4.3

	/// 스킬 정보 설정
	void SetSkill( SMSG_SKILL_LIST::SkillInfo & skill_data );
	void SetSkill( SMSG_SKILL_LIST::SkillInfo & skill_data, AR_TIME totalCoolTime );

	/// 스킬 정보 획득
	const SMSG_SKILL_LIST::SkillInfo GetSkill()	{ return m_SkillData; }
	
	/// 스킬 틱 처리		Cool Time 처리	// sonador #2.1.2.4.3
	virtual void Process( DWORD	dwTime );

	/// 초기화
	void ReInit();

	/// 사용 상태 설정
	void SetUse( BOOL bUse );

	/// 이미 사용중인지 여부 확인
	BOOL IsUse() { return m_bUse; }

	// 
	// 인터페이스에서 필요로 하는 정보
	// 

	/// 스킬 아이디 획득
    const int GetSkillID() const 		{ return m_SkillData.skill_id; }

	/// 스킬 소유자 핸들 획득
	const AR_HANDLE GetTarget() const	{ return m_hTarget; }

	/// 스킬 소유자 핸들 설정
	void SetTarget( AR_HANDLE hTarget ) { m_hTarget = hTarget; }

	/// 사용 Lv 설정
	void SetUseLevel( int nLevel )		{ m_nUseLevel = nLevel; }

	/// 
	//void ResetAddedLevel() { m_nAddedLevel = 0; }
	void SetAddedLevel( int nAddedLevel ) { m_nAddedLevel = nAddedLevel; }

	/// 사용 Lv 획득
	const int GetUseLevel() const		{ return m_nUseLevel; }
	const int GetAddedLevel() const		{ return m_nAddedLevel; }

	void SetCurLevel( int nLevel )		{ m_SkillData.current_skill_level = nLevel; }
	void SetBaseLevel( int nLevel )		{ m_SkillData.base_skill_level = nLevel; }
	const int GetCurLevel() const		{ return m_SkillData.current_skill_level; }
	const int GetBaseLevel() const		{ return m_SkillData.base_skill_level; }
	void SetRemainTime( AR_TIME time )	{ m_SkillData.remain_cool_time = time; }

	const AR_HANDLE GetSkillCard() const	{ return m_hSkillCard; }
	void SetSkillCard( AR_HANDLE hItem )	{ m_hSkillCard = hItem; }
	
	void SetCasting( bool bCasting )	{ m_bCasting = bCasting; }
	void SetFire( bool bFire )			{ m_bFire = bFire; }
	const bool IsCasting() const		{ return m_bCasting; }
	const bool IsFire() const			{ return m_bFire; }

	/// TODO : 스킬 슬롯 손 봐야 한다.
	void SetBeginTime( DWORD dwTime )	{ m_dwBeginTime = dwTime; m_dwStartTime = dwTime; }
	/// 2012.02.28 SetBeginTime 할 때, total cool time과 remain cool time이 고려가 되야 되는데, SetBeginTime는 고려가 안되는 실수를 할 수 있어서 함수를 따로 만듬
	void setBeginTime(DWORD dwTime, AR_TIME totalCoolTime, AR_TIME remainCoolTime);

	const DWORD GetBeginTime()			{ return m_dwBeginTime; }

	const AR_TIME GetRemainTime()		{ return m_SkillData.remain_cool_time; }

	/// 쿨타임을 얻어온다.
	const DWORD GetCoolingTime();
	
public:
	
	SMSG_SKILL_LIST::SkillInfo m_SkillData;	///< 스킬 정보


	// 
	// 인터페이스에서 필요로 하는 정보
	// 
	
	AR_HANDLE	m_hTarget;	///< 스킬 소유자의 핸들, 크리처일 경우
	
	AR_HANDLE	m_hSkillCard;	///< 적용된 스킬 카드 핸들

	DWORD		m_dwBeginTime;
	bool 		m_bCasting;
	bool 		m_bFire;
	int			m_nUseLevel;
	
	int			m_nAddedLevel;

	BOOL		m_bUse;		///< 사용되고 있는 스킬의 정보
	DWORD		m_dwCoolTime;
	DWORD   	m_dwStartTime;
private:

};

//SAddedSkillInfo
class SAddedSkillInfo
{
public:

	/// 생성자
	SAddedSkillInfo();

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

	/// 스킬 소유자 핸들 획득
	const AR_HANDLE GetTarget() const	{ return m_hTarget; }

	/// 스킬 소유자 핸들 설정
	void SetTarget( AR_HANDLE hTarget ) { m_hTarget = hTarget; }

	/// 스킬 정보 설정
	void SetAddedSkill( SMSG_ADDED_SKILL_LIST::AddedSkillInfo & skill_data );
	
	int GetLevel(int SkillId, AR_HANDLE target);

	AR_HANDLE	m_hTarget;	///< 스킬 소유자의 핸들, 크리처일 경우

	SMSG_ADDED_SKILL_LIST::AddedSkillInfo m_SkillData;	///< 스킬 정보
};

//////////////////////////////////////////////////////////////////////////
//SSkillSlotMgr
// MJ 2005/04/01
typedef std::vector<SSkillSlot*>	SKILL_VECTOR;
typedef std::vector<SAddedSkillInfo*>	ADDED_SKILL_VECTOR;

/// 플레이어 스킬 매니저
class SSkillSlotMgr : public SGameUIMgr
{
public:
	SSkillSlotMgr();
	virtual ~SSkillSlotMgr();

	virtual void ResetSkill();
	virtual void ResetAddedSkill();

	/// Cool Time 처리
	virtual void Process( DWORD	dwTime );

	virtual void AddSkill( DWORD dwTime, SMSG_SKILL_LIST::SkillInfo & skill_data, AR_HANDLE hTarget = NULL, int modificationType = 0 ); ///< 스킬 추가
	virtual void DelSkill( int nSkillCode, AR_HANDLE hTarget = NULL );	///< 스킬 삭제
	virtual BOOL UseSkill( int nSkillCode, int nLevel );				///< 스킬 사용

	virtual void AddAddedSkill(SMSG_ADDED_SKILL_LIST::AddedSkillInfo & skill_data, AR_HANDLE hTarget);

	virtual void SetCurSkill( int nSkill_ID = -1 );
	virtual void AddCooling( int nSkill_ID, AR_HANDLE hTarget = NULL );      ///< Cooling 등록
	virtual void DelCooling( int nSkill_ID, AR_HANDLE hTarget = NULL );      ///< Cooling 삭제

	/// 인터페이스에서 필요로 하는 정보 관리
	virtual const SKILL_VECTOR & GetSkillList() { return m_vecSkillSlotList; };
	virtual const ADDED_SKILL_VECTOR & GetAddedSkillList() { return m_vecAddedSkillList; };

	virtual void SetSkillCard( int nSkillID, AR_HANDLE hItem );
	
	bool SetCastingSkill( int nSkillID, bool bCasting, AR_HANDLE hTarget = NULL );
	bool SetFireSkill( int nSkillID, bool bFire, AR_HANDLE hTarget = NULL );
	bool SetCastingCancelSkill( int nSkillID, AR_HANDLE hTarget = NULL );

	virtual const int GetBaseSkillLevel( int nSkillID, AR_HANDLE hTarget = NULL ) const;
	virtual const int GetCurrentSkillLevel( int nSkillID, AR_HANDLE hTarget = NULL ) const;
	virtual const int GetUseSkillLevel( int nSkillID ) const;
	virtual const int GetUseSkillLevel( int nSkillID, AR_HANDLE hTarget ) const;
	virtual const DWORD GetSkillMaxTime( int nSkillID, AR_HANDLE hTarget = NULL ) const;
	virtual const DWORD GetSkillCurTime( int nSkillID, AR_HANDLE hTarget = NULL ) const;
	virtual const AR_HANDLE GetSkillCard( int nSkillID ) const;

	virtual const bool IsExistSkill( int nSkillID, AR_HANDLE hTarget = NULL ) const;
	virtual const bool IsCastingSkill( int nSkillID, AR_HANDLE hTarget = NULL ) const;
	virtual const bool IsFireSkill( int nSkillID, AR_HANDLE hTarget = NULL ) const;
	virtual const bool IsEnableCreatureSkill() const;

	virtual const bool IsExistSkillLevel( int nSkillID, int nSkillLevel, AR_HANDLE hTarget = NULL ) const;

	virtual SSkillSlot* GetSkillSlot( int nSkillID );

	void GetIdenticalCoolTimeGroup( int nSkill_ID, std::vector<int>& vecSkillList ) const;

	AR_TIME GetLastTimeUsed() { return tLastTimeUsed; };
	void SetLastTimeUsed(AR_TIME time) { tLastTimeUsed = time; };

	/// 스킬이 쿨타임 중인지 체크한다
	BOOL CheckCoolTime( int nSkillID );
	virtual void ResetInfo();
protected:
	virtual void Init();
	virtual void Destroy();

	SKILL_VECTOR m_vecSkillSlotList;
	ADDED_SKILL_VECTOR m_vecAddedSkillList;

	DWORD m_dwTime;

	int				   m_nCurUseSkill;   ///< 현재 사용 중인 스킬
	std::vector< int > m_nCoolingSkill;  ///< 쿨링 중인 스킬들
	
	AR_TIME tLastTimeUsed;

private:

};

//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
/// 소환수 스킬
struct QUICK_SKILL
{
	int m_nSkillID;
	int m_nUseLevel;
	int m_nQuickSlotNum;
	AR_HANDLE m_hCreature;

	enum STATE_QUICK_SLOT
	{
		STATE_NONE = 0,    ///< 상태 없음
		STATE_CASTING,     ///< 캐스팅
		STATE_FIRE,	       ///< 화이어
		STATE_CANCEL,      ///< 취소
		STATE_TOGGLE_ON,   ///< 토글 On
		STATE_TOGGLE_OFF,  ///< 토글 Off
		STATE_TOGGLE_ON_BY_USER,   //
		STATE_TOGGLE_OFF_BY_USER,  //
	};

	STATE_QUICK_SLOT	m_nStateQuickSlot;

	QUICK_SKILL( int nSkillID, int nUseLevel, int nQuickSlotNum, AR_HANDLE hCreature, int nState )
	{
		m_nSkillID = nSkillID;
		m_nUseLevel = nUseLevel;
		m_nQuickSlotNum = nQuickSlotNum;
		m_hCreature = hCreature;
		m_nStateQuickSlot = STATE_NONE;
		m_nStateQuickSlot = (STATE_QUICK_SLOT)nState;
	}

	STATE_QUICK_SLOT	GetStateQuickSlot()	{ return m_nStateQuickSlot; }
	void				SetStateQuickSlot( STATE_QUICK_SLOT nState ) { m_nStateQuickSlot = nState; }	
};
class SCreatureSkillSlotMgr : public SSkillSlotMgr
{
public:
	SCreatureSkillSlotMgr();
	virtual ~SCreatureSkillSlotMgr();

	virtual void ResetCreatureSkill( AR_HANDLE hTarget );

	virtual void AddSkill( DWORD dwTime, SMSG_SKILL_LIST::SkillInfo & skill_data, AR_HANDLE hTarget = NULL, int modificationType = 0 ); ///< 스킬 추가
	virtual BOOL UseSkill( int nSkillCode, int nLevel );				///< 스킬 사용
	
	virtual void SetCurSkill( int nSkill_ID = -1 );
	virtual void AddCooling( int nSkill_ID, AR_HANDLE hTarget = NULL );      ///< Cooling 등록
	virtual void DelCooling( int nSkill_ID, AR_HANDLE hTarget = NULL );      ///< Cooling 삭제

	// skill quick slot
	void InitQuickSlot();
	void AddQuickSlot( AR_HANDLE hCreature, int nSkillID, int nLevel, int nState, int nQuickSlotNum, int nDragIndex=-1 );
	bool ChangeQuickSlot( AR_HANDLE hCreature, int nQuickSlotNum, int nDragIndex );
	void DelQuickSlot( AR_HANDLE hCreature, int nQuickSlotNum );
	QUICK_SKILL* FindQuickSlot( AR_HANDLE hCreature, int nQuickSlotNum );
	void GetQuickslotID( AR_HANDLE hCreature, int nSkillID, std::vector<int>& rIdList );
	BOOL IsUseSkill( AR_HANDLE hCreature, int nSkillID );

	virtual const bool IsExistSkill( int nSkillID, AR_HANDLE hTarget = NULL ) const;
	const bool AbleLearnSkill( int nSkillID, int nLv, AR_HANDLE hTarget ) const;

	BOOL CheckCoolTime( int nSkillID, AR_HANDLE hCaster );	///< 스킬이 쿨타임 중인지 체크한다

	void ResetInfo();
protected:
	std::vector<QUICK_SKILL> m_vecQuickSlotList;
};