#include "stdafx.h"

#include "ManageServerDispatch.h"
#include "ManageToolServerDispatch.h"

#include <Network/Session/Session.h>
#include <Network/Dispatch/SendManagePacket.h>
#include <Network/Dispatch/MultiDispatchStorage.h>

#include <Network/Packet/ManagePacketCmd.h>
#include <UserManage/ToolUserManageTable.h>
#include <ServerManage/ManageClientManager.h>

#include <Setup/SetupClient.h>
#include <Log/ServerLog.h>
#include <Network/Packet/WrapPacket.h>

#include <mmsystem.h>

enum ManageToolServerConst
{
	MANAGE_TOOL_SERVER_DEFAULT_DISPATCH_NUM = 10
};


CManageToolServerDispatch::CManageToolServerDispatch(CSession& Session)
:	CRylServerDispatch(Session, MANAGE_TOOL_SERVER_DEFAULT_DISPATCH_NUM),
	m_bAuthorized(false), m_dwLastPingRecvTime(timeGetTime())
{	
	memset(&m_UserInfo, 0, sizeof(ServerManage::UserInfo));

	DETLOG1(g_Log, "this:0x%p/CManageToolServerDispatch Created", this);
}


CManageToolServerDispatch::~CManageToolServerDispatch()
{
	DETLOG1(g_Log, "this:0x%p/CManageToolServerDispatch Destroyed", this);
}

void CManageToolServerDispatch::Connected()
{
	// 인증 성공시 LoginTable에 삽입된다.
	DETLOG1(g_Log, "this:0x%p/CManageToolServerDispatch Connected", this);
}

void CManageToolServerDispatch::Disconnected()
{
	if(0 != m_UserInfo.szID[0])
	{
        CToolUserManager::GetInstance().Logout(m_UserInfo.szID);
	}

	DETLOG1(g_Log, "this:0x%p/CManageToolServerDispatch Disconnected", this);
}


bool CManageToolServerDispatch::Dispatch()
{
    unsigned long dwCurrentTime = timeGetTime();

    // 2분 동안 핑을 못받으면 접속을 끊는다.
    if (1000 * 60 * 2 < dwCurrentTime - m_dwLastPingRecvTime)
    {
        INFLOG4(g_Log, "Disconnect by ping %s:%d / %u / %u ",
            GetRemoteAddr().get_addr_string(), GetRemoteAddr().get_port_in(),
            dwCurrentTime, m_dwLastPingRecvTime);

        return false;
    }

    return CRylServerDispatch::Dispatch();
}

bool CManageToolServerDispatch::DispatchPacket(PktBase* lpPktBase)
{
	PktBase::LengthType nPacketLen = lpPktBase->GetLen();
	
	bool bResult = true;
	const TCHAR* szErrorString = 0;

    bool bSendInvalidUserPacketAck = false;
    bool bSendInvalidManagePacketAck = false;

    if (ServerManage::CMD::Ping == lpPktBase->GetCmd())
    {
        m_dwLastPingRecvTime = timeGetTime();

        PktBase pktBase;
        memset(&pktBase, 0, sizeof(PktBase));
        pktBase.SetServerInfo(m_dwLastPingRecvTime);

        if (PacketWrap::WrapHeader(reinterpret_cast<char*>(&pktBase), 
            sizeof(PktBase), ServerManage::CMD::Ping, pktBase.GetState(), pktBase.GetError()))
        {
            GetSendStream().PutBuffer(reinterpret_cast<char*>(&pktBase), 
                sizeof(PktBase), ServerManage::CMD::Ping);
        }
    }
	else if(ServerManage::CMD::AuthUser == lpPktBase->GetCmd())
	{
        if(!AuthUser(lpPktBase))
		{
			szErrorString = "Authorize failed.";
		}
		else
		{
			m_bAuthorized = true;

            // 인증이 성공하면 RunInfo를 전송한다.
            if(!CManageClientManager::SendRunInfo(GetSession(), 
                CManageClientManager::GetInstance().GetRunInfoTable()))
            {
                ERRLOG3(g_Log, "SS:0x%p/DP:0x%p/IP:%15s/Send runInfo failed",
                    &GetSession(), this, GetSession().GetRemoteAddr().get_addr_string());
            }
		}
	}
	else if(m_bAuthorized)
	{
        switch(lpPktBase->GetCmd())
		{
        // 다음 커맨드들은, RunID가 속한 서버로 메시지를 Relay한다. 
        // Relay하지 못한 경우는 실패를 돌려준다.
        case ServerManage::CMD::RunProcess:
        case ServerManage::CMD::QuitProcess:
        case ServerManage::CMD::ForceTerminate:
        case ServerManage::CMD::ProcessStatus:

		case ServerManage::CMD::RelayCommand:
		case ServerManage::CMD::AutoPatch:
		case ServerManage::CMD::ChangeSetup:
		case ServerManage::CMD::ReloadSetup:

        case ServerManage::CMD::ExecuteCommand:

            if(CToolUserManager::GetInstance().IsManageUser(m_UserInfo) && 
                (m_UserInfo.usAdminLevel == CToolUserManager::MASTER 
                || m_UserInfo.usAdminLevel == CToolUserManager::GENERAL))
                
			{
                bResult = RelayPacketToManageClient(lpPktBase);
			}
            else
            {
                bSendInvalidManagePacketAck = true;
            }
			break;
		
		case ServerManage::CMD::AddUser:
			if(CToolUserManager::GetInstance().IsManageUser(m_UserInfo) && 
                m_UserInfo.usAdminLevel == CToolUserManager::MASTER) 
			{ 
				bResult = AddUser(lpPktBase);
			} 
            else
            {
                bSendInvalidUserPacketAck = true;
            }
			break;

		case ServerManage::CMD::DelUser:			
			if(CToolUserManager::GetInstance().IsManageUser(m_UserInfo) && 
                m_UserInfo.usAdminLevel == CToolUserManager::MASTER) 
			{ 
				bResult = DelUser(lpPktBase); 
			} 
            else
            {
                bSendInvalidUserPacketAck = true;
            }
			break;

		case ServerManage::CMD::ModUser:
			if(CToolUserManager::GetInstance().IsManageUser(m_UserInfo) && 
                m_UserInfo.usAdminLevel == CToolUserManager::MASTER) 
			{ 
				bResult = ModUser(lpPktBase);
			}
            else
            {
                bSendInvalidUserPacketAck = true;
            }
			break;

        case ServerManage::CMD::RequestPromote:
			if(m_UserInfo.usAdminLevel == CToolUserManager::MASTER || 
				m_UserInfo.usAdminLevel == CToolUserManager::GENERAL) 
			{ 
				bResult = RequestPromote(lpPktBase);
			}
            else
            {
                bSendInvalidUserPacketAck = true;
            }
			break;

        case ServerManage::CMD::RequestUserReaction:
			if(m_UserInfo.usAdminLevel == CToolUserManager::MASTER || 
				m_UserInfo.usAdminLevel == CToolUserManager::GENERAL) 
			{ 
				bResult = ProcessUserReaction(lpPktBase);
			}
            else
            {
                bSendInvalidUserPacketAck = true;
            }
			break;

		case ServerManage::CMD::UserList:
			if(m_UserInfo.usAdminLevel == CToolUserManager::MASTER) 
			{ 
				bResult = UserList(lpPktBase); 
			}
            else
            {
                bSendInvalidUserPacketAck = true;
            }
			break;
		
		default:
            szErrorString = "Unknown packet. Cannot process.";
			break;
		}
	}
	else
	{
		szErrorString = "Unauthorized user send command. Cannot process.";
	}

	if(!bResult)
	{
		szErrorString = "Packet process failed.";
	}

    if(bSendInvalidManagePacketAck)
    {
        ServerManage::SendManagePacket(GetSession(), lpPktBase->GetCmd(), 
            0, 0, 0, 0, 0, 0, 0, ServerManage::INVALID_MANAGE_RIGHTS);
    }

    if(bSendInvalidUserPacketAck)
    {
        ServerManage::SendUserInfo(GetBufferFactory(), &GetSession(), 0, 0, 
            lpPktBase->GetCmd(), ServerManage::INVALID_USERMANAGE_RIGHTS);
    }

	if(0 != szErrorString)
	{
		in_addr addr;
		addr.S_un.S_addr = m_UserInfo.dwIP;

        ERRLOG5(g_Log, "ID:%s/Name:%s/IP:%s/Cmd:0x%02x/%s",
			m_UserInfo.szID, m_UserInfo.szFullName, inet_ntoa(addr),
			lpPktBase->GetCmd(), szErrorString);
	}

	return true;
}


bool CManageToolServerDispatch::RelayPacketToManageClient(PktBase* lpPktBase)
{
	unsigned char cError = 0;

	ServerManage::ManageCommand* lpManageCommand = 
		reinterpret_cast<ServerManage::ManageCommand*>(lpPktBase);

	if(!ServerManage::CheckManagePacketLength(lpPktBase))
	{
		cError = ServerManage::INVALID_MANAGE_PACKET_ERROR;
	}
    
    if(CManageClientManager::MAX_RUNID == lpManageCommand->dwRunID)
	{
		CManageServerDispatch::GetDispatchTable().Process(
			ServerManage::CSendManagePacketToClient(*lpManageCommand, 
            reinterpret_cast<char*>(lpManageCommand + 1)));
	}
	else
	{
        ServerManage::RunInfo runInfo;

        if(CManageClientManager::GetInstance().GetRunInfo(
            lpManageCommand->dwRunID, runInfo))
        {
			GET_MULTI_DISPATCH(lpManageServerDispatch,
				runInfo.m_dwServerIP, 
				CManageServerDispatch, 
				CManageServerDispatch::GetDispatchTable());

			if(0 != lpManageServerDispatch)
			{
                DETLOG4(g_Log, "ID:%s/FullName:%s/Send Relay Packet(Cmd:%d), RunID:%u",
                    m_UserInfo.szID, m_UserInfo.szFullName, 
                    lpManageCommand->GetCmd(), lpManageCommand->dwRunID);
                
                if(!ServerManage::SendManagePacket(lpManageServerDispatch->GetSession(), 
					lpManageCommand->GetCmd(), lpManageCommand->nMessage, 
					lpManageCommand->wParam, lpManageCommand->lParam,
					lpManageCommand->dwRunID, lpManageCommand->usDataLen, lpManageCommand->usFlags,
					reinterpret_cast<char*>(lpManageCommand + 1), 0))
				{
					cError = ServerManage::SEND_MANAGE_COMMAND_ERROR;
				}
			}
			else
			{
				cError = ServerManage::CANNOT_FIND_CLIENT_DISPATCH;
			}
        }
        else
        {
            cError = ServerManage::UNKNOWN_RUN_INFO;
        }
	}

	return ServerManage::SendManagePacket(GetSession(), 
		lpPktBase->GetCmd(), 0, 0, 0, 0, 0, 0, 0, cError);
}