#include "stdafx.h"
#include "ToolUserManageTable.h"

#include <tchar.h>
#include <Log/ServerLog.h>

#include <Stream/Buffer/Buffer.h>
#include <Stream/Buffer/BufferFactory.h>

#include <Network/Session/Session.h>
#include <Network/Dispatch/SendManagePacket.h>
#include <Network/Dispatch/ManageServer/ManageToolServerDispatch.h>

#include <DB/SQLite.h>
#include <DB/ManageServerDB.h>
#include <Setup/RylServerGroupSetup.h>


CToolUserManager& CToolUserManager::GetInstance()
{
	static CToolUserManager toolUserManager(CManageServerDB::GetInstance());
	return toolUserManager;
}


inline void SetUserInfo(ServerManage::UserInfo& UserInfo_Out, 
						const char* szID, const char* szPass,
						const char* szFullName, const char* szIP,
						const char* szAdminLevel)
{
	_snprintf(UserInfo_Out.szID, ServerManage::UserInfo::ID_LEN - 1, "%s", szID);
	UserInfo_Out.szID[ServerManage::UserInfo::ID_LEN - 1] = 0;

	_snprintf(UserInfo_Out.szPassword, ServerManage::UserInfo::PASS_LEN - 1, "%s", szPass);
	UserInfo_Out.szPassword[ServerManage::UserInfo::PASS_LEN - 1] = 0;

	_snprintf(UserInfo_Out.szFullName, ServerManage::UserInfo::NAME_LEN - 1, "%s", szFullName);
	UserInfo_Out.szFullName[ServerManage::UserInfo::NAME_LEN - 1] = 0;

	UserInfo_Out.dwIP = inet_addr(szIP);
	UserInfo_Out.usAdminLevel = atoi(szAdminLevel);
}


CToolUserManager::ToolUser::ToolUser(CManageToolServerDispatch* lpDispatch, 
									 ServerManage::UserInfo& userInfo)
									 :	m_lpDispatch(lpDispatch), m_UserInfo(userInfo)
{

}

CToolUserManager::ToolUser::ToolUser()
:	m_lpDispatch(0)
{
	memset(&m_UserInfo, 0, sizeof(ServerManage::UserInfo));
}


enum ToolUserConst
{
	TOOLUSER_MAX_QUERY = 1024
};


CToolUserManager::CToolUserManager(CManageServerDB& ManageServerDB)
:	m_ManageServerDB(ManageServerDB)
{
    memset(&m_ManageUser, 0, sizeof(ServerManage::UserInfo));
}

CToolUserManager::~CToolUserManager()
{

}

// -------------------------------------------------------------------------
// UserManagement
bool CToolUserManager::AddUser(const ServerManage::UserInfo& userInfo)
{
	char szQuery[TOOLUSER_MAX_QUERY];

	in_addr addr;
	addr.S_un.S_addr = userInfo.dwIP;

	int nQueryLen = _snprintf(szQuery, TOOLUSER_MAX_QUERY - 1, 
		"INSERT INTO TblManageToolUser values('%s', '%s', '%s', '%s', %d)",
		userInfo.szID, userInfo.szPassword, userInfo.szFullName, 
		inet_ntoa(addr), userInfo.usAdminLevel);

	szQuery[TOOLUSER_MAX_QUERY - 1] = 0;

	if(0 < nQueryLen)
	{
		CSQLite::Dataset addUserQuery(m_ManageServerDB.GetSQLite(), szQuery);

		if(addUserQuery.Compile() && addUserQuery.Execute())
		{
			return true;
		}

		ERRLOG2(g_Log, "AddUser failed - query failed : %s(Query:%s)", 
			addUserQuery.GetLastError(), szQuery);
	}
	else
	{
		ERRLOG1(g_Log, "AddUser failed - make query failed : (Query:%s)", szQuery);
	}	
	
	return false;
}


bool CToolUserManager::GetUserInfo(const char* szID_In, 
								   ServerManage::UserInfo& userInfo_Out)
{
	char szQuery[TOOLUSER_MAX_QUERY];

	int nQueryLen = _snprintf(szQuery, TOOLUSER_MAX_QUERY - 1, 
		"SELECT ID, PASS, NAME, IP, LEVEL FROM TblManageToolUser WHERE ID = '%s'", szID_In);

	szQuery[TOOLUSER_MAX_QUERY - 1] = 0;

	if(0 < nQueryLen)
	{
        CSQLite::Dataset getUserQuery(m_ManageServerDB.GetSQLite(), szQuery);

		int nColNum = 0;
		const char** pazValue  = 0;
		const char** pazColumn = 0;

		if(getUserQuery.Compile() && 
			getUserQuery.Execute(&nColNum, &pazValue, &pazColumn))
		{	
			if(5 == nColNum && 0 != pazValue)
			{
				SetUserInfo(userInfo_Out, pazValue[0], pazValue[1], 
					pazValue[2], pazValue[3], pazValue[4]);
				return true;
			}
		}

		ERRLOG2(g_Log, "Getuser failed - query error : %s(Query:%s)", 
			getUserQuery.GetLastError(), szQuery);
	}
	else
	{
		ERRLOG1(g_Log, "Getuser failed - create query failed : (Query:%s)", szQuery);
	}
	
	return false;
}

bool CToolUserManager::DelUser(const char* szID)
{
	char szQuery[TOOLUSER_MAX_QUERY];

	int nQueryLen = _snprintf(szQuery, TOOLUSER_MAX_QUERY - 1, 
		"DELETE FROM TblManageToolUser WHERE ID = '%s'", szID);

	szQuery[TOOLUSER_MAX_QUERY - 1] = 0;

	if(0 < nQueryLen)
	{
        CSQLite::Dataset delUserQuery(m_ManageServerDB.GetSQLite(), szQuery);

		if(delUserQuery.Compile() && delUserQuery.Execute())
		{
            return true;
		}

		ERRLOG2(g_Log, "Deluser failed - query error : %s(Query:%s)", 
			delUserQuery.GetLastError(), szQuery);
	}
	else
	{
		ERRLOG1(g_Log, "Deluser failed - create query error : %s", szQuery);
	}

	return false;
}

bool CToolUserManager::ModifyUser(const ServerManage::UserInfo& modified)
{
	char szQuery[TOOLUSER_MAX_QUERY];

	in_addr addr;
	addr.S_un.S_addr = modified.dwIP;

	int nQueryLen = _snprintf(szQuery, TOOLUSER_MAX_QUERY - 1, 
		"UPDATE TblManageToolUser SET PASS = '%s', NAME = '%s', IP = '%s', LEVEL = %d WHERE ID = '%s'",
		modified.szPassword, modified.szFullName, inet_ntoa(addr),
		modified.usAdminLevel, modified.szID);

	szQuery[TOOLUSER_MAX_QUERY - 1] = 0;

	if(0 < nQueryLen)
	{
        CSQLite::Dataset modUserQuery(m_ManageServerDB.GetSQLite(), szQuery);

		if(modUserQuery.Compile() && modUserQuery.Execute())
		{
            return true;
		}

		ERRLOG2(g_Log, "Moduser failed - query error : %s(Query:%s)", 
			modUserQuery.GetLastError(), szQuery);
	}
	else
	{
		ERRLOG1(g_Log, "Moduser failed - create query error : %s", szQuery);
	}

	return false;
}


bool CToolUserManager::SendAllUserInfo(CSession& Session)
{
    const int MAX_USER_INFO = (PktMaxLen - sizeof(ServerManage::UserCommand)) / sizeof(ServerManage::UserInfo);
	ServerManage::UserInfo tempUserInfo[MAX_USER_INFO];

	CBufferFactory& bufferFactory = Session.GetPolicy().GetBufferFactory();
	const char* szQuery = "SELECT ID, PASS, NAME, IP, LEVEL FROM TblManageToolUser";

    CSQLite::Dataset getUserQuery(m_ManageServerDB.GetSQLite(), szQuery);

	if(getUserQuery.Compile())
	{
        int nColNum = 0;
		const char** pazValue  = 0;
		const char** pazColumn = 0;

		int nRowCount = 0;

		while(getUserQuery.Execute(&nColNum, &pazValue, &pazColumn))
		{	
			if(5 == nColNum && 0 != pazValue)
			{
				SetUserInfo(tempUserInfo[nRowCount], pazValue[0], 
					pazValue[1], pazValue[2], pazValue[3], pazValue[4]);

				memset(tempUserInfo[nRowCount].szPassword, 0, 
					ServerManage::UserInfo::PASS_LEN);

				++nRowCount;
			}

			if(nRowCount == MAX_USER_INFO)
			{
				ServerManage::SendUserInfo(bufferFactory, &Session, tempUserInfo, 
					nRowCount, ServerManage::CMD::UserList, 0);

                nRowCount = 0;
			}

		}

		if(0 < nRowCount)
		{
            ServerManage::SendUserInfo(bufferFactory, &Session, tempUserInfo, 
				nRowCount, ServerManage::CMD::UserList, 0);
		}

		if(0 != getUserQuery.GetLastError())
		{
			ERRLOG2(g_Log, "Getuser failed - query error : %s(Query:%s)", 
				getUserQuery.GetLastError(), szQuery);
		}
	}
	else if(0 != getUserQuery.GetLastError())
	{
		ERRLOG2(g_Log, "Getuser failed - compile query failed : %s(Query:%s)", 
			getUserQuery.GetLastError(), szQuery);
	}

	return true;
}


bool CToolUserManager::GetUserInfo(UserList& userList_Out)
{
	const unsigned char MAX_USER_INFO = 100;
	ServerManage::UserInfo tempUserInfo[MAX_USER_INFO];
	const char* szQuery = "SELECT ID, PASS, NAME, IP, LEVEL FROM TblManageToolUser";

    CSQLite::Dataset getUserQuery(m_ManageServerDB.GetSQLite(), szQuery);

	if(getUserQuery.Compile())
	{
        int nColNum = 0;
		const char** pazValue  = 0;
		const char** pazColumn = 0;

		int nRowCount = 0;

		while(getUserQuery.Execute(&nColNum, &pazValue, &pazColumn))
		{	
			if(5 == nColNum && 0 != pazValue)
			{
				SetUserInfo(tempUserInfo[nRowCount], pazValue[0], 
                    pazValue[1], pazValue[2], pazValue[3], pazValue[4]);

				++nRowCount;
			}

			if(nRowCount == MAX_USER_INFO)
			{
                userList_Out.insert(userList_Out.end(), tempUserInfo, tempUserInfo + nRowCount);
                nRowCount = 0;
			}
		}

		if(0 < nRowCount)
		{
            userList_Out.insert(userList_Out.end(), tempUserInfo, tempUserInfo + nRowCount);
		}

		if(0 != getUserQuery.GetLastError())
		{
			ERRLOG2(g_Log, "Getuser failed - query error : %s(Query:%s)", 
				getUserQuery.GetLastError(), szQuery);
		}
        else
        {
            return true;
        }
	}
	else if(0 != getUserQuery.GetLastError())
	{
		ERRLOG2(g_Log, "Getuser failed - compile query failed : %s(Query:%s)", 
			getUserQuery.GetLastError(), szQuery);
	}

    return false;
}


// Login/Logout
ServerManage::UserCommandError CToolUserManager::Authorize(CManageToolServerDispatch& dispatch, 
														   ServerManage::UserInfo& userInfo_inout)
{
	ServerManage::UserInfo foundUserInfo;
	memset(&foundUserInfo, 0, sizeof(ServerManage::UserInfo));

	ServerManage::UserCommandError eUserCommandErr = ServerManage::NO_USER_COMMAND_ERROR;

	int iCheck =
		GetPrivateProfileInt("SETTING", "USER_IP_CHECK", 1, CRylServerGroupSetup::GetInstance().GetSetupFileName());

	if(IsLogin(userInfo_inout.szID))
	{
		eUserCommandErr = ServerManage::ALREADY_LOGINED;
	}
	else if(!GetUserInfo(userInfo_inout.szID, foundUserInfo))
	{
		eUserCommandErr = ServerManage::CANNOT_AUTHORIZE_NOT_USER;
	}
	else if(0 != strncmp(foundUserInfo.szPassword, userInfo_inout.szPassword, 
		ServerManage::UserInfo::PASS_LEN))
	{
		eUserCommandErr = ServerManage::CANNOT_AUTHORIZE_INVALID_PASSWORD;
	}
	else if((1 == iCheck) && (foundUserInfo.dwIP != userInfo_inout.dwIP))
	{
		eUserCommandErr = ServerManage::CANNOT_AUTHORIZE_INVALID_IPADDRESS;
	}
	else
	{
		// ID, Password가 같다. 인증 성공.
		Logout(foundUserInfo.szID);

		m_LoginUserList.push_back(ToolUser(&dispatch, foundUserInfo));
		userInfo_inout = foundUserInfo;
	}

	return eUserCommandErr;
}


bool CToolUserManager::IsLogin(const char* szName)
{
	CurrentUserList::iterator pos = m_LoginUserList.begin();
	CurrentUserList::iterator end = m_LoginUserList.end();

	for(; pos != end; ++pos)
	{
		ToolUser& toolUser = *pos;

		if(0 == strncmp(toolUser.m_UserInfo.szID, szName, ServerManage::UserInfo::ID_LEN))
		{
			return true;
		}
	}

	return false;
}


bool CToolUserManager::Logout(const char* szName)
{
	CurrentUserList::iterator pos = m_LoginUserList.begin();
	CurrentUserList::iterator end = m_LoginUserList.end();

	int nEraseCount = 0;

	for(; pos != end;)
	{
		ToolUser& toolUser = *pos;

		if(0 == strncmp(toolUser.m_UserInfo.szID, szName, ServerManage::UserInfo::ID_LEN))
		{
			// Logout info를 준다.
			ServerManage::SendUserInfo(toolUser.m_lpDispatch->GetBufferFactory(), 0, 
				&toolUser.m_UserInfo, 1, ServerManage::CMD::UserLogout, 0);

            if(IsManageUser(toolUser.m_UserInfo))
            {
                memset(&m_ManageUser, 0, sizeof(ServerManage::UserInfo));

                ServerManage::SendUserInfo(toolUser.m_lpDispatch->GetBufferFactory(), 0, 
                    &m_ManageUser, 1, ServerManage::CMD::ManagerInfo, 0);
            }

			pos = m_LoginUserList.erase(pos);
			++nEraseCount;
		}
		else
		{
			++pos;
		}
	}

	return (0 < nEraseCount);
}


// Send packets to all users
bool CToolUserManager::SendToAllLoginUser(const char* szBuffer, unsigned short usBufferSize, unsigned char cCmd_In)
{
	CurrentUserList::iterator pos = m_LoginUserList.begin();
	CurrentUserList::iterator end = m_LoginUserList.end();

	for(; pos != end; ++pos)
	{
		ToolUser&					toolUser	= *pos;
		CManageToolServerDispatch*	lpDispatch	= toolUser.m_lpDispatch;

		if(0 != lpDispatch)
		{						
			lpDispatch->GetSendStream().PutBuffer(szBuffer, usBufferSize, cCmd_In);
		}
	}

	return true;
}


bool CToolUserManager::SendAllLoginUserInfo(CSession& Session)
{
	const unsigned char MAX_USER_INFO = 100;
	ServerManage::UserInfo tempUserInfo[MAX_USER_INFO];

	CBufferFactory& bufferFactory = Session.GetPolicy().GetBufferFactory();

	CurrentUserList::iterator pos = m_LoginUserList.begin();
	CurrentUserList::iterator end = m_LoginUserList.end();

	unsigned char cSendNum = 0;

	for(; pos != end; ++pos)
	{
		tempUserInfo[cSendNum] = pos->m_UserInfo;
		memset(tempUserInfo[cSendNum].szPassword, 0, ServerManage::UserInfo::PASS_LEN);

		++cSendNum;

		if(cSendNum == MAX_USER_INFO)
		{
			ServerManage::SendUserInfo(bufferFactory, &Session,
				tempUserInfo, cSendNum, ServerManage::CMD::UserLogin, 0);

			cSendNum = 0;
		}
	}

	if(0 < cSendNum)
	{
		ServerManage::SendUserInfo(bufferFactory, &Session,
			tempUserInfo, cSendNum, ServerManage::CMD::UserLogin, 0);
	}

	return true;
}


CManageToolServerDispatch* CToolUserManager::GetUserDispatch(unsigned long dwIP)
{
	CurrentUserList::iterator pos = m_LoginUserList.begin();
	CurrentUserList::iterator end = m_LoginUserList.end();

	for(; pos != end; ++pos)
	{
		ToolUser& toolUser = *pos;

		if(toolUser.m_UserInfo.dwIP == dwIP)
		{
			return toolUser.m_lpDispatch;
		}
	}

	return 0;
}

CManageToolServerDispatch* CToolUserManager::GetUserDispatch(const char* szID)
{
	CurrentUserList::iterator pos = m_LoginUserList.begin();
	CurrentUserList::iterator end = m_LoginUserList.end();

	for(; pos != end; ++pos)
	{
		ToolUser& toolUser = *pos;

		if(0 == strncmp(toolUser.m_UserInfo.szID, szID, ServerManage::UserInfo::ID_LEN))
		{
			return toolUser.m_lpDispatch;
		}
	}

	return 0;
}


bool CToolUserManager::IsManageUser(const ServerManage::UserInfo& UserInfo)
{
    if(0 == strncmp(m_ManageUser.szID, UserInfo.szID, ServerManage::UserInfo::ID_LEN))
    {
        return true;
    }

    return false;
}