#pragma once

#include "PublicDefine.h"
#include "Constant.h"
#include <tchar.h>

struct SERVER_INFO
{
	DWORD	m_dwServerKey;
	BYTE	m_byServerNum;
	BYTE	m_byWorld;
	BYTE	m_byChannel;
	BYTE	m_byServerType;
	BYTE	m_byStatus;
};

struct SERVER_INFO_EX : public SERVER_INFO
{
	CHAR			m_szWorldName[MAX_WORLD_NAME_SIZE];
	CHAR			m_szChannelName[MAX_WORLD_NAME_SIZE];
};

#ifdef __20080312__SOLARAUTH_SERVER_PATCH
struct SCFOLDER_INFO
{
	DWORD m_Key;
	DWORD m_ParentKey;
	TCHAR m_szName[MAX_WORLD_NAME_SIZE];
	TCHAR m_szVer[MAX_PATCH_VER_SIZE];

	SCFOLDER_INFO()
	{
		ZeroMemory( this, sizeof( SCFOLDER_INFO));
	}

	SCFOLDER_INFO( const SCFOLDER_INFO& rhs )
		: m_Key( rhs.m_Key)
		, m_ParentKey( rhs.m_ParentKey)
	{
		_tcsncpy( m_szName, rhs.m_szName, MAX_WORLD_NAME_SIZE);
		_tcsncpy( m_szVer, rhs.m_szVer, MAX_PATCH_VER_SIZE);
	}

	SCFOLDER_INFO( DWORD key, DWORD parentKey, const TCHAR* szName, const TCHAR* szVer )
		: m_Key( key)
		, m_ParentKey( parentKey)
	{
		_tcsncpy( m_szName, szName, MAX_WORLD_NAME_SIZE);
		_tcsncpy( m_szVer, szVer, MAX_PATCH_VER_SIZE);
	}

	const SCFOLDER_INFO& operator=( const SCFOLDER_INFO& rhs )
	{
		m_Key = rhs.m_Key;
		m_ParentKey = rhs.m_ParentKey;
		_tcsncpy( m_szName, rhs.m_szName, MAX_WORLD_NAME_SIZE);
		_tcsncpy( m_szVer, rhs.m_szVer, MAX_PATCH_VER_SIZE);

		return ( *this);
	}
};

//.// UPDATE_INFO

struct UPDATE_INFO
{
	BYTE	m_byUpdateNumber;
	BYTE	m_byUpdateSequence;	
	TCHAR	m_szProcessName[MAX_PATH];	
	TCHAR	m_szProcessVer[MAX_PATH];				

	UPDATE_INFO()
	{
		ZeroMemory( this, sizeof( UPDATE_INFO));
	}

	VOID SetProcName( const TCHAR* szName )
	{
		_tcsncpy( m_szProcessName, szName, MAX_PATH);
	}

	VOID SetProcVer( const TCHAR* szVer )
	{
		_tcsncpy( m_szProcessVer, szVer, MAX_PATH);
	}

	//.//

	const UPDATE_INFO& operator=( const UPDATE_INFO& rhs )
	{
		CopyMemory( this, &rhs, sizeof(UPDATE_INFO));
		return ( *this);
	}
};

struct PROCESS_INFO : public UPDATE_INFO
{
	TCHAR m_szCheckProcess[MAX_PATH];

	PROCESS_INFO()
		: UPDATE_INFO()
	{
		ZeroMemory( m_szCheckProcess, MAX_PATH );
	}

	VOID SetCheckProc( const TCHAR* szCheckProc )
	{
		_tcsncpy( m_szCheckProcess, szCheckProc, MAX_PATH);
	}

	//.//

	const PROCESS_INFO& operator=( const PROCESS_INFO& rhs )
	{
		CopyMemory( m_szCheckProcess, rhs.m_szCheckProcess, MAX_PATH);
		dynamic_cast<UPDATE_INFO *>( this)->operator =( rhs);

		return ( *this);
	}
};


struct FTP_INFO
{
	DWORD m_dwPort;
	TCHAR m_szIP[MAX_IP_SIZE];
	TCHAR m_szUserID[MAX_NAME_SIZE];
	TCHAR m_szPWD[MAX_PASSWORD_SIZE];

	FTP_INFO()
	{
		ZeroMemory( this, sizeof( FTP_INFO));
	}

	FTP_INFO( const FTP_INFO& rhs )
	{
		CopyMemory( this, &rhs, sizeof( FTP_INFO));
	}

	VOID SetIP( const TCHAR* szIP )
	{
		_tcsncpy( m_szIP, szIP, MAX_IP_SIZE);
	}

	VOID SetUserID( const TCHAR* szID )
	{
		_tcsncpy( m_szUserID, szID, MAX_NAME_SIZE);
	}

	VOID SetPWD( const TCHAR* pwd )
	{
		_tcsncpy( m_szPWD, pwd, MAX_PASSWORD_SIZE);
	}

	const FTP_INFO& operator=( const FTP_INFO& rhs )
	{
		CopyMemory( this, &rhs, sizeof( FTP_INFO));
		return ( *this);
	}
};

#endif //__20080312__SOLARAUTH_SERVER_PATCH

struct PATCH_VERSION
{
	BYTE	m_byVer1;
	BYTE	m_byVer2;
	BYTE	m_byVer3;
};

struct SERVER_PATCH_INFO : public SERVER_INFO
{
	PATCH_VERSION	m_PatchVer;
};

struct SERVER_ACCESS_INFO : public SERVER_INFO
{
	BOOL	bAccessRight;
};

struct AddressInfo
{
	TCHAR	m_szServerIP[MAX_IP_SIZE];
	WORD	m_wServerPort;
};


//////////////////////////////////////////////////////////////////////////
//	Master와 연동용...
#ifdef __20080310__CHANGE_SET_SERVERKEY
typedef struct tagSERVER_KEY
{
	union
	{
		struct
		{
			BYTE m_WorldID;
			BYTE m_ChannelID;
			BYTE m_ServerType;
			BYTE m_ServerID;
		};
		DWORD m_dwKey;
	};

	//.//

	explicit tagSERVER_KEY( const DWORD key = 0 ) 
	: m_dwKey( key) 
	{}

	tagSERVER_KEY( BYTE worldID, BYTE channelID, BYTE serverType, BYTE serverID ) 
	: m_WorldID( worldID)
	, m_ChannelID( channelID)
	, m_ServerType( serverType)
	, m_ServerID( serverID)
	{}

	operator DWORD() const 
	{ 
		return m_dwKey; 
	}

	VOID Init() 
	{
		Set( 0, 0, 0, 0 );
	}

	DWORD Set( BYTE worldID, BYTE channelID, BYTE serverType, BYTE serverID ) 
	{
		m_WorldID		= worldID;
		m_ChannelID		= channelID;
		m_ServerType	= serverType;
		m_ServerID		= serverID;

		return m_dwKey;
	}

	inline DWORD GetOldServerKey() const 
	{
		return ( ( ( m_dwKey)&0x000000FF << 24) | 
				 ( ( m_dwKey)&0x0000FF00 <<  8) | 
				 ( ( m_dwKey)&0x00FF0000 >>  8) | 
				 ( ( m_dwKey)&0xFF000000 >> 24));
		//or
		return ( ( m_ServerID << 24) | ( m_ServerType << 16) | 
			     ( m_ChannelID >> 8) | ( m_WorldID));
	}

	inline BYTE	GetWorldID() const { return m_WorldID; }
	inline BYTE	GetChannelID() const { return m_ChannelID; }
	inline BYTE	GetServerType()	const {	return m_ServerType; }
	inline BYTE	GetServerID() const { return m_ServerID; }
} SERVER_KEY, *LPSERVER_KEY;
#else //__20080310__CHANGE_SET_SERVERKEY
typedef struct tagSERVER_KEY
{
	union
	{
		struct
		{
			BYTE m_WorldID;
			BYTE m_ChannelID;
			BYTE m_ServerType;
			BYTE m_ServerID;
		};
		DWORD m_dwKey;
	};

	tagSERVER_KEY( const DWORD key = 0 )	{ m_dwKey = key; }
	tagSERVER_KEY( BYTE worldID, BYTE channelID, BYTE serverType, BYTE serverID )	{ Set(worldID, channelID, serverType, serverID); }
	operator DWORD()						{ return m_dwKey; }
	DWORD Set( BYTE worldID, BYTE channelID, BYTE serverType, BYTE serverID )
	{
		m_WorldID		= worldID;
		m_ChannelID		= channelID;
		m_ServerType	= serverType;
		m_ServerID		= serverID;

		return m_dwKey;
	}
	BYTE GetWorldID()		{ return m_WorldID; }
	BYTE GetChannelID()		{ return m_ChannelID; }
	BYTE GetServerType()	{ return m_ServerType; }
	BYTE GetServerID()		{ return m_ServerID; }
} SERVER_KEY, *LPSERVER_KEY;
#endif //__20080310__CHANGE_SET_SERVERKEY
//////////////////////////////////////////////////////////////////////////


// SERVER_KEY 내용 바뀌면서 바이트 뒤집어져서 임시로 수정 - 장기적으로는 구조체로 보내지 않는 편이 좋겠다(성현창)
typedef struct tagOLDSERVER_KEY
{
	DWORD dwKey;

	tagOLDSERVER_KEY( const DWORD key = 0 ) { dwKey = key; }
	operator DWORD()		{ return dwKey; }

	DWORD Set( BYTE worldID, BYTE channelID, BYTE serverType, BYTE serverID )
	{
		memcpy( &dwKey, &worldID, sizeof(BYTE) );
		dwKey <<= 8;	memcpy( &dwKey, &channelID, sizeof(BYTE) );
		dwKey <<= 8;	memcpy( &dwKey, &serverType, sizeof(BYTE) );
		dwKey <<= 8;	memcpy( &dwKey, &serverID, sizeof(BYTE) );
		return dwKey;
	}
	BYTE GetWorldID()		{ BYTE id; DWORD temp = dwKey; temp >>= 24; memcpy( &id, &temp, sizeof(BYTE) ); return id; }
	BYTE GetChannelID()	{ BYTE id; DWORD temp = dwKey; temp >>= 16; memcpy( &id, &temp, sizeof(BYTE) ); return id; }
	BYTE GetServerType()		{ BYTE id; DWORD temp = dwKey; temp >>= 8; memcpy( &id, &temp, sizeof(BYTE) ); return id; }
	BYTE GetServerID()		{ BYTE id; memcpy( &id, &dwKey, sizeof(BYTE) ); return id; }
	const DWORD operator=(const SERVER_KEY &ServerKey)
	{
		this->Set( ServerKey.m_WorldID, ServerKey.m_ChannelID, ServerKey.m_ServerType, ServerKey.m_ServerID );
		return dwKey;
	}
} OLD_SERVER_KEY, *LPOLD_SERVER_KEY;


struct FTP_CONNECT_INFO
{
	BYTE	m_byWorld;
	TCHAR	m_szName[MAX_NAME_SIZE];
	TCHAR	m_szIP[MAX_IP_SIZE];
	WORD	m_wPort;
	TCHAR	m_szID[MAX_USERID_SIZE];
	TCHAR	m_szPassword[MAX_PASSWORD_SIZE];
};


struct GAME_PROCESS_STATUS
{
	eGAME_SERVER_TYPE	m_ServerType;
	eSERVER_STATUS		m_Status;
};

struct USER_ID_TOTAL_INFO
{
	BYTE	m_wCount;
	TCHAR	m_szUserID[MAX_USER_COUNT][MAX_USERID_SIZE];

	DWORD	GetSize()
	{
		return ( sizeof(TCHAR)*MAX_USERID_SIZE*m_wCount + sizeof(m_wCount) );
	}

	USER_ID_TOTAL_INFO()
	{
		m_wCount = 0;
		ZeroMemory( m_szUserID, sizeof(m_szUserID) );
	}
};

struct AGENT_INFO
{
	DWORD	m_dwAgentKey;
	TCHAR	m_szIP[MAX_IP_SIZE];
};

#ifdef __20080312__SOLARAUTH_SERVER_PATCH
struct CONVERT_RESULT
{
	BOOL byType;		// false : 인코드 true : 디코드
	eRC_CONVERT dwError;
	TCHAR szFileName[MAX_FILE_NAME];

	CONVERT_RESULT()
	{
		ZeroMemory( this, sizeof( CONVERT_RESULT));
	}
};
#endif

#ifdef __20120306__SOLARAUTH_SERVER_PATCH_RESULT
struct PATCH_RESULT
{
    BYTE    patch_result_type_;
    BYTE    solar_server_type_;
};
#endif