#include "StdAfx.h"

// _NA_005026_20120527_CHAOS_ZONE_BATTLE_GROUND
#include <ChaosZoneSystem/Handler_CG_BATTLE_GROUND.h>
#include <PacketStruct_AG_ChaosZoneSystem.h>
#include <ChaosZoneSystem/PacketStruct_ChaosZoneSystem.h>
#include <ChaosZoneSystem/BattleGroundManager.h>
#include <TimeCheck/BattleGroundOpenTimeManager.h>

void Handler_CG_BATTLE_GROUND::OnCG_ProcessPacket(User* user, MSG_BASE* packet, WORD size)
{
#ifdef _NA_000000_20120914_CHAOS_ZONE_BATTLE_GROUND_ACTIVATION
    MSG_CG_BATTLE_GROUND_PACKET* recv_packet = static_cast<MSG_CG_BATTLE_GROUND_PACKET*>(packet);

    switch(recv_packet->packet_type)
    {
    case CG_BATTLE_GROUND_RESERVATION_SYN:   // ÀüÀå ¿¹¾à..
        {
            OnCG_BATTLE_GROUND_RESERVATION_SYN(user, packet, size);
        }break;

    case CG_BATTLE_GROUND_RESERVATION_CANCEL_SYN:   // ÀüÀå Ãë¼Ò..
        {
            OnCG_BATTLE_GROUND_RESERVATION_CANCEL_SYN(user, packet, size);
        }break;

    case CG_BATTLE_GROUND_ABNORMAL_EXIT_USER_REMOVE_SYN:  // ºñÁ¤»ó Á¢¼Ó Á¾·á½Ã ¿¹¾à Ãë¼Ò
        {
            OnCG_BATTLE_GROUND_ABNORMAL_EXIT_USER_REMOVE_SYN(user, packet, size);
        }break;
#ifdef _NA_008679_20160202_REWORK_BATTLEGROUND
    case CG_BATTLE_GROUND_GET_OPEN_TIME_SYN:
        {
            OnCG_BATTLE_GROUND_GET_OPEN_TIME_SYN(user, packet, size);
        }break;
    case CG_BATTLE_GROUND_RESERVATION_COUNT_SYN:
        {
            OnCG_BATTLE_GROUND_RESERVATION_COUNT_SYN(user, packet, size);
        } break;
#endif // _NA_008679_20160202_REWORK_BATTLEGROUND
    default:
        {
            user->SendToLinkedServer(static_cast<MSG_BASE_FORWARD*>(packet), size);
        }
        break;
    }
#endif // _NA_000000_20120914_CHAOS_ZONE_BATTLE_GROUND_ACTIVATION
}

void Handler_CG_BATTLE_GROUND::OnCG_BATTLE_GROUND_RESERVATION_SYN(User* user, MSG_BASE* packet, WORD size)
{
    MSG_CG_BATTLE_GROUND_RESERVATION_SYN* recv_msg = 
        static_cast<MSG_CG_BATTLE_GROUND_RESERVATION_SYN*>(packet);

    const MAPCODE map_code = recv_msg->map_code;
    MSG_CG_BATTLE_GROUND_RESERVATION_ACK ack_msg;

    BattleGroundManager* const battle_ground_manager = BattleGroundManager::Instance();
    if (battle_ground_manager == NULL)
    {
        ack_msg.result_code = RC::RC_BATTLE_GROUND_RESERVATION_FAIL;
        user->SendPacket(&ack_msg, sizeof(ack_msg));
        return;
    }

    // ÀÔÀå Á¦ÇÑ È®ÀÎ..
    RC::eBATTLE_GROUND_RESULT result_code = battle_ground_manager->CanReservation(user, map_code);
    if (result_code != RC::RC_BATTLE_GROUND_RESERVATION_SUCCESS) 
    {
        ack_msg.result_code = result_code;
        user->SendPacket(&ack_msg, sizeof(ack_msg));
        return;
    }

    //Agent->GameServer¿¡¼­ °ËÁõ
    MSG_AG_BATTLE_GROUND_CAN_RESERVATION_SYN msg;
    msg.map_code = map_code;
    msg.is_healer = recv_msg->is_healer;
    user->SendToLinkedServer(&msg, sizeof(msg));
}

void Handler_CG_BATTLE_GROUND::OnCG_BATTLE_GROUND_RESERVATION_CANCEL_SYN(User* user, MSG_BASE* packet, WORD size)
{
    MSG_CG_BATTLE_GROUND_RESERVATION_CANCEL_SYN* recv_msg = 
        static_cast<MSG_CG_BATTLE_GROUND_RESERVATION_CANCEL_SYN*>(packet);

    BattleGroundManager* const battle_ground_manager = BattleGroundManager::Instance();

    MSG_CG_BATTLE_GROUND_RESERVATION_CANCEL_ACK ack_msg;
    // ¿¹¾à Ãë¼Ò
    ack_msg.result_code = battle_ground_manager->CancelReservation(user);
    
    user->SendPacket(&ack_msg, sizeof(ack_msg));
}

void Handler_CG_BATTLE_GROUND::OnCG_BATTLE_GROUND_ABNORMAL_EXIT_USER_REMOVE_SYN(User* user, MSG_BASE* packet, WORD size)
{
    MSG_CG_BATTLE_GROUND_ABNORMAL_EXIT_USER_REMOVE_SYN* recv_msg = 
        static_cast<MSG_CG_BATTLE_GROUND_ABNORMAL_EXIT_USER_REMOVE_SYN*>(packet);
}

#ifdef _NA_008679_20160202_REWORK_BATTLEGROUND
void Handler_CG_BATTLE_GROUND::OnCG_BATTLE_GROUND_GET_OPEN_TIME_SYN(User* user, MSG_BASE* packet, WORD size)
{
    MSG_CG_BATTLE_GROUND_GET_OPEN_TIME_SYN* recv_msg = 
        static_cast<MSG_CG_BATTLE_GROUND_GET_OPEN_TIME_SYN*>(packet);

    MSG_CG_BATTLE_GROUND_GET_OPEN_TIME_ACK ack_msg;

    util::TimeInfoPerFrame time_info;
    util::TimeSync::UpdateTimeInfoPerFrame(&time_info);

    BattleGroundManager::Instance()->SetupMessage(time_info, &ack_msg);

    user->SendPacket(&ack_msg, sizeof(ack_msg));
}

VOID Handler_CG_BATTLE_GROUND::OnCG_BATTLE_GROUND_RESERVATION_COUNT_SYN( User* user, MSG_BASE* packet, WORD siz )
{
    MSG_CG_BATTLE_GROUND_RESERVATION_COUNT_SYN* recv_msg = 
        static_cast<MSG_CG_BATTLE_GROUND_RESERVATION_COUNT_SYN*>(packet);

    BattleGroundManager::Instance()->SendReservationMemberCountToClient(user->GetUserGUID(), recv_msg->map_code);
}

#endif //_NA_008679_20160202_REWORK_BATTLEGROUND