#include "GroupManager.h"
#include <libopenimsdk.h>
#include "../NimResult.h"
#include "../ZegoDataUtils.h"
#include "ConstDefine.h"
#include "Listen.h"

GroupManagerService::GroupManagerService() {
    m_serviceName = "groupManager";
}

void GroupManagerService::onMethodCalled(
    const std::string& method,
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (method == "setGroupListener") {
        setGroupListener(arguments, result);
    } else if (method == "inviteUserToGroup") {
        inviteUserToGroup(arguments, result);
    } else if (method == "kickGroupMember") {
        kickGroupMember(arguments, result);
    } else if (method == "getGroupMembersInfo") {
        getGroupMembersInfo(arguments, result);
    } else if (method == "getGroupMemberList") {
        getGroupMemberList(arguments, result);
    } else if (method == "getJoinedGroupList") {
        getJoinedGroupList(arguments, result);
    } else if (method == "getJoinedGroupListPage") {
        getJoinedGroupListPage(arguments, result);
    } else if (method == "createGroup") {
        createGroup(arguments, result);
    } else if (method == "setGroupInfo") {
        setGroupInfo(arguments, result);
    } else if (method == "getGroupsInfo") {
        getGroupsInfo(arguments, result);
    } else if (method == "joinGroup") {
        joinGroup(arguments, result);
    } else if (method == "quitGroup") {
        quitGroup(arguments, result);
    } else if (method == "transferGroupOwner") {
        transferGroupOwner(arguments, result);
    } else if (method == "getGroupApplicationListAsRecipient") {
        getGroupApplicationListAsRecipient(arguments, result);
    } else if (method == "getGroupApplicationListAsApplicant") {
        getGroupApplicationListAsApplicant(arguments, result);
    } else if (method == "acceptGroupApplication") {
        acceptGroupApplication(arguments, result);
    } else if (method == "refuseGroupApplication") {
        refuseGroupApplication(arguments, result);
    } else if (method == "dismissGroup") {
        dismissGroup(arguments, result);
    } else if (method == "changeGroupMute") {
        changeGroupMute(arguments, result);
    } else if (method == "changeGroupMemberMute") {
        changeGroupMemberMute(arguments, result);
    } else if (method == "searchGroups") {
        searchGroups(arguments, result);
    } else if (method == "getGroupMemberListByJoinTimeFilter") {
        getGroupMemberListByJoinTimeFilter(arguments, result);
    } else if (method == "getGroupMemberOwnerAndAdmin") {
        getGroupMemberOwnerAndAdmin(arguments, result);
    } else if (method == "searchGroupMembers") {
        searchGroupMembers(arguments, result);
    } else if (method == "setGroupMemberInfo") {
        setGroupMemberInfo(arguments, result);
    } else if (method == "isJoinGroup") {
        isJoinGroup(arguments, result);
    } else if (method == "getUsersInGroup") {
        getUsersInGroup(arguments, result);
    } else {
        result->NotImplemented();
    }
}

void GroupManagerService::setGroupListener(
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        set_group_listener(NewGroupListenerCallBack());
        result->Success(flutter::EncodableValue());
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void GroupManagerService::inviteUserToGroup(
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
        auto groupID = zego_value_get_string(arguments->at(flutter::EncodableValue("groupID")));
        auto reason = zego_value_get_string(arguments->at(flutter::EncodableValue("reason")));
        auto userIDList = zego_value_get_string(arguments->at(flutter::EncodableValue("userIDList")));
        char* operationID_cs = const_cast<char*>(operationID.c_str());
        char* groupID_cs = const_cast<char*>(groupID.c_str());
        char* reason_cs = const_cast<char*>(reason.c_str());
        char* userIDList_cs = const_cast<char*>(userIDList.c_str());

        invite_user_to_group(NewBaseCallBack(result), operationID_cs, groupID_cs, reason_cs, userIDList_cs);
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void GroupManagerService::kickGroupMember(
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
        auto groupID = zego_value_get_string(arguments->at(flutter::EncodableValue("groupID")));
        auto reason = zego_value_get_string(arguments->at(flutter::EncodableValue("reason")));
        auto userIDList = zego_value_get_string(arguments->at(flutter::EncodableValue("userIDList")));
        char* operationID_cs = const_cast<char*>(operationID.c_str());
        char* groupID_cs = const_cast<char*>(groupID.c_str());
        char* reason_cs = const_cast<char*>(reason.c_str());
        char* userIDList_cs = const_cast<char*>(userIDList.c_str());

        kick_group_member(NewBaseCallBack(result), operationID_cs, groupID_cs, reason_cs, userIDList_cs);
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void GroupManagerService::getGroupMembersInfo(
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
        auto groupID = zego_value_get_string(arguments->at(flutter::EncodableValue("groupID")));
        auto userIDList = zego_value_get_string(arguments->at(flutter::EncodableValue("userIDList")));
        char* operationID_cs = const_cast<char*>(operationID.c_str());
        char* groupID_cs = const_cast<char*>(groupID.c_str());
        char* userIDList_cs = const_cast<char*>(userIDList.c_str());

        get_specified_group_members_info(NewBaseCallBack(result), operationID_cs, groupID_cs, userIDList_cs);
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void GroupManagerService::getGroupMemberList(
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
        auto groupID = zego_value_get_string(arguments->at(flutter::EncodableValue("groupID")));
        auto filter = zego_value_get_int(arguments->at(flutter::EncodableValue("filter")));
        auto offset = zego_value_get_int(arguments->at(flutter::EncodableValue("offset")));
        auto count = zego_value_get_int(arguments->at(flutter::EncodableValue("count")));
        char* operationID_cs = const_cast<char*>(operationID.c_str());
        char* groupID_cs = const_cast<char*>(groupID.c_str());

        get_group_member_list(NewBaseCallBack(result), operationID_cs, groupID_cs, filter, offset, count);
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void GroupManagerService::getJoinedGroupList(
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
        char* operationID_cs = const_cast<char*>(operationID.c_str());

        get_joined_group_list(NewBaseCallBack(result), operationID_cs);
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void GroupManagerService::getJoinedGroupListPage(
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
        auto offset = zego_value_get_int(arguments->at(flutter::EncodableValue("offset")));
        auto count = zego_value_get_int(arguments->at(flutter::EncodableValue("count")));
        char* operationID_cs = const_cast<char*>(operationID.c_str());

        get_joined_group_list_page(NewBaseCallBack(result), operationID_cs, offset, count);
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void GroupManagerService::createGroup(
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
        auto groupInfo = map_2_json(*arguments);
        char* operationID_cs = const_cast<char*>(operationID.c_str());
        char* groupInfo_cs = const_cast<char*>(groupInfo.c_str());

        create_group(NewBaseCallBack(result), operationID_cs, groupInfo_cs);
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void GroupManagerService::setGroupInfo(
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
        auto groupInfo = zego_value_get_string(arguments->at(flutter::EncodableValue("groupInfo")));
        char* operationID_cs = const_cast<char*>(operationID.c_str());
        char* groupInfo_cs = const_cast<char*>(groupInfo.c_str());

        set_group_info(NewBaseCallBack(result), operationID_cs, groupInfo_cs);
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void GroupManagerService::getGroupsInfo(
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
        auto groupIDList = zego_value_get_string(arguments->at(flutter::EncodableValue("groupIDList")));
        char* operationID_cs = const_cast<char*>(operationID.c_str());
        char* groupIDList_cs = const_cast<char*>(groupIDList.c_str());

        get_specified_groups_info(NewBaseCallBack(result), operationID_cs, groupIDList_cs);
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void GroupManagerService::joinGroup(
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
        auto groupID = zego_value_get_string(arguments->at(flutter::EncodableValue("groupID")));
        auto reason = zego_value_get_string(arguments->at(flutter::EncodableValue("reason")));
        auto joinSource = zego_value_get_int(arguments->at(flutter::EncodableValue("joinSource")));
        auto ex = zego_value_get_string(arguments->at(flutter::EncodableValue("ex")));
        char* operationID_cs = const_cast<char*>(operationID.c_str());
        char* groupID_cs = const_cast<char*>(groupID.c_str());
        char* reason_cs = const_cast<char*>(reason.c_str());
        char* ex_cs = const_cast<char*>(ex.c_str());

        join_group(NewBaseCallBack(result), operationID_cs, groupID_cs, reason_cs, joinSource, ex_cs);
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void GroupManagerService::quitGroup(
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
        auto groupID = zego_value_get_string(arguments->at(flutter::EncodableValue("groupID")));
        char* operationID_cs = const_cast<char*>(operationID.c_str());
        char* groupID_cs = const_cast<char*>(groupID.c_str());

        quit_group(NewBaseCallBack(result), operationID_cs, groupID_cs);
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void GroupManagerService::transferGroupOwner(
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
        auto groupID = zego_value_get_string(arguments->at(flutter::EncodableValue("groupID")));
        auto userID = zego_value_get_string(arguments->at(flutter::EncodableValue("userID")));
        char* operationID_cs = const_cast<char*>(operationID.c_str());
        char* groupID_cs = const_cast<char*>(groupID.c_str());
        char* userID_cs = const_cast<char*>(userID.c_str());

        transfer_group_owner(NewBaseCallBack(result), operationID_cs, groupID_cs, userID_cs);
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void GroupManagerService::getGroupApplicationListAsRecipient(
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
        char* operationID_cs = const_cast<char*>(operationID.c_str());

        get_group_application_list_as_recipient(NewBaseCallBack(result), operationID_cs);
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void GroupManagerService::getGroupApplicationListAsApplicant(
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
        char* operationID_cs = const_cast<char*>(operationID.c_str());

        get_group_application_list_as_applicant(NewBaseCallBack(result), operationID_cs);
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void GroupManagerService::acceptGroupApplication(
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
        auto groupID = zego_value_get_string(arguments->at(flutter::EncodableValue("groupID")));
        auto userID = zego_value_get_string(arguments->at(flutter::EncodableValue("userID")));
        auto handleMsg = zego_value_get_string(arguments->at(flutter::EncodableValue("handleMsg")));
        char* operationID_cs = const_cast<char*>(operationID.c_str());
        char* groupID_cs = const_cast<char*>(groupID.c_str());
        char* userID_cs = const_cast<char*>(userID.c_str());
        char* handleMsg_cs = const_cast<char*>(handleMsg.c_str());

        accept_group_application(NewBaseCallBack(result), operationID_cs, groupID_cs, userID_cs, handleMsg_cs);
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void GroupManagerService::refuseGroupApplication(
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
        auto groupID = zego_value_get_string(arguments->at(flutter::EncodableValue("groupID")));
        auto userID = zego_value_get_string(arguments->at(flutter::EncodableValue("userID")));
        auto handleMsg = zego_value_get_string(arguments->at(flutter::EncodableValue("handleMsg")));
        char* operationID_cs = const_cast<char*>(operationID.c_str());
        char* groupID_cs = const_cast<char*>(groupID.c_str());
        char* userID_cs = const_cast<char*>(userID.c_str());
        char* handleMsg_cs = const_cast<char*>(handleMsg.c_str());

        refuse_group_application(NewBaseCallBack(result), operationID_cs, groupID_cs, userID_cs, handleMsg_cs);
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void GroupManagerService::dismissGroup(
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
        auto groupID = zego_value_get_string(arguments->at(flutter::EncodableValue("groupID")));
        char* operationID_cs = const_cast<char*>(operationID.c_str());
        char* groupID_cs = const_cast<char*>(groupID.c_str());

        dismiss_group(NewBaseCallBack(result), operationID_cs, groupID_cs);
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void GroupManagerService::changeGroupMute(
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
        auto groupID = zego_value_get_string(arguments->at(flutter::EncodableValue("groupID")));
        auto mute = zego_value_get_bool(arguments->at(flutter::EncodableValue("mute")));
        char* operationID_cs = const_cast<char*>(operationID.c_str());
        char* groupID_cs = const_cast<char*>(groupID.c_str());

        change_group_mute(NewBaseCallBack(result), operationID_cs, groupID_cs, mute);
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void GroupManagerService::changeGroupMemberMute(
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
        auto groupID = zego_value_get_string(arguments->at(flutter::EncodableValue("groupID")));
        auto userID = zego_value_get_string(arguments->at(flutter::EncodableValue("userID")));
        auto seconds = zego_value_get_int(arguments->at(flutter::EncodableValue("seconds")));
        char* operationID_cs = const_cast<char*>(operationID.c_str());
        char* groupID_cs = const_cast<char*>(groupID.c_str());
        char* userID_cs = const_cast<char*>(userID.c_str());

        change_group_member_mute(NewBaseCallBack(result), operationID_cs, groupID_cs, userID_cs, seconds);
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void GroupManagerService::searchGroups(
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
        auto searchParam = zego_value_get_string(arguments->at(flutter::EncodableValue("searchParam")));
        char* operationID_cs = const_cast<char*>(operationID.c_str());
        char* searchParam_cs = const_cast<char*>(searchParam.c_str());

        search_groups(NewBaseCallBack(result), operationID_cs, searchParam_cs);
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void GroupManagerService::getGroupMemberListByJoinTimeFilter(
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
        auto groupID = zego_value_get_string(arguments->at(flutter::EncodableValue("groupID")));
        auto offset = zego_value_get_int(arguments->at(flutter::EncodableValue("offset")));
        auto count = zego_value_get_int(arguments->at(flutter::EncodableValue("count")));
        auto joinTimeBegin = zego_value_get_int(arguments->at(flutter::EncodableValue("joinTimeBegin")));
        auto joinTimeEnd = zego_value_get_int(arguments->at(flutter::EncodableValue("joinTimeEnd")));
        auto excludeUserIDList = zego_value_get_string(arguments->at(flutter::EncodableValue("excludeUserIDList")));
        char* operationID_cs = const_cast<char*>(operationID.c_str());
        char* groupID_cs = const_cast<char*>(groupID.c_str());
        char* excludeUserIDList_cs = const_cast<char*>(excludeUserIDList.c_str());

        get_group_member_list_by_join_time_filter(NewBaseCallBack(result), operationID_cs, groupID_cs, offset, count, joinTimeBegin, joinTimeEnd, excludeUserIDList_cs);
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void GroupManagerService::getGroupMemberOwnerAndAdmin(
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
        auto groupID = zego_value_get_string(arguments->at(flutter::EncodableValue("groupID")));
        char* operationID_cs = const_cast<char*>(operationID.c_str());
        char* groupID_cs = const_cast<char*>(groupID.c_str());

        get_group_member_owner_and_admin(NewBaseCallBack(result), operationID_cs, groupID_cs);
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void GroupManagerService::searchGroupMembers(
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
        auto searchParam = zego_value_get_string(arguments->at(flutter::EncodableValue("searchParam")));
        char* operationID_cs = const_cast<char*>(operationID.c_str());
        char* searchParam_cs = const_cast<char*>(searchParam.c_str());

        search_group_members(NewBaseCallBack(result), operationID_cs, searchParam_cs);
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void GroupManagerService::setGroupMemberInfo(
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
        auto info = zego_value_get_string(arguments->at(flutter::EncodableValue("info")));
        char* operationID_cs = const_cast<char*>(operationID.c_str());
        char* info_cs = const_cast<char*>(info.c_str());

        set_group_member_info(NewBaseCallBack(result), operationID_cs, info_cs);
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void GroupManagerService::isJoinGroup(
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
        auto groupID = zego_value_get_string(arguments->at(flutter::EncodableValue("groupID")));
        char* operationID_cs = const_cast<char*>(operationID.c_str());
        char* groupID_cs = const_cast<char*>(groupID.c_str());

        is_join_group(NewBaseCallBack(result), operationID_cs, groupID_cs);
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void GroupManagerService::getUsersInGroup(
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
        auto groupID = zego_value_get_string(arguments->at(flutter::EncodableValue("groupID")));
        auto userIDs = zego_value_get_string(arguments->at(flutter::EncodableValue("userIDs")));
        char* operationID_cs = const_cast<char*>(operationID.c_str());
        char* groupID_cs = const_cast<char*>(groupID.c_str());
        char* userIDs_cs = const_cast<char*>(userIDs.c_str());

        get_users_in_group(NewBaseCallBack(result), operationID_cs, groupID_cs, userIDs_cs);
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}