#pragma once

#include <string>
using namespace std;

typedef unsigned char byte;

//#define		MAX_VERSION_COUNT		3
//#define		MAX_VERSION_CHAR_SIZE	128

class CVersionInfo
{
public:
	CVersionInfo(void);
	CVersionInfo( const CVersionInfo& obj )
	{
		for( int i = 0 ; i < MAX_VERSION_COUNT; i++ )
			m_byVer[i] = obj.m_byVer[i];
	}

	~CVersionInfo(void);

private:
	byte			m_byVer[MAX_VERSION_COUNT];

public:
	byte			GetVersion( int nNum );
	bool			SetVersion( int nNum, byte byVer );
	unsigned int	GetTotalVersion();
	void			Init();
	bool			SetVersionFromString( char* pszVersion ); //01.02.03 °ú °°Àº ŸÀÔÀÇ ½ºÆ®¸µ¹öÀüÀ¸·Î ¹öÀü¼¼ÆÃ
	bool			GetStringVersion( char* OUT pszVersion, int nSize );

public:
	CVersionInfo&	operator=( const CVersionInfo& obj )
	{
		for( int i = 0 ; i < MAX_VERSION_COUNT; i++ )
			m_byVer[i] = obj.m_byVer[i];

		return *this;
	}

};

//////////////////////////////////////////////////////////////////////////
#ifdef __VERSIONEX_CLASS
#include <tchar.h>
namespace VersionEx
{
	class VersionInfoEx
	{
		enum { max_ver_value = 0x00ffffff };

	public:
		explicit VersionInfoEx( DWORD ver = 0 )
			: m_dwVer( ver), m_bBad(  false)
		{
			if( ver > max_ver_value ) 
			{
				m_bBad = true;
				m_dwVer = 0;
			}
		}

		VersionInfoEx( const VersionInfoEx& rhs )
			: m_dwVer( rhs.m_dwVer), m_bBad( rhs.m_bBad)
		{ }

		~VersionInfoEx() { }

		//.//

		inline DWORD GetVersion() const { return m_dwVer; }

		bool GetStringVersion( TCHAR* OUT pszVersion, int nSize ) const
		{
			if( nSize < MAX_PATCH_VER_SIZE )
				return false;

			memset( m_szVer, 0, nSize);
			_stprintf( pszVersion, _T("%d.%d.%d"), first, middle, last);
			return true;
		}

		const TCHAR* GetStringVersion() const
		{
			memset( m_szVer, 0, MAX_PATCH_VER_SIZE);
			_stprintf( m_szVer, _T("%d.%d.%d"), first, middle, last);

			return m_szVer;
		}

		bool SetVersion( const TCHAR* szVer )
		{
			std::string strVersion( szVer);
			int nCnt = 1;
			std::size_t nPos = 0;

			m_dwVer = 0;
			BYTE *Ver = reinterpret_cast< BYTE* >( &m_dwVer);

			while( ( nPos = strVersion.find( '.')) != string::npos )
			{
				string strVer = strVersion.substr( 0, nPos);
				Ver[nCnt] = atoi( strVer.c_str());
				strVersion.erase( 0, nPos + 1);
				nCnt++;
			}
			Ver[nCnt] = atoi( strVersion.c_str());

			return true;
		}

		inline bool SetVersion( DWORD ver )
		{	// Á¤»ó °ªÀÌ ¾Æ´Ò°æ¿ì 0À¸·Î ¼³Á¤
			if( ver > max_ver_value ) 
				return false;
			else
			{
				m_dwVer = ver;
				return !( m_bBad = false);
			}
		}

		inline bool	IsBad() const {	return m_bBad;	}

		operator DWORD() const
		{
			return m_dwVer;
		}

		bool operator == ( const VersionInfoEx& rhs ) const
		{
			return ( rhs.m_dwVer == m_dwVer);
		}

		bool operator  < ( const VersionInfoEx& rhs ) const
		{
			return ( m_dwVer < rhs.m_dwVer);
		}

		VersionInfoEx& operator = ( const VersionInfoEx& rhs )
		{
			memcpy( this, &rhs, sizeof( *this));
			return ( *this);
		}

	private:
		union 
		{
			struct 
			{	// ex. 1.0.1
				BYTE dummy;		// »ç¿ëµÇÁö ¾ÊÀ½
				BYTE first;	
				BYTE middle;
				BYTE last;
			};

			DWORD m_dwVer;
		};

		bool m_bBad;
		mutable TCHAR m_szVer[MAX_PATCH_VER_SIZE];
	};
}
#endif //__VERSIONEX_CLASS
//////////////////////////////////////////////////////////////////////////