#include "stdafx.h"
#include "AceInterface.h"
#include "GameServer.h"

const wchar_t* AceInterface::kLibraryDir = L"./";
const uint32_t AceInterface::kGameID = 719;
const char* AceInterface::kAuthToken = "79205A21";
const uint32_t AceInterface::kWorldID = 160;

bool AceInterface::initAceInterface()
{
    AceSdkServerLibraryInfo library_info;
	memset(&library_info, 0, sizeof(AceSdkServerLibraryInfo));
	memcpy(library_info.library_dir_, kLibraryDir, wcslen(kLibraryDir)*sizeof(wchar_t));

    AceSdkServerAuthInfo auth_info;
	memset(&auth_info, 0, sizeof(AceSdkServerAuthInfo));
    auth_info.game_id_ = kGameID;
    snprintf(auth_info.auth_token_, sizeof(auth_info.auth_token_), "%s", kAuthToken);

    AceSdkServerDeploymentInfo deployment_info;
	memset(&deployment_info, 0, sizeof(AceSdkServerDeploymentInfo));
    deployment_info.region_ = ACE_SDK_REGION_CHINA_MAINLAND;
    deployment_info.distributor_ = ACE_SDK_GAME_DISTRIBUTOR_COMMON;

    AceSdkResult ret = ace_sdk_server_init(&library_info, &auth_info, &deployment_info);
    if (ret != ACE_SDK_RESULT_OK)
    {
        printf(">>ACE fail to init ace sdk server, ret : %d\n", ret);
        //return false;
    }

    //set text judge callback
    ret = ace_sdk_server_set_recv_batch_multi_text_result_callback(onAceTextJudgeCallback);
    if (ret != ACE_SDK_RESULT_OK)
    {
        printf(">>ACE fail to set text judge callback, ret : %d\n", ret);
        //return false;
	}
	printf(">>ACE SDK server init success.\n");
	return true;
}

bool AceInterface::onPlayerLogin(const AceSdkAccount& account, AceSdkTicket& aceTicket, AceSdkLightFeatureResponse& lightFeature)
{
    // add player when login
    AceSdkPlayerAddInfo add_player_info;
	memset(&add_player_info, 0, sizeof(AceSdkPlayerAddInfo));
    snprintf(add_player_info.role_name_, sizeof(add_player_info.role_name_) - 1, "qq_%s", account.account_);
    AceSdkResult ret = ace_sdk_server_add_player(&account, &add_player_info);
    if (ret != 0)
    {
        printf(">>ACE fail to add player, ret: %d\n", ret);
        return false;
    }

	printf(">>ACE add player success.\n");

    // get ticket
	memset(&aceTicket, 0, sizeof(AceSdkTicket));
    ret = ace_sdk_server_get_ticket(&account, &aceTicket);
    if (ret != 0)
    {
        printf(">>ACE  fail to get ace ticket, ret: %d\n", ret);
        return false;
    }

    printf(">>ACE Succ to get ace ticket, len=%u, content=%s\n", aceTicket.ticket_len_, aceTicket.ticket_);

    //get light feature
	AceSdkLightFeatureRequest lightFeatureReq;
	memset(&lightFeatureReq, 0, sizeof(AceSdkLightFeatureRequest));
	snprintf(lightFeatureReq.client_version_, sizeof(lightFeatureReq.client_version_) - 1, "%s", "1.0.0");

	memset(&lightFeature, 0, sizeof(AceSdkLightFeatureResponse));
	ret = ace_sdk_server_get_light_feature(&account, &lightFeatureReq, &lightFeature);
    if (ret != 0)
    {
        printf(">>ACE  fail to get ace ticket, ret: %d\n", ret);
        return false;
    }
	printf(">>ACE Succ to get light feature\n");
    return true;
}

void AceInterface::onPlayerLogout(const AceSdkAccount& account)
{
    AceSdkResult ret = ace_sdk_server_delete_player(&account);
    if (ret != ACE_SDK_RESULT_OK)
    {
        printf(">>ACE fail to call ace_sdk_server_delete_player, ret : %d\n", ret);
    }
}

void AceInterface::onReceiveClientTickPacket(const AceSdkAccount& account, const uint8_t* packet_buffer, uint32_t packet_len)
{
    AceSdkServerPacket serverPacket;
	memset(&serverPacket, 0, sizeof(AceSdkServerPacket));

    memcpy(&(serverPacket.account_), &account, sizeof(AceSdkAccount));
	serverPacket.packet_len_ = packet_len;
	memcpy(serverPacket.packet_buffer_, packet_buffer, packet_len);

    AceSdkResult ret = ace_sdk_server_on_packet_received(&serverPacket);
    if (ret != ACE_SDK_RESULT_OK)
    {
        printf(">>ACE fail to call ace_sdk_server_on_packet_received, ret : %d\n", ret);
	}
}

void AceInterface::getServerTickPacket(AceSdkServerPacketList& serverTickPackets)
{
    memset(&serverTickPackets, 0, sizeof(AceSdkServerPacketList));
    AceSdkResult ret = ace_sdk_server_get_packet(&serverTickPackets);
    if (ret != ACE_SDK_RESULT_OK)
    {
        printf(">>ACE fail to call ace_sdk_server_get_packets, ret : %d\n", ret);
	}
    if (serverTickPackets.packet_num_ > 0)
    {
        printf(">>ACE call ace_sdk_server_on_packet_received, packet_num : %d\n", serverTickPackets.packet_num_);
    }
}

void AceInterface::keepClientAlive(const AceSdkAccount& account)
{
    AceSdkResult ret = ace_sdk_server_keep_alive_player(&account);
    if (ret != ACE_SDK_RESULT_OK)
    {
        printf(">>ACE fail to call ace_sdk_server_keep_alive, ret : %d\n", ret);
	}
}

bool AceInterface::onUGCRequest(const AceSdkAccount& account, int32_t ugcSceneID, const char* content, 
		int32_t ugcCtxID, int32_t clientID)
{
	AceSdkBatchMultiTextInputInfo textInputInfo;
	memset(&textInputInfo, 0, sizeof(AceSdkBatchMultiTextInputInfo));

	textInputInfo.account_info_ = account;
	snprintf(textInputInfo.role_name_, ACE_SDK_UIC_MAX_ROLE_NAME_LEN - 1, "qq_%s", account.account_);
    textInputInfo.multi_text_cnt_ = 1;
    textInputInfo.multi_text_array_[0].scene_id_ = ugcSceneID;
    snprintf(textInputInfo.multi_text_array_[0].text_, ACE_SDK_UIC_MAX_MESSAGE_LEN, "%s", content);

    AceTextJudgeCallbackData callbackData;
	memset(&callbackData, 0, sizeof(AceTextJudgeCallbackData));
	callbackData.clientID = clientID;
	callbackData.ugcClientCtxID = ugcCtxID;
	textInputInfo.callback_len_ = sizeof(AceTextJudgeCallbackData);
	memcpy(textInputInfo.callback_data_, &callbackData, sizeof(AceTextJudgeCallbackData));

	AceSdkResult ret = ace_sdk_server_judge_batch_multi_text(&textInputInfo);
    if (ret != ACE_SDK_RESULT_OK)
    {
        printf(">>ACE fail to call ace_sdk_server_judge_batch_multi_text, ret : %d\n", ret);
        return false;
    }

    printf(">>ACE call ace_sdk_server_judge_batch_multi_text\n");
    return true;
}

int AceInterface::onAceTextJudgeCallback(const AceSdkUicJudgeResultInfoBatchMultiText* result_info)
{
    if (result_info == nullptr) return 0;
    if (result_info->callback_len_ != sizeof(AceTextJudgeCallbackData))
    {
		printf(">>ACE text judge callback data length mismatch, len : %d\n", result_info->callback_len_);
        return 0;
    }
    printf(">>ACE text judge callback received, err_code : %d, multext_result_cnt : %d\n", 
		result_info->err_code_, result_info->multext_result_cnt_);

    AceTextJudgeCallbackData callbackData;
	memcpy(&callbackData, result_info->callback_data_, sizeof(AceTextJudgeCallbackData));

	GameServer::getSingleton()->onUGCCallback(callbackData.clientID, callbackData.ugcClientCtxID,  result_info);

    return 0;
}