#include "stdafx.h"

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

#include <Network/Session/Session.h>
#include <Network/Packet/ManagePacketCmd.h>
#include <Network/Dispatch/SendManagePacket.h>
#include <Network/Dispatch/MultiDispatchStorage.h>
#include <UserManage/ToolUserManageTable.h>

#include <Log/ServerLog.h>
#include <Setup/SetupClient.h>

#include <ServerManage/ManageClientManager.h>
#include <UserManage/UserStatistics.h>

enum ManageServerConst
{
	MANAGE_SERVER_DEFAULT_DISPATCH_NUM = 100
};

CMultiDispatch& CManageServerDispatch::GetDispatchTable()
{
	static CMultiDispatch multiDispatch;
	return multiDispatch;
}


CManageServerDispatch::CManageServerDispatch(CSession& Session)
:	CRylServerDispatch(Session, MANAGE_SERVER_DEFAULT_DISPATCH_NUM),
	m_bAuthorized(false)
{	
	memset(&m_UserInfo, 0, sizeof(ServerManage::UserInfo));

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


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


void CManageServerDispatch::Connected()
{
	// Á¢¼Ó IP¸¦ key·Î Àâ¾Æ¼­ ¼¼ÆÃÇÑ´Ù.
	INET_Addr& remoteAddr = GetSession().GetRemoteAddr();

	unsigned long dwDispatchID = remoteAddr.get_addr_in().sin_addr.S_un.S_addr;
	GetDispatchTable().SetDispatch(dwDispatchID, this);
	
    // TODO : ¼­¹ö IP·Î °Ë»öÇؼ­, RunInfoµéÀ» Àü¼ÛÇÑ´Ù.

    CManageClientManager::RunTable runInfoTable;
    CManageClientManager::GetInstance().GetRunInfoFromIP(dwDispatchID, runInfoTable);

    if(!CManageClientManager::SendRunInfo(GetSession(), runInfoTable))
    {
        ERRLOG3(g_Log, "SS:0x%p/DP:0x%p/IP:%15s/Send runInfo failed",
            &GetSession(), this, remoteAddr.get_addr_string());
    }

	DETLOG2(g_Log, "this:0x%p/Key:%u/CManageServerDispatch Connected", this, dwDispatchID);
}



class CSendProcessData
{
public:

    CSendProcessData(ServerManage::ProcessStatus* lpProcessData, 
        unsigned short usProcessDataNum)
        :   m_lpProcessData(lpProcessData), m_usProcessDataNum(usProcessDataNum)
    {

    }

    bool operator () (CManageToolServerDispatch& toolDispatch)
    {
        ServerManage::SendManagePacket(toolDispatch.GetSession(), ServerManage::CMD::ProcessStatus, 
            0, 0, 0, 0, sizeof(ServerManage::ProcessStatus) * m_usProcessDataNum, 0, m_lpProcessData, 0);
        return true;
    }

private:
    
    ServerManage::ProcessStatus*    m_lpProcessData;
    unsigned short                  m_usProcessDataNum;
};

void CManageServerDispatch::Disconnected()
{
	// Á¢¼Ó IP¸¦ key·Î Àâ¾Æ¼­ ¼¼ÆÃÇÑ´Ù.
	INET_Addr& remoteAddr = GetSession().GetRemoteAddr();

	unsigned long dwDispatchID = remoteAddr.get_addr_in().sin_addr.S_un.S_addr;
	GetDispatchTable().RemoveDispatch(dwDispatchID);

    CManageClientManager::RunTable runInfoTable;
    CManageClientManager::GetInstance().GetRunInfoFromIP(dwDispatchID, runInfoTable);

    CManageClientManager::RunTable::iterator pos = runInfoTable.begin();
    CManageClientManager::RunTable::iterator end = runInfoTable.end();
    
    const int MAX_PROCESS_STATUS_SEND_ONCE = 
        (PktMaxLen - sizeof(ServerManage::ManageCommand)) / sizeof(ServerManage::ProcessStatus);

    ServerManage::ProcessStatus procesStatus[MAX_PROCESS_STATUS_SEND_ONCE];

    unsigned short usSendProcessStatus = 0;

    for(; pos != end; ++pos)
    {
        ServerManage::RunInfo& runInfo = pos->second;

        // Default - Deactivated Process.
        ServerManage::ProcessStatus* lpCurrentProcessStatus = procesStatus + usSendProcessStatus;
        memset(lpCurrentProcessStatus, 0, sizeof(ServerManage::ProcessStatus));

        lpCurrentProcessStatus->m_dwRunID = runInfo.m_dwRunID;
        ++usSendProcessStatus;

        if(usSendProcessStatus == MAX_PROCESS_STATUS_SEND_ONCE)
        {
            CToolUserManager::GetInstance().ProcessCurrentUser(
                CSendProcessData(procesStatus, usSendProcessStatus));

            usSendProcessStatus = 0;
        }
    }

    if(0 < usSendProcessStatus)
    {
        CToolUserManager::GetInstance().ProcessCurrentUser(
            CSendProcessData(procesStatus, usSendProcessStatus));

        usSendProcessStatus = 0;
    }

	DETLOG2(g_Log, "this:0x%p/Key:%u/CManageServerDispatch Disconnected", this, dwDispatchID);
}


bool CManageServerDispatch::DispatchPacket(PktBase* lpPktBase)
{
	PktBase::LengthType nPacketLen = lpPktBase->GetLen();
	
	bool bResult = false;

    switch(lpPktBase->GetCmd())
	{
    case ServerManage::CMD::ProcessStatus:
        CUserStatistics::GetInstance().CheckClearUser(lpPktBase);
        RelayPacketToManageTools(lpPktBase);
        break;
        
	case ServerManage::CMD::RelayCommand:
		RelayPacketToManageTools(lpPktBase);
		break;

	default:

		{
			in_addr addr;
			addr.S_un.S_addr = m_UserInfo.dwIP;

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

	return true;
}


bool CManageServerDispatch::RelayPacketToManageTools(PktBase* lpPktBase)
{
	unsigned char   cError = 0;
    bool            bDoNotRelay = false;

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

	if(!ServerManage::CheckManagePacketLength(lpPktBase))
	{
		cError = ServerManage::INVALID_MANAGE_PACKET_ERROR;
	}

    if(sizeof(ServerManage::PktManagePacket) <= lpManageCommand->usDataLen)
    {
        ServerManage::PktManagePacket* lpPktManagePacket = 
            reinterpret_cast<ServerManage::PktManagePacket*>(lpManageCommand + 1);

        switch(lpPktManagePacket->m_dwSubCommand)
        {
        case ServerManage::CMD::SubCmd_ServerUserNum:
            {
                ServerManage::PktManageUserNum* lpPktManageUserNum = 
                    static_cast<ServerManage::PktManageUserNum*>(lpPktManagePacket);

				/*
                DETLOG2(g_Log, "RunID:%d/PID:%d/Setting UserInfo", 
                    lpManageCommand->dwRunID, lpPktManageUserNum->m_dwPID);
					*/

                CUserStatistics::GetInstance().SerializeIn(lpManageCommand->dwRunID, 
                    reinterpret_cast<ServerManage::UserNumPair*>(lpPktManageUserNum + 1), 
                    lpPktManageUserNum->m_dwUserInfoNum);
            }
            break;            
        }
    }

	if(0 == cError && !bDoNotRelay)
	{
		CToolUserManager::GetInstance().ProcessCurrentUser(
			ServerManage::CSendManagePacketToClient(*lpManageCommand, 
            reinterpret_cast<char*>(lpManageCommand + 1)));

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