#include "stdafx.h"
#include <PacketStruct_CL.h>

#include "Handler_CL.h"

#include <Object/WiseUser.h>

#include "SolarDateTime.h"

#undef ADD_HANDLER_SEND_INFO_EOR
#undef ADD_HANDLER_SEND_INFO
#define ADD_HANDLER_SEND_INFO_EOR()	{ MAKEWORD(0, 0), PHASE_NOACTION, (PH_fnHandler)NULL }
#define ADD_HANDLER_SEND_INFO(c, p, accptablePHASE)		\
    { MAKEWORD(c, p), (ePHASE_SHIFT)(accptablePHASE), (PH_fnHandler)&Handler_CL::SEND::Send##p }

#undef ADD_HANDLER_RECV_INFO_EOR
#undef ADD_HANDLER_RECV_INFO
#define ADD_HANDLER_RECV_INFO_EOR()	{ MAKEWORD(0, 0), PHASE_NOACTION, (PH_fnHandler)NULL }
#define ADD_HANDLER_RECV_INFO(c, p, accptablePHASE)		\
    { MAKEWORD(c, p), (ePHASE_SHIFT)(accptablePHASE), (PH_fnHandler)&Handler_CL::RECV::On##p }


sPACKET_HANDLER_INFO*	Handler_CL::GetHandlerInfo()
{
    static sPACKET_HANDLER_INFO s_pHandlerInfo[] =
    {
        // CG_CONNECTION
        //ADD_HANDLER_SEND_INFO(CG_CONNECTION, CG_CONNECTION_BACKTOCHARSELECT_SYN, PHASE_UNLIMITED),
        ADD_HANDLER_RECV_INFO(CATEGORY_AUTH, FC_AUTH_READY_CMD, PHASE_UNLIMITED),
        ADD_HANDLER_RECV_INFO(CATEGORY_AUTH, FC_AUTH_VERIFY_ACK, PHASE_UNLIMITED),
        ADD_HANDLER_RECV_INFO(CATEGORY_AUTH, FC_AUTH_ID_PASSWORD_CHECK_ACK, PHASE_UNLIMITED),
        ADD_HANDLER_RECV_INFO(CATEGORY_AUTH, FC_AUTH_SERVER_LIST_WORLD_ACK, PHASE_UNLIMITED),
        ADD_HANDLER_RECV_INFO(CATEGORY_AUTH, FC_AUTH_SERVER_LIST_CHANNEL_ACK, PHASE_UNLIMITED),
        //ADD_HANDLER_RECV_INFO(CATEGORY_AUTH, CL_AUTH_S2C_AKPATTERN_NTF, PHASE_UNLIMITED),
        ADD_HANDLER_RECV_INFO(CATEGORY_AUTH, FC_AUTH_SERVER_SELECT_ACK, PHASE_UNLIMITED),
        ADD_HANDLER_RECV_INFO_EOR(),
    };

    return s_pHandlerInfo;
};

void	Handler_CL::RegisterHandler_ALL(PACKET_HANDLER_DELEGATOR pInstance)
{
    pInstance->RegisterHandler(LOGIN_FRONT_SESSION, GetHandlerInfo());

}

//
//
//



//HANDLER_CL_SEND_IMPL(CG_PREPARE_WORLD_CONNECT_SYN)

//void	Handler_CL::RECV::OnFC_AUTH_READY_CMD(WiseUser* pUser, MSG_BASE* pMsg, WORD wSize)
//{
//}


HANDLER_CL_RECV_IMPL(FC_AUTH_READY_CMD)
{
    DEBUGGING_CODE_L3("");

    MSG_FC_AUTH_READY_CMD& rRecvMsg = pSIG_NETMSG->MsgTypeOf<MSG_FC_AUTH_READY_CMD>();
    LogicFlowDelegator&	rLOGIC = pUser->GetLogicFlow();

    sAuthController& rAUTH = pUser->AuthController();
    rAUTH.EncKey() = rRecvMsg.m_dwEncKey;

    LF_DEFINE STEP = rLOGIC.GetCurrentSTEP();
    sSIG_STEP& rSIGNAL = sSIGNAL_BUFFER::InstanceOf<sSIG_STEP>();
    if(S_000330_WAIT_MSG_S2C_READY_LF == STEP)
    {
        rSIGNAL.SUBTYPE() = sSIG_STEP::ACTIVATE_NEXT_STEP;

        sSIG_STEP_ARG& rARG = rSIGNAL.InstanceOf<sSIG_STEP_ARG>();
        rARG.SetInfo(LFG_CONNECTION, S_000920_CLOSURE_EXCEPTION_LF);
        rLOGIC.OnMsg(&rSIGNAL);
    }
    else
    {
        DEBUGGING_CODE_L1("FAIL-STATUS");
        rSIGNAL.SUBTYPE() = sSIG_STEP::ACTIVATE_JUMP_STEP;
        sSIG_STEP_ARG& rARG = rSIGNAL.InstanceOf<sSIG_STEP_ARG>();
        rARG.SetInfo(LFG_CONNECTION, S_000920_CLOSURE_EXCEPTION_LF);
        rLOGIC.OnMsg(&rSIGNAL);
    }
}

HANDLER_CL_RECV_IMPL(FC_AUTH_VERIFY_ACK)
{
    DEBUGGING_CODE_L3("");

    // byResult = { 0(SUCCESS), 1(ERROR-Version)
    MSG_FC_AUTH_VERIFY_ACK& rRecvMsg = pSIG_NETMSG->MsgTypeOf<MSG_FC_AUTH_VERIFY_ACK>();
    LogicFlowDelegator&	rLOGIC = pUser->GetLogicFlow();

    LF_DEFINE STEP = rLOGIC.GetCurrentSTEP();
    sSIG_STEP& rSIGNAL = sSIGNAL_BUFFER::InstanceOf<sSIG_STEP>();
    if(S_000350_WAIT_FC_AUTH_VERIFY_LF == STEP)
    {
        rSIGNAL.SUBTYPE() = sSIG_STEP::ACTIVATE_NEXT_STEP;
        sSIG_STEP_ARG& rARG = rSIGNAL.InstanceOf<sSIG_STEP_ARG>();
        rARG.SetInfo(LFG_CONNECTION, S_000920_CLOSURE_EXCEPTION_LF);
        rLOGIC.OnMsg(&rSIGNAL);
    }
    else
    {
        DEBUGGING_CODE_L1("FAIL-STATUS");
        rSIGNAL.SUBTYPE() = sSIG_STEP::ACTIVATE_JUMP_STEP;
        sSIG_STEP_ARG& rARG = rSIGNAL.InstanceOf<sSIG_STEP_ARG>();
        rARG.SetInfo(LFG_CONNECTION, S_000920_CLOSURE_EXCEPTION_LF);
        rLOGIC.OnMsg(&rSIGNAL);
    }
}

HANDLER_CL_RECV_IMPL(FC_AUTH_ID_PASSWORD_CHECK_ACK)
{
    DEBUGGING_CODE_L3("");

    // byResult = { 0(SUCCESS), ... }
    MSG_FC_AUTH_ID_PASSWORD_CHECK_ACK& rRecvMsg = pSIG_NETMSG->MsgTypeOf<MSG_FC_AUTH_ID_PASSWORD_CHECK_ACK>();
    LogicFlowDelegator&	rLOGIC = pUser->GetLogicFlow();

    LF_DEFINE STEP = rLOGIC.GetCurrentSTEP();
    sSIG_STEP& rSIGNAL = sSIGNAL_BUFFER::InstanceOf<sSIG_STEP>();
    sSIG_STEP_ARG& rARG = rSIGNAL.InstanceOf<sSIG_STEP_ARG>();

    if(rRecvMsg.m_szInfo[0])
    {
        printf("%s\n", rRecvMsg.m_szInfo);
    }

    if(S_000370_WAIT_CF_AUTH_ID_PASSWORD_CHECK_LF == STEP)
    {
        rSIGNAL.SUBTYPE() = sSIG_STEP::ACTIVATE_NEXT_STEP;
    }
    else
    {
        DEBUGGING_CODE_L1("FAIL-STATUS");
        rSIGNAL.SUBTYPE() = sSIG_STEP::ACTIVATE_JUMP_STEP;
    }

    rARG.SetInfo(LFG_CONNECTION, S_000920_CLOSURE_EXCEPTION_LF);
    rLOGIC.OnMsg(&rSIGNAL);
}


HANDLER_CL_RECV_IMPL(FC_AUTH_SERVER_LIST_WORLD_ACK)
{
    DEBUGGING_CODE_L3("");

    MSG_FC_AUTH_SERVER_LIST_WORLD_ACK& rRecvMsg = pSIG_NETMSG->MsgTypeOf<MSG_FC_AUTH_SERVER_LIST_WORLD_ACK>();
    LogicFlowDelegator&	rLOGIC = pUser->GetLogicFlow();
    sAuthController& rAUTH = pUser->AuthController();
    rAUTH.CreateAuthInfo();
    AuthInfo* pAuthInfo = rAUTH.GetAuthInfo();

    const int number_of_groups = rRecvMsg.m_Count;
    pAuthInfo->Initialize(number_of_groups);

    sSIG_STEP& rSIGNAL = sSIGNAL_BUFFER::InstanceOf<sSIG_STEP>();

    if(pAuthInfo)
    {
        for (int index = 0; index < number_of_groups; ++index) {
            if (!FlowControl::FCAssert(pAuthInfo->AddGroupInfo(rRecvMsg.m_GroupDataList[index]))) {
                goto FAIL_PROCESS;
            }
        };

        LF_DEFINE STEP = rLOGIC.GetCurrentSTEP();
        if(S_000390_WAIT_FC_AUTH_SERVER_LIST_LF == STEP)
        {
            rSIGNAL.SUBTYPE() = sSIG_STEP::ACTIVATE_NEXT_STEP;
            sSIG_STEP_ARG& rARG = rSIGNAL.InstanceOf<sSIG_STEP_ARG>();
            rARG.SetInfo(LFG_CONNECTION, S_000920_CLOSURE_EXCEPTION_LF);
            rLOGIC.OnMsg(&rSIGNAL);
            return;
        }
    }

FAIL_PROCESS:
    {
        DEBUGGING_CODE_L1("FAIL-STATUS");
        rSIGNAL.SUBTYPE() = sSIG_STEP::ACTIVATE_JUMP_STEP;
        sSIG_STEP_ARG& rARG = rSIGNAL.InstanceOf<sSIG_STEP_ARG>();
        rARG.SetInfo(LFG_CONNECTION, S_000920_CLOSURE_EXCEPTION_LF);
        rLOGIC.OnMsg(&rSIGNAL);
    };
}

HANDLER_CL_RECV_IMPL(FC_AUTH_SERVER_LIST_CHANNEL_ACK)
{
    DEBUGGING_CODE_L3("");

    MSG_FC_AUTH_SERVER_LIST_CHANNEL_ACK& rRecvMsg = pSIG_NETMSG->MsgTypeOf<MSG_FC_AUTH_SERVER_LIST_CHANNEL_ACK>();
    LogicFlowDelegator&	rLOGIC = pUser->GetLogicFlow();
    sAuthController& rAUTH = pUser->AuthController();
    AuthInfo* auth_info = rAUTH.GetAuthInfo();

    printf("Server list\n");
    const int number_of_servers = rRecvMsg.m_Count;
    for (int index = 0; index < number_of_servers; ++index)
    {
        const SERVER_DATA& server_data = rRecvMsg.m_ServerDataList[index];
        if (!FlowControl::FCAssert(auth_info->AddServerInfo(server_data))) {
            goto CLOSURE_PROCESS;
        }
        printf("|Group=%d|Channel=%d|Stat=%d|Crowded=%d|Name=%s|\n",
               server_data.m_GroupID, server_data.m_ChannelID,
               server_data.m_ConnectStatus, server_data.m_CrowdGrade,
               server_data.m_szChannelName);
    }

    /*
    BYTE* pOffset = (BYTE*)(((MSG_BASE*)&rRecvMsg) + 1);
    DWORD dwGroupCnt = *pOffset;

    ++pOffset;

    if (!(dwGroupCnt && (dwGroupCnt < MAX_GROUP)))
    goto CLOSURE_PROCESS;

    rAUTH.CreateAuthInfo();
    AuthInfo* pAuthInfo = rAUTH.GetAuthInfo();
    pAuthInfo->Initialize(dwGroupCnt);

    do
    {	// ¼­¹ö ±×·ì ¸ñ·Ï À̸§
    AUTH_WORLD_NAME_T szWorldName;

    for(DWORD dwIdx=0 ; dwIdx<dwGroupCnt ; ++dwIdx, pOffset += MAX_WORLD_NAME_LEN)
    {
    szWorldName.CopyFrom((CHAR*)pOffset);
    DEBUGGING_CODE_L3(szWorldName.GetBUFFER());

    pAuthInfo->AddWorldInfo(dwIdx, szWorldName);
    }
    } while(0);

    const DWORD STATUS_COUNT = 16;
    do
    {	// ¼­¹ö ³ªÀÌÁ¦ÇÑ Á¤º¸
    for(DWORD dwIdx=0 ; dwIdx<STATUS_COUNT ; ++dwIdx, ++pOffset)
    {
    sWorldInfoByAuth* pWORLD = pAuthInfo->GetWorldByIndex(dwIdx);
    if(pWORLD)
    pWORLD->AGE = (eAGE_T)*pOffset;
    }
    } while(0);

    DWORD dwServerCnt = *pOffset;
    ++pOffset;

    if (!(dwServerCnt && (dwServerCnt < MAX_SVR)))
    goto CLOSURE_PROCESS;

    do
    {
    AUTH_CHANNEL_NAME_T szChannelName;

    for(DWORD dwIdx=0 ; dwIdx<dwServerCnt ; ++dwIdx, pOffset += sizeof(AUTH_SERVER_NAME))
    {
    AUTH_SERVER_NAME* pAUTH_STRUCT = (AUTH_SERVER_NAME*)pOffset;
    szChannelName.CopyFrom(pAUTH_STRUCT->szServerName);
    AUTH_WORLD_ID_T worldIDX = pAUTH_STRUCT->byGroupIdx;

    pAuthInfo->AddChannelInfo((BYTE)dwIdx, worldIDX, szChannelName);
    }
    } while(0);
    */

    DEBUGGING_CODE_L3("");

    return;

CLOSURE_PROCESS:
    {
        sSIG_STEP& rSIGNAL = sSIGNAL_BUFFER::InstanceOf<sSIG_STEP>();
        DEBUGGING_CODE_L1("FAIL-STATUS");
        rSIGNAL.SUBTYPE() = sSIG_STEP::ACTIVATE_JUMP_STEP;
        sSIG_STEP_ARG& rARG = rSIGNAL.InstanceOf<sSIG_STEP_ARG>();
        rARG.SetInfo(LFG_CONNECTION, S_000920_CLOSURE_EXCEPTION_LF);
        rLOGIC.OnMsg(&rSIGNAL);
    }
}

//HANDLER_CL_RECV_IMPL(CL_AUTH_S2C_AKPATTERN_NTF)
//{
//	DEBUGGING_CODE_L3("");
//}

HANDLER_CL_RECV_IMPL(FC_AUTH_SERVER_SELECT_ACK)
{
    DEBUGGING_CODE_L3("");

    MSG_FC_AUTH_SERVER_SELECT_ACK& rRecvMsg = pSIG_NETMSG->MsgTypeOf<MSG_FC_AUTH_SERVER_SELECT_ACK>();
    LogicFlowDelegator&	rLOGIC = pUser->GetLogicFlow();
    sAuthController& rAUTH = pUser->AuthController();
    AuthInfo* pAUTH = rAUTH.GetAuthInfo();

    DEFINE_CONST AUTH_RET_SUCCESS = 0;
    DEFINE_CONST AUTH_RET_SERVERDOWN = 1;
    DEFINE_CONST AUTH_RET_DUPLICATE = 2;
    DEFINE_CONST OTHER_ERROR = 3;

    DWORD dwRES = rRecvMsg.m_byResult;
    dwRES = pAUTH ? dwRES : OTHER_ERROR;

    sSIG_STEP& rSIGNAL = sSIGNAL_BUFFER::InstanceOf<sSIG_STEP>();
    switch(dwRES)
    {
    case AUTH_RET_SUCCESS:
        {
            rSIGNAL.SUBTYPE() = sSIG_STEP::ACTIVATE_NEXT_STEP;
            pAUTH->SetConnectingGameServerInfo(
                rRecvMsg.m_dwAuthUserID,
                rRecvMsg.m_serialKey,
                rRecvMsg.m_szSvrIP,
                (WORD)rRecvMsg.m_dwSvrPort
                );
        }
        break;
    case AUTH_RET_SERVERDOWN:
        {
            DEBUGGING_CODE_L3("AUTH_RET_SERVERDOWN");
            rSIGNAL.SUBTYPE() = sSIG_STEP::ACTIVATE_JUMP_STEP;
        }
        break;
    case AUTH_RET_DUPLICATE:
        {
            DEBUGGING_CODE_L3("AUTH_RET_DUPLICATE");
            rSIGNAL.SUBTYPE() = sSIG_STEP::ACTIVATE_JUMP_STEP;
            //Àç½Ãµµ...½ÃÅ°ÀÚ.
        }
        break;
    case OTHER_ERROR:
        {
            DEBUGGING_CODE_L3("OTHER_ERROR");
            rSIGNAL.SUBTYPE() = sSIG_STEP::ACTIVATE_JUMP_STEP;
        }
        break;
    }

    sSIG_STEP_ARG& rARG = rSIGNAL.InstanceOf<sSIG_STEP_ARG>();
    rARG.SetInfo(LFG_CONNECTION, S_000920_CLOSURE_EXCEPTION_LF);
    rLOGIC.OnMsg(&rSIGNAL);
}