#include "stdafx.h"
#include "Resource.h"
#include "ManageClient.h"
#include <Utility/ServerAppFramework/MsgProc/MsgProc.h>
#include <Utility/ServerAppFramework/ConsoleWindow/ConsoleWindow.h>
#include <Utility/ServerAppFramework/ConsoleWindow/ConsoleCMDFactory.h>
#include <Network/Dispatch/ManageClient/ManageClientDispatch.h>

#include <Network/Dispatch/SendManagePacket.h>

#include <Log/ServerLog.h>

class CIPCMessage : public CMsgProc
{
private:

    virtual LRESULT operator () (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
	{
		GET_SINGLE_DISPATCH(lpManageClientDispatch, 
			CManageClientDispatch, CManageClientDispatch::GetDispatchTable());

		if(0 != lpManageClientDispatch && 0 != lParam)
		{
		    // µ¥ÀÌÅÍ ¸Þ½ÃÁö.
		    COPYDATASTRUCT& copyDataStruct = *reinterpret_cast<PCOPYDATASTRUCT>(lParam);
            ServerManage::PktManagePacket* lpPktManage = 
                reinterpret_cast<ServerManage::PktManagePacket*>(copyDataStruct.lpData);

            ServerManage::PktManagePing* lpPktManagePing =
                static_cast<ServerManage::PktManagePing*>(lpPktManage);

            unsigned long dwRunID = 0;

            if(ServerManage::CMD::IPC_ManagePing == lpPktManage->GetCmd()
                && copyDataStruct.cbData == sizeof(ServerManage::PktManagePing)
                && lpManageClientDispatch->GetRunIDFromString(
                lpPktManagePing->m_szAppFullPathName, lpPktManagePing->m_szCommandLine, dwRunID))
            {
                HWND hWnd = FindWindow(lpPktManagePing->m_szWindowName, 
                    lpPktManagePing->m_szWindowName);

                if(0 != hWnd)
                {
                    lpManageClientDispatch->SetAppData(dwRunID, 
                        hWnd, lpPktManage->m_dwPID, lpPktManagePing->m_dwStatusFlag);
                }
            }
            else if(lpManageClientDispatch->GetRunIDFromPID(lpPktManage->m_dwPID, dwRunID))
            {
                ServerManage::SendManagePacket(lpManageClientDispatch->GetSession(), 
                    ServerManage::CMD::RelayCommand, WM_COPYDATA, wParam, 0, dwRunID, 
                    static_cast<unsigned short>(copyDataStruct.cbData), 0, copyDataStruct.lpData, 0);
            }
		}
   
        return 0;
	}
};


class CProcessCommandMessage : public CMsgProc
{
public:

	CProcessCommandMessage(CManageClient& ManageClient) : m_ManageClient(ManageClient) {	}

private:

    virtual LRESULT operator () (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
	{
		char* szCommand = 0;	

        CConsoleWindow* lpConsoleWindow = m_ManageClient.GetConsoleWindow();
        if(0 == lpConsoleWindow)
        {
            return 0;
        }

		switch (LOWORD(wParam)) 
		{
    	case ID_MANAGECLIENT_OPEN_CONSOLE:  lpConsoleWindow->Initialize("ROWManageClient");  break;
		case ID_MANAGECLIENT_CLOSE_CONSOLE: lpConsoleWindow->Destroy();     break;
        case ID_MANAGECLIENT_RELOADSETUP:   szCommand = "reload";           break;
		}

		if(0 != szCommand)
		{
			lpConsoleWindow->GetCMDProcess().Add(
				lpConsoleWindow->GetConsoleCMDFactory().Create(szCommand, strlen(szCommand)));
		}

		if(LOWORD(wParam) == IDM_EXIT)
		{
			DETLOG0(g_Log, "Terminate ManageServer System Tray.");
			PostMessage(hWnd, WM_QUIT, 0, 0);
		}		

    	return 0;
	}

	CManageClient& m_ManageClient;
};

bool CManageClient::InitializeMsgProc()
{
    CMsgProcessMgr* lpMsgProcessMgr = GetMsgProcessMgr();
	if(0 == lpMsgProcessMgr)
	{
		return false;
	}

    int nErrorCount = 0;
	
    lpMsgProcessMgr->Remove(WM_COPYDATA);

    nErrorCount += lpMsgProcessMgr->Register(WM_COPYDATA, new CIPCMessage) ? 0 : 1;
    nErrorCount += lpMsgProcessMgr->Register(WM_COMMAND, new CProcessCommandMessage(*this)) ? 0 : 1;
	
    return 0 == nErrorCount;
}