o3de/Gems/Twitch/Code/Source/TwitchREST.cpp

/*
 * Copyright (c) Contributors to the Open 3D Engine Project.
 * For complete copyright and license terms please see the LICENSE at the root of this distribution.
 *
 * SPDX-License-Identifier: Apache-2.0 OR MIT
 *
 */

#include <AzCore/std/time.h>
#include <AzCore/std/smart_ptr/make_shared.h>
#include <AzCore/std/string/conversions.h>
#include <Twitch/TwitchBus.h>
#include <HttpRequestor/HttpRequestorBus.h>
#include "TwitchREST.h"

namespace Twitch
{
    ITwitchRESTPtr ITwitchREST::Alloc()
    {
        return AZStd::make_shared<TwitchREST>();
    }

    const char * TwitchREST::kProtocol("https");
    const char * TwitchREST::kBasePath("api.twitch.tv");
    const char * TwitchREST::kVer("v5");
    const char * TwitchREST::kKraken("kraken");
    const char * TwitchREST::kAuthType("OAuth ");
    const char * TwitchREST::kAcceptType("application/vnd.twitchtv.v5+json");

    TwitchREST::TwitchREST()
    {
        // all names listed below comply with Twitch's naming rules, Do not change the case or 
        // spelling of the return values! Also do not put in the ::Unknown strings, placehold only!

        m_availabilityMap[PresenceAvailability::Idle]           = "idle";
        m_availabilityMap[PresenceAvailability::Online]         = "online";
        
        m_activityTypeMap[PresenceActivityType::Watching]       = "watching";
        m_activityTypeMap[PresenceActivityType::Playing]        = "playing";
        m_activityTypeMap[PresenceActivityType::Broadcasting]   = "broadcasting";
    }

    void TwitchREST::FlushEvents()
    {
        TwitchNotifyBus::ExecuteQueuedEvents();
    }

    void TwitchREST::GetUser(ReceiptID& receipt)
    {
        AZStd::string url( BuildKrakenURL("user") );

        AddHTTPRequest(url, Aws::Http::HttpMethod::HTTP_GET, GetDefaultHeaders(), [receipt, this](const Aws::Utils::Json::JsonView& json, Aws::Http::HttpResponseCode httpCode)
        {
            ResultCode rc(ResultCode::TwitchRESTError);
            UserInfo userinfo;

            if (httpCode == Aws::Http::HttpResponseCode::OK)
            {
                rc = ResultCode::Success;

                SafeGetUserInfo(userinfo, json);
            }

            TwitchNotifyBus::QueueBroadcast(&TwitchNotifyBus::Events::GetUser, UserInfoValue(userinfo, receipt, rc));
        });
    }
    
    void TwitchREST::ResetFriendsNotificationCount(const ReceiptID& receipt, const AZStd::string& friendID)
    {
        AZStd::string url( BuildBaseURL("users", friendID) + "/friends/notifications");
        
        AddHTTPRequest(url, Aws::Http::HttpMethod::HTTP_DELETE, GetDefaultHeaders(), [receipt](const Aws::Utils::Json::JsonView& /*json*/, Aws::Http::HttpResponseCode httpCode)
        {
            ResultCode rc(ResultCode::TwitchRESTError);

            if (httpCode == Aws::Http::HttpResponseCode::NO_CONTENT)    // 204: NO_CONTENT The server successfully processed the request and is not returning any content
            {
                rc = ResultCode::Success;
            }
        
            TwitchNotifyBus::QueueBroadcast(&TwitchNotifyBus::Events::ResetFriendsNotificationCountNotify, Int64Value(static_cast<AZ::s64>(httpCode), receipt, rc));
        });
    }
    

    void TwitchREST::GetFriendNotificationCount(const ReceiptID& receipt, const AZStd::string& friendID)
    {
        AZStd::string url(BuildBaseURL("users", friendID) + "/friends/notifications");

        AddHTTPRequest(url, Aws::Http::HttpMethod::HTTP_GET, GetDefaultHeaders(), [receipt](const Aws::Utils::Json::JsonView& json, Aws::Http::HttpResponseCode httpCode)
        {
            ResultCode rc(ResultCode::TwitchRESTError);
            AZ::s64 count = 0;

            if (httpCode == Aws::Http::HttpResponseCode::OK)
            {
                rc = ResultCode::Success;
                count = json.GetInteger("count");
            }
            else
            {
                count = static_cast<AZ::s64>(httpCode);
            }

            TwitchNotifyBus::QueueBroadcast(&TwitchNotifyBus::Events::GetFriendNotificationCount, Int64Value(count, receipt, rc));
        });
    }

    void TwitchREST::GetFriendRecommendations(const ReceiptID& receipt, const AZStd::string& friendID)
    {
        AZStd::string url(BuildBaseURL("users", friendID) + "/friends/recommendations");

        AddHTTPRequest(url, Aws::Http::HttpMethod::HTTP_GET, GetDefaultHeaders(), [receipt, this](const Aws::Utils::Json::JsonView& jsonDoc, Aws::Http::HttpResponseCode httpCode)
        {
            ResultCode rc(ResultCode::TwitchRESTError);
            FriendRecommendationList returnRecommendations;
            
            if (httpCode == Aws::Http::HttpResponseCode::OK)
            {
                rc = ResultCode::Success;
                Aws::Utils::Array<Aws::Utils::Json::JsonView> recommendations = jsonDoc.GetArray("recommendations");

                for(size_t index =0; index<recommendations.GetLength(); index++)
                {
                    FriendRecommendation fr;

                    Aws::Utils::Json::JsonView item = recommendations.GetItem(index);

                    fr.Reason = item.GetString("reason").c_str();
                    SafeGetUserInfoFromUserContainer(fr.User, item);

                    returnRecommendations.push_back(fr);
                }
            }

            TwitchNotifyBus::QueueBroadcast(&TwitchNotifyBus::Events::GetFriendRecommendations, FriendRecommendationValue(returnRecommendations, receipt, rc));
        });
    }

    void TwitchREST::GetFriends(const ReceiptID& receipt, const AZStd::string& friendID, const AZStd::string& cursor)
    {
        AZStd::string url(BuildBaseURL("users", friendID) + "/friends/relationships");

        HttpRequestor::Headers headers( GetDefaultHeaders() );

        AddToHeader(headers, "limit", 256ULL);

        if( !cursor.empty() )
            AddToHeader(headers, "cursor", cursor);
        
        AddHTTPRequest(url, Aws::Http::HttpMethod::HTTP_GET, headers, [receipt, this](const Aws::Utils::Json::JsonView& jsonDoc, Aws::Http::HttpResponseCode httpCode)
        {
            ResultCode rc(ResultCode::TwitchRESTError);
            GetFriendReturn friendReturn;

            if (httpCode == Aws::Http::HttpResponseCode::OK)
            {
                rc = ResultCode::Success;

                SafeGetJSONString(friendReturn.Cursor, "cursor", jsonDoc);

                Aws::Utils::Array<Aws::Utils::Json::JsonView> recommendations = jsonDoc.GetArray("friends");

                for (size_t index = 0; index < recommendations.GetLength(); index++)
                {
                    FriendInfo fi;

                    Aws::Utils::Json::JsonView item = recommendations.GetItem(index);

                    SafeGetJSONString(fi.CreatedDate, "created_at", item);
                    SafeGetUserInfoFromUserContainer(fi.User, item);

                    friendReturn.Friends.push_back(fi);
                }
            }

            TwitchNotifyBus::QueueBroadcast(&TwitchNotifyBus::Events::GetFriends, GetFriendValue(friendReturn, receipt, rc));
        });
    }

    void TwitchREST::GetFriendStatus(const ReceiptID& receipt, const AZStd::string& sourceFriendID, const AZStd::string& targetFriendID)
    {
        AZStd::string url(BuildBaseURL("users", sourceFriendID) + "/friends/relationships/" + targetFriendID);

        AddHTTPRequest(url, Aws::Http::HttpMethod::HTTP_GET, GetDefaultHeaders(), [receipt, this](const Aws::Utils::Json::JsonView& jsonDoc, Aws::Http::HttpResponseCode httpCode)
        {
            ResultCode rc(ResultCode::TwitchRESTError);
            FriendStatus friendStatus;

            if (httpCode == Aws::Http::HttpResponseCode::OK)
            {
                rc = ResultCode::Success;

                SafeGetJSONString(friendStatus.Status, "status", jsonDoc);
                SafeGetUserInfoFromUserContainer(friendStatus.User, jsonDoc);
            }

            TwitchNotifyBus::QueueBroadcast(&TwitchNotifyBus::Events::GetFriendStatus, FriendStatusValue(friendStatus, receipt, rc));
        });
    }

    void TwitchREST::AcceptFriendRequest(const ReceiptID& receipt, const AZStd::string& friendID)
    {
        AZStd::string url(BuildBaseURL("users") + "/friends/relationships/" + friendID);

        AddHTTPRequest(url, Aws::Http::HttpMethod::HTTP_PUT, GetDefaultHeaders(), [receipt]([[maybe_unused]] const Aws::Utils::Json::JsonView& jsonDoc, Aws::Http::HttpResponseCode httpCode)
        {
            ResultCode rc(ResultCode::TwitchRESTError);

            if (httpCode == Aws::Http::HttpResponseCode::CREATED)
            {
                rc = ResultCode::Success;
            }

            TwitchNotifyBus::QueueBroadcast(&TwitchNotifyBus::Events::AcceptFriendRequest, Int64Value(static_cast<AZ::s64>(httpCode), receipt, rc));
        });
    }


    void TwitchREST::GetFriendRequests(const ReceiptID& receipt, const AZStd::string& cursor)
    {
        AZStd::string url(BuildBaseURL("users") + "/friends/requests");

        HttpRequestor::Headers headers(GetDefaultHeaders());

        AddToHeader(headers, "limit", 512ULL);

        if (!cursor.empty())
            AddToHeader(headers, "cursor", cursor);

        AddHTTPRequest(url, Aws::Http::HttpMethod::HTTP_GET, headers, [receipt, this](const Aws::Utils::Json::JsonView& jsonDoc, Aws::Http::HttpResponseCode httpCode)
        {
            ResultCode rc(ResultCode::TwitchRESTError);
            FriendRequestResult requestResult;

            if (httpCode == Aws::Http::HttpResponseCode::OK)
            {
                rc = ResultCode::Success;

                SafeGetJSONString(requestResult.Cursor, "cursor", jsonDoc);
                SafeGetJSONu64(requestResult.Total, "total", jsonDoc);

                Aws::Utils::Array<Aws::Utils::Json::JsonView> recommendations = jsonDoc.GetArray("requests");

                for (size_t index = 0; index < recommendations.GetLength(); index++)
                {
                    Aws::Utils::Json::JsonView item = recommendations.GetItem(index);
                    FriendRequest fr;

                    SafeGetJSONbool(fr.IsRecommended, "is_recommended", item);
                    SafeGetJSONbool(fr.IsStranger, "is_stranger", item);
                    SafeGetJSONString(fr.NonStrangerReason, "non_stranger_reason", item);
                    SafeGetJSONString(fr.RequestedDate, "requested_at", item);
                    SafeGetUserInfoFromUserContainer(fr.User, item);

                    requestResult.Requests.push_back(fr);
                }
            }
            
            TwitchNotifyBus::QueueBroadcast(&TwitchNotifyBus::Events::GetFriendRequests, FriendRequestValue(requestResult, receipt, rc));
        });
    }

    void TwitchREST::CreateFriendRequest(const ReceiptID& receipt, const AZStd::string& friendID)
    {
        AZStd::string url(BuildBaseURL("users") + "/friends/requests/" + friendID);

        AddHTTPRequest(url, Aws::Http::HttpMethod::HTTP_PUT, GetDefaultHeaders(), [receipt]([[maybe_unused]] const Aws::Utils::Json::JsonView& jsonDoc, Aws::Http::HttpResponseCode httpCode)
        {
            ResultCode rc(ResultCode::TwitchRESTError);

            if (httpCode == Aws::Http::HttpResponseCode::CREATED)
            {
                rc = ResultCode::Success;
            }

            TwitchNotifyBus::QueueBroadcast(&TwitchNotifyBus::Events::CreateFriendRequest, Int64Value(static_cast<AZ::s64>(httpCode), receipt, rc));
        });
    }

    void TwitchREST::DeclineFriendRequest(const ReceiptID& receipt, const AZStd::string& friendID)
    {
        AZStd::string url(BuildBaseURL("users") + "/friends/requests/" + friendID);

        AddHTTPRequest(url, Aws::Http::HttpMethod::HTTP_DELETE, GetDefaultHeaders(), [receipt]([[maybe_unused]] const Aws::Utils::Json::JsonView& jsonDoc, Aws::Http::HttpResponseCode httpCode)
        {
            ResultCode rc(ResultCode::TwitchRESTError);

            if (httpCode == Aws::Http::HttpResponseCode::CREATED)
            {
                rc = ResultCode::Success;
            }

            TwitchNotifyBus::QueueBroadcast(&TwitchNotifyBus::Events::DeclineFriendRequest, Int64Value(static_cast<AZ::s64>(httpCode), receipt, rc));
        });
    }
    
    void TwitchREST::UpdatePresenceStatus(const ReceiptID& receipt, PresenceAvailability availability, PresenceActivityType activityType, const AZStd::string& gameContext)
    {
        // we need to get the twitch channel this user is on, and that call requires its own receipt
        ReceiptID gcReceipt;

        InternalGetChannel(gcReceipt, [receipt, availability, activityType, gameContext, this](const ChannelInfo& channelInfo, const ReceiptID&, ResultCode)
        {
            AZStd::string url(BuildBaseURL("users") + "/status");

            HttpRequestor::Headers headers(GetDefaultHeaders());
            AddToHeader(headers, "Content-Type", "application/json");
        
            AZStd::string appID;
            TwitchRequestBus::BroadcastResult(appID, &TwitchRequests::GetApplicationID);

            Aws::Utils::Json::JsonValue jsonActivity;
            jsonActivity.WithString("type", GetPresenceActivityTypeName(activityType).c_str());
            jsonActivity.WithString("channel_id", channelInfo.Id.c_str());
            jsonActivity.WithString("game_id", appID.c_str());

            if ( (activityType == PresenceActivityType::Playing) && !gameContext.empty() )
            {
                Aws::Utils::Json::JsonValue jsonGameContext(Aws::String(gameContext.c_str()));

                if( jsonGameContext.WasParseSuccessful() )
                    jsonActivity.WithObject("game_context", AZStd::move(jsonGameContext));
            }
        
            AZStd::string sessionID;
            TwitchRequestBus::BroadcastResult(sessionID, &TwitchRequests::GetSessionID);

            Aws::Utils::Json::JsonValue jsonBody;
            jsonBody.WithString("session_id", sessionID.c_str());
            jsonBody.WithString("availability", GetPresenceAvailabilityName(availability).c_str());
            jsonBody.WithObject("activities", AZStd::move(jsonActivity));

            Aws::String body(jsonBody.View().WriteCompact());
                
            AddHTTPRequest(url, Aws::Http::HttpMethod::HTTP_POST, headers, body.c_str(), [receipt, this](const Aws::Utils::Json::JsonView& jsonDoc, Aws::Http::HttpResponseCode httpCode)
            {
                ResultCode rc(ResultCode::TwitchRESTError);
                AZ::s64 pollIntervalSeconds = 0;

                if (httpCode == Aws::Http::HttpResponseCode::OK)
                {
                    rc = ResultCode::Success;

                    SafeGetJSONs64(pollIntervalSeconds, "poll_interval_seconds", jsonDoc);
                }
                else
                {
                    pollIntervalSeconds = static_cast<AZ::s64>(httpCode);
                }

                TwitchNotifyBus::QueueBroadcast(&TwitchNotifyBus::Events::UpdatePresenceStatus, Int64Value(pollIntervalSeconds, receipt, rc));
            });
        });
    }

    void TwitchREST::GetPresenceStatusofFriends(const ReceiptID& receipt)
    {
        AZStd::string url(BuildBaseURL("users") + "/status/friends");

        AddHTTPRequest(url, Aws::Http::HttpMethod::HTTP_GET, GetDefaultHeaders(), [receipt, this](const Aws::Utils::Json::JsonView& jsonDoc, Aws::Http::HttpResponseCode httpCode)
        {
            ResultCode rc(ResultCode::TwitchRESTError);
            PresenceStatusList statusList;

            if (httpCode == Aws::Http::HttpResponseCode::OK)
            {
                rc = ResultCode::Success;

                Aws::Utils::Array<Aws::Utils::Json::JsonView> recommendations = jsonDoc.GetArray("data");

                for (size_t index = 0; index < recommendations.GetLength(); index++)
                {
                    Aws::Utils::Json::JsonView item = recommendations.GetItem(index);
                    PresenceStatus ps;

                    SafeGetJSONs64(ps.Index, "index", item);
                    SafeGetJSONs64(ps.UpdatedDate, "UpdatedDate", item);
                    SafeGetJSONString(ps.UserID, "user_id", item);
                    SafeGetPresenceActivityType(ps.ActivityType, item);
                    SafeGetPresenceAvailability(ps.Availability, item);

                    statusList.push_back(ps);
                }
            }
            
            TwitchNotifyBus::QueueBroadcast(&TwitchNotifyBus::Events::GetPresenceStatusofFriends, PresenceStatusValue(statusList, receipt, rc));
        });
    }

    void TwitchREST::GetPresenceSettings(const ReceiptID& receipt)
    {
        AZStd::string url(BuildBaseURL("users") + "/status/settings");

        AddHTTPRequest(url, Aws::Http::HttpMethod::HTTP_GET, GetDefaultHeaders(), [receipt, this](const Aws::Utils::Json::JsonView& jsonDoc, Aws::Http::HttpResponseCode httpCode)
        {
            ResultCode rc(ResultCode::TwitchRESTError);
            PresenceSettings presenceSettings;

            if (httpCode == Aws::Http::HttpResponseCode::OK)
            {
                rc = ResultCode::Success;

                SafeGetJSONbool(presenceSettings.IsInvisible, "is_invisible", jsonDoc);
                SafeGetJSONbool(presenceSettings.ShareActivity, "share_activity", jsonDoc);
            }

            TwitchNotifyBus::QueueBroadcast(&TwitchNotifyBus::Events::GetPresenceSettings, PresenceSettingsValue(presenceSettings, receipt, rc));
        });
    }

    void TwitchREST::UpdatePresenceSettings(const ReceiptID& receipt, bool isInvisible, bool shareActivity)
    {
        AZStd::string url(BuildBaseURL("users") + "/status/settings");

        HttpRequestor::Headers headers(GetDefaultHeaders());
        AddToHeader(headers, "Content-Type", "application/json");

        Aws::Utils::Json::JsonValue jsonBody;
        jsonBody.WithBool("is_invisible", isInvisible);
        jsonBody.WithBool("share_activity", shareActivity);

        Aws::String body(jsonBody.View().WriteCompact());

        AddHTTPRequest(url, Aws::Http::HttpMethod::HTTP_POST, headers, body.c_str(), [receipt, this](const Aws::Utils::Json::JsonView& jsonDoc, Aws::Http::HttpResponseCode httpCode)
        {
            ResultCode rc(ResultCode::TwitchRESTError);
            PresenceSettings presenceSettings;

            if (httpCode == Aws::Http::HttpResponseCode::OK)
            {
                rc = ResultCode::Success;

                SafeGetJSONbool(presenceSettings.IsInvisible, "is_invisible", jsonDoc);
                SafeGetJSONbool(presenceSettings.ShareActivity, "share_activity", jsonDoc);
            }

            TwitchNotifyBus::QueueBroadcast(&TwitchNotifyBus::Events::UpdatePresenceSettings, PresenceSettingsValue(presenceSettings, receipt, rc));
        });
    }

    void TwitchREST::GetChannel(const ReceiptID& receipt)
    {
        InternalGetChannel(receipt, [](const ChannelInfo& channelInfo, const ReceiptID& receipt, ResultCode rc)
        {
            TwitchNotifyBus::QueueBroadcast(&TwitchNotifyBus::Events::GetChannel, ChannelInfoValue(channelInfo, receipt, rc));
        });
    }

    void TwitchREST::GetChannelbyID(const ReceiptID& receipt, const AZStd::string& channelID)
    {
        AZStd::string url(BuildKrakenURL("channels") + "/" + (channelID.empty() ? "0000000" : channelID));

        AddHTTPRequest(url, Aws::Http::HttpMethod::HTTP_GET, GetClientIDHeader(), [receipt, this](const Aws::Utils::Json::JsonView& jsonDoc, Aws::Http::HttpResponseCode httpCode)
        {
            ResultCode rc(ResultCode::TwitchRESTError);
            ChannelInfo channelInfo;

            if (httpCode == Aws::Http::HttpResponseCode::OK)
            {
                rc = ResultCode::Success;

                channelInfo.NumItemsRecieved = SafeGetChannelInfo(channelInfo, jsonDoc);
            }

            TwitchNotifyBus::QueueBroadcast(&TwitchNotifyBus::Events::GetChannelbyID, ChannelInfoValue(channelInfo, receipt, rc));
        });
    }


    void TwitchREST::UpdateChannel(const ReceiptID& receipt, const ChannelUpdateInfo& channelUpdateInfo)
    {
        /*
        ** sanity check here, at least once of these must be set to update.
        */

        if( ( !channelUpdateInfo.ChannelFeedEnabled.ToBeUpdated() ) &&
            ( !channelUpdateInfo.Delay.ToBeUpdated()) &&
            ( !channelUpdateInfo.GameName.ToBeUpdated()) &&
            ( !channelUpdateInfo.Status.ToBeUpdated()))
        {
            TwitchNotifyBus::QueueBroadcast(&TwitchNotifyBus::Events::UpdateChannel, ChannelInfoValue(ChannelInfo(), receipt, ResultCode::TwitchChannelNoUpdatesToMake));
        }

        // we need to get the twitch channel this user is on, and that call requires its own receipt
        ReceiptID gcReceipt;
        
        InternalGetChannel(gcReceipt, [receipt, channelUpdateInfo, this](const ChannelInfo& channelInfo, const ReceiptID&, ResultCode)
        {
            AZStd::string url(BuildKrakenURL("channels") + "/" + channelInfo.Id);

            HttpRequestor::Headers headers(GetDefaultHeaders());                  
            AddToHeader(headers, "Content-Type", "application/json");

            Aws::Utils::Json::JsonValue jsonChannel;

            if (channelUpdateInfo.Status.ToBeUpdated())
            {
                jsonChannel.WithString("status", channelUpdateInfo.Status.GetValue().c_str());
            }

            if (channelUpdateInfo.GameName.ToBeUpdated())
            {
                jsonChannel.WithString("game", channelUpdateInfo.GameName.GetValue().c_str());
            }
        
            if (channelUpdateInfo.Delay.ToBeUpdated())
            {
                jsonChannel.WithString("delay", AZStd::to_string(channelUpdateInfo.Delay.GetValue()).c_str());
            }
            
            if (channelUpdateInfo.ChannelFeedEnabled.ToBeUpdated())
            {
                jsonChannel.WithBool("channel_feed_enabled", channelUpdateInfo.ChannelFeedEnabled.GetValue());
            }
            
            Aws::Utils::Json::JsonValue jsonBody;

            jsonBody.WithObject("channel", AZStd::move(jsonChannel));

            Aws::String body(jsonBody.View().WriteCompact());

            AddHTTPRequest(url, Aws::Http::HttpMethod::HTTP_PUT, headers, body.c_str(), [receipt, this](const Aws::Utils::Json::JsonView& jsonDoc, Aws::Http::HttpResponseCode httpCode)
            {
                ResultCode rc(ResultCode::TwitchRESTError);
                ChannelInfo retChannelInfo;

                if (httpCode == Aws::Http::HttpResponseCode::OK)
                {
                    rc = ResultCode::Success;

                    retChannelInfo.NumItemsRecieved = SafeGetChannelInfo(retChannelInfo, jsonDoc);
                }

                TwitchNotifyBus::QueueBroadcast(&TwitchNotifyBus::Events::UpdateChannel, ChannelInfoValue(retChannelInfo, receipt, rc));
            });
        });
    }

    void TwitchREST::GetChannelEditors(ReceiptID& receipt, const AZStd::string& channelID)
    {
        AZStd::string url(BuildKrakenURL("channels") + "/" + channelID + "/editors");

        AddHTTPRequest(url, Aws::Http::HttpMethod::HTTP_GET, GetDefaultHeaders(), [receipt, this](const Aws::Utils::Json::JsonView& jsonDoc, Aws::Http::HttpResponseCode httpCode)
        {
            ResultCode rc(ResultCode::TwitchRESTError);
            UserInfoList userList;

            if (httpCode == Aws::Http::HttpResponseCode::OK)
            {
                rc = ResultCode::Success;

                Aws::Utils::Array<Aws::Utils::Json::JsonView> jsonUserArray = jsonDoc.GetArray("users");

                for (size_t index = 0; index < jsonUserArray.GetLength(); index++)
                {
                    Aws::Utils::Json::JsonView item = jsonUserArray.GetItem(index);
                    UserInfo ui;

                    SafeGetUserInfo(ui, item);

                    userList.push_back(ui);
                }
            }

            TwitchNotifyBus::QueueBroadcast(&TwitchNotifyBus::Events::GetChannelEditors, UserInfoListValue(userList, receipt, rc));
        });
    }
    
    void TwitchREST::GetChannelFollowers(ReceiptID& receipt, const AZStd::string& channelID, const AZStd::string& cursor, AZ::u64 offset)
    {
        AZStd::string url(BuildKrakenURL("channels") + "/" + channelID + "/follows?limit=100");

        if( !cursor.empty() )
        {
            url += "&cursor=";
            url += cursor;
            url += "&offset=";
            url += AZStd::to_string(offset);
        }

        AddHTTPRequest(url, Aws::Http::HttpMethod::HTTP_GET, GetClientIDHeader(), [receipt, this](const Aws::Utils::Json::JsonView& jsonDoc, Aws::Http::HttpResponseCode httpCode)
        {
            ResultCode rc(ResultCode::TwitchRESTError);
            FollowerResult followerResult;

            if (httpCode == Aws::Http::HttpResponseCode::OK)
            {
                rc = ResultCode::Success;

                SafeGetJSONString(followerResult.Cursor, "_cursor", jsonDoc);
                SafeGetJSONu64(followerResult.Total, "_total", jsonDoc);

                Aws::Utils::Array<Aws::Utils::Json::JsonView> jsonFollowsArray = jsonDoc.GetArray("follows");

                for (size_t index = 0; index < jsonFollowsArray.GetLength(); index++)
                {
                    Aws::Utils::Json::JsonView item = jsonFollowsArray.GetItem(index);
                    Follower follower;
                    
                    SafeGetJSONString(follower.CreatedDate, "created_at", item);
                    SafeGetJSONbool(follower.Notifications, "notifications", item);
                    SafeGetUserInfoFromUserContainer(follower.User, item);

                    followerResult.Followers.push_back(follower);
                }
            }

            TwitchNotifyBus::QueueBroadcast(&TwitchNotifyBus::Events::GetChannelFollowers, FollowerResultValue(followerResult, receipt, rc));
        });
    }

    void TwitchREST::GetChannelTeams(ReceiptID& receipt, const AZStd::string& channelID)
    {
        AZStd::string url(BuildKrakenURL("channels") + "/" + channelID + "/teams");
        
        AddHTTPRequest(url, Aws::Http::HttpMethod::HTTP_GET, GetClientIDHeader(), [receipt, this](const Aws::Utils::Json::JsonView& jsonDoc, Aws::Http::HttpResponseCode httpCode)
        {
            ResultCode rc(ResultCode::TwitchRESTError);
            TeamInfoList teamInfoList;

            if (httpCode == Aws::Http::HttpResponseCode::OK)
            {
                rc = ResultCode::Success;

                Aws::Utils::Array<Aws::Utils::Json::JsonView> jsonArray = jsonDoc.GetArray("teams");

                for (size_t index = 0; index < jsonArray.GetLength(); index++)
                {
                    Aws::Utils::Json::JsonView item = jsonArray.GetItem(index);
                    TeamInfo teamInfo;

                    SafeGetTeamInfo(teamInfo, item);

                    teamInfoList.push_back(teamInfo);
                }
            }

            TwitchNotifyBus::QueueBroadcast(&TwitchNotifyBus::Events::GetChannelTeams, ChannelTeamValue(teamInfoList, receipt, rc));
        });
    }

    void TwitchREST::GetChannelSubscribers(ReceiptID& receipt, const AZStd::string& channelID, AZ::u64 offset)
    {
        AZStd::string url(BuildKrakenURL("channels") + "/" + channelID + "/subscriptions?limit=100");

        if (offset > 0)
        {
            url += "&offset=";
            url += AZStd::to_string(offset);
        }

        AddHTTPRequest(url, Aws::Http::HttpMethod::HTTP_GET, GetDefaultHeaders(), [receipt, this](const Aws::Utils::Json::JsonView& jsonDoc, Aws::Http::HttpResponseCode httpCode)
        {
            ResultCode rc(ResultCode::TwitchRESTError);
            Subscription subscription;

            if (httpCode == Aws::Http::HttpResponseCode::OK)
            {
                rc = ResultCode::Success;

                SafeGetJSONu64(subscription.Total, "_total", jsonDoc);

                Aws::Utils::Array<Aws::Utils::Json::JsonView> jsonSubscriptionsArray = jsonDoc.GetArray("subscriptions");

                for (size_t index = 0; index < jsonSubscriptionsArray.GetLength(); index++)
                {
                    Aws::Utils::Json::JsonView item = jsonSubscriptionsArray.GetItem(index);
                    SubscriberInfo si;

                    SafeGetJSONString(si.ID, "_id", item);
                    SafeGetJSONString(si.CreatedDate, "created_at", item);
                    SafeGetUserInfoFromUserContainer(si.User, item);

                    subscription.Subscribers.push_back(si);
                }
            }

            TwitchNotifyBus::QueueBroadcast(&TwitchNotifyBus::Events::GetChannelSubscribers, SubscriberValue(subscription, receipt, rc));
        });
    }

    void TwitchREST::CheckChannelSubscriptionbyUser(ReceiptID& receipt, const AZStd::string& channelID, const AZStd::string& userID)
    {
        AZStd::string url(BuildKrakenURL("channels") + "/" + channelID + "/subscriptions/" + userID);
        
        AddHTTPRequest(url, Aws::Http::HttpMethod::HTTP_GET, GetDefaultHeaders(), [receipt, this](const Aws::Utils::Json::JsonView& jsonDoc, Aws::Http::HttpResponseCode httpCode)
        {
            ResultCode rc(ResultCode::TwitchRESTError);
            SubscriberInfo si;

            if (httpCode == Aws::Http::HttpResponseCode::OK)
            {
                rc = ResultCode::Success;

                SafeGetJSONString(si.ID, "_id", jsonDoc);
                SafeGetJSONString(si.CreatedDate, "created_at", jsonDoc);
                SafeGetUserInfoFromUserContainer(si.User, jsonDoc);
            }

            TwitchNotifyBus::QueueBroadcast(&TwitchNotifyBus::Events::CheckChannelSubscriptionbyUser, SubscriberbyUserValue(si, receipt, rc));
        });
    }

    void TwitchREST::GetChannelVideos(ReceiptID& receipt, const AZStd::string& channelID, BroadCastType boradcastType, const AZStd::string& language, AZ::u64 offset)
    {
        AZStd::string url(BuildKrakenURL("channels") + "/" + channelID + "/videos?limit=100");

        if (offset > 0)
        {
            url += "&offset=";
            url += AZStd::to_string(offset);
        }

        AZStd::string bt( GetBroadCastTypeNameFromType(boradcastType) );
        if( !bt.empty() )
        {
            url += "&broadcast_type=";
            url += bt;
        }

        if( !language.empty() )
        {
            url += "&language=";
            url += language;
        
        }
        
        AddHTTPRequest(url, Aws::Http::HttpMethod::HTTP_GET, GetDefaultHeaders(), [receipt, this](const Aws::Utils::Json::JsonView& jsonDoc, Aws::Http::HttpResponseCode httpCode)
        {
            ResultCode rc(ResultCode::TwitchRESTError);
            VideoReturn videoReturn;

            if (httpCode == Aws::Http::HttpResponseCode::OK)
            {
                rc = ResultCode::Success;

                SafeGetJSONu64(videoReturn.Total, "_total", jsonDoc);

                Aws::Utils::Array<Aws::Utils::Json::JsonView> jsonVideosArray = jsonDoc.GetArray("videos");

                for (size_t index = 0; index < jsonVideosArray.GetLength(); index++)
                {
                    Aws::Utils::Json::JsonView item = jsonVideosArray.GetItem(index);
                    VideoInfo vi;

                    SafeGetJSONString(vi.ID, "_id", item);
                    SafeGetJSONu64(vi.BroadcastID, "broadcast_id", item);
                    SafeGetJSONBroadCastType(vi.Type, "broadcast_type", item);
                    SafeGetJSONVideoChannel(vi.Channel, item);
                    SafeGetJSONString(vi.CreatedDate, "created_at", item);
                    SafeGetJSONString(vi.Description, "description", item);
                    SafeGetJSONString(vi.DescriptionHTML, "description_html", item);
                    SafeGetJSONVideoFPS(vi.FPS, item);
                    SafeGetJSONString(vi.Game, "game", item);
                    SafeGetJSONString(vi.Language, "language", item);
                    SafeGetJSONu64(vi.Length, "length", item);
                    SafeGetJSONVideoPreview(vi.Preview, item);
                    SafeGetJSONString(vi.PublishedDate, "published_at", item);
                    SafeGetJSONVideoResolutions(vi.Resolutions, item);
                    SafeGetJSONString(vi.Status, "status", item);
                    SafeGetJSONString(vi.TagList, "tag_list", item);
                    SafeGetJSONVideoThumbnails(vi.Thumbnails, item);
                    SafeGetJSONString(vi.Title, "title", item);
                    SafeGetJSONString(vi.URL, "url", item);
                    SafeGetJSONString(vi.Viewable, "viewable", item);
                    SafeGetJSONString(vi.ViewableAt, "viewable_at", item);
                    SafeGetJSONu64(vi.Views, "views", item);

                    videoReturn.Videos.push_back(vi);
                }
            }

            TwitchNotifyBus::QueueBroadcast(&TwitchNotifyBus::Events::GetChannelVideos, VideoReturnValue(videoReturn, receipt, rc));
        });
    }


    void TwitchREST::StartChannelCommercial(ReceiptID& receipt, const AZStd::string& channelID, CommercialLength length)
    {
        AZStd::string url(BuildKrakenURL("channels") + "/" + channelID + "/commercial");

        HttpRequestor::Headers headers( GetDefaultHeaders() );
        AddToHeader(headers, "Content-Type", "application/json");

        Aws::Utils::Json::JsonValue jsonBody;
        jsonBody.WithInt64("duration", GetComercialLength(length) );

        Aws::String body(jsonBody.View().WriteCompact());
        
        AddHTTPRequest(url, Aws::Http::HttpMethod::HTTP_POST, headers, body.c_str(), [receipt, this](const Aws::Utils::Json::JsonView& jsonDoc, Aws::Http::HttpResponseCode httpCode)
        {
            ResultCode rc(ResultCode::TwitchRESTError);
            StartChannelCommercialResult cr;

            if (httpCode == Aws::Http::HttpResponseCode::OK)
            {
                rc = ResultCode::Success;

                SafeGetJSONu64(cr.Duration, "duration", jsonDoc);
                SafeGetJSONString(cr.Message, "message", jsonDoc);
                SafeGetJSONu64(cr.RetryAfter, "retryafter", jsonDoc);
            }

            TwitchNotifyBus::QueueBroadcast(&TwitchNotifyBus::Events::StartChannelCommercial, StartChannelCommercialValue(cr, receipt, rc));
        });
    }

    void TwitchREST::ResetChannelStreamKey(ReceiptID& receipt, const AZStd::string& channelID)
    {
        AZStd::string url(BuildKrakenURL("channels") + "/" + channelID + "/stream_key");

        AddHTTPRequest(url, Aws::Http::HttpMethod::HTTP_DELETE, GetDefaultHeaders(), [receipt, this](const Aws::Utils::Json::JsonView& jsonDoc, Aws::Http::HttpResponseCode httpCode)
        {
            ResultCode rc(ResultCode::TwitchRESTError);
            ChannelInfo ci;

            if (httpCode == Aws::Http::HttpResponseCode::OK)
            {
                rc = ResultCode::Success;

                SafeGetChannelInfo(ci, jsonDoc);
            }

            TwitchNotifyBus::QueueBroadcast(&TwitchNotifyBus::Events::ResetChannelStreamKey, ChannelInfoValue(ci, receipt, rc));
        });
    }

    bool TwitchREST::IsValidGameContext(const AZStd::string& gameContext) const
    {
        bool isValid = false;

        /*
        ** Insure gameContext is a valid JSON object, and that means there must be a string!
        */

        if( !gameContext.empty() )
        {
            Aws::Utils::Json::JsonValue json(Aws::String(gameContext.c_str()));

            isValid = json.WasParseSuccessful();
        }
        
        return isValid;
    }

    void TwitchREST::AddHTTPRequest(const AZStd::string& URI, Aws::Http::HttpMethod method, const HttpRequestor::Headers & headers, const HttpRequestor::Callback & callback)
    {
        HttpRequestor::HttpRequestorRequestBus::Broadcast(&HttpRequestor::HttpRequestorRequests::AddRequestWithHeaders, URI, method, headers, callback);
    }

    void TwitchREST::AddHTTPRequest(const AZStd::string& URI, Aws::Http::HttpMethod method, const HttpRequestor::Headers & headers, const AZStd::string& body, const HttpRequestor::Callback & callback)
    {
        HttpRequestor::HttpRequestorRequestBus::Broadcast(&HttpRequestor::HttpRequestorRequests::AddRequestWithHeadersAndBody, URI, method, headers, body, callback);
    }
        
    void TwitchREST::InternalGetChannel(const ReceiptID& receipt, const GetChannelCallback& callback)
    {
        AZStd::string url(BuildKrakenURL("channel"));

        AddHTTPRequest(url, Aws::Http::HttpMethod::HTTP_GET, GetDefaultHeaders(), [receipt, callback, this](const Aws::Utils::Json::JsonView& jsonDoc, Aws::Http::HttpResponseCode httpCode)
        {
            ResultCode rc(ResultCode::TwitchRESTError);
            ChannelInfo channelInfo;

            if (httpCode == Aws::Http::HttpResponseCode::OK)
            {
                rc = ResultCode::Success;

                channelInfo.NumItemsRecieved = SafeGetChannelInfo(channelInfo, jsonDoc);
            }

            callback(channelInfo, receipt, rc);
        });
    }

    AZStd::string TwitchREST::BuildBaseURL(const AZStd::string& family, const AZStd::string& friendID /*= ""*/) const
    {
        /*
        ** return a URL something like https://api.twitch.tv/v5/<family>/<clientid>
        */

        AZStd::string url(kProtocol);
        AZStd::string clientID;

        // if user id is empty, then get the current client id for the logged in user.
        if( friendID.empty() )
        {
            TwitchRequestBus::BroadcastResult(clientID, &TwitchRequests::GetUserID);
        }
        else
        {
            clientID = friendID;
        }

        url += "://";
        url += kBasePath;           // kBasePath("api.twitch.tv");
        url += "/";
        url += kVer;                // kVer("v5");
        url += "/";
        url += family;
        url += "/";
        url += clientID;

        return url;
    }

    AZStd::string TwitchREST::BuildKrakenURL(const AZStd::string& family) const
    {
        /*
        ** return a URL something like https://api.twitch.tv/kraken/<family>
        */

        AZStd::string url(kProtocol);

        url += "://";
        url += kBasePath;           // kBasePath("api.twitch.tv");
        url += "/";
        url += kKraken;             // kKraken("kraken");
        url += "/";
        url += family;

        return url;
    }
    
    HttpRequestor::Headers TwitchREST::GetDefaultHeaders()
    {
        HttpRequestor::Headers hdrs;
        
        AddAcceptToHeader(hdrs);
        AddOAuthtHeader(hdrs);
        AddClientIDHeader(hdrs);

        return hdrs;
    }

    HttpRequestor::Headers TwitchREST::GetClientIDHeader()
    {
        HttpRequestor::Headers hdrs;

        AddAcceptToHeader(hdrs);
        AddClientIDHeader(hdrs);

        return hdrs;
    }

    void TwitchREST::AddOAuthtHeader(HttpRequestor::Headers& headers)
    {
        AZStd::string oAuthToken;
        TwitchRequestBus::BroadcastResult(oAuthToken, &TwitchRequests::GetOAuthToken);
        headers["Authorization"] = kAuthType + oAuthToken;
    }
    
    // return the application id in a header, the rest docs refer this as the client-id, poorly named)
    void TwitchREST::AddClientIDHeader(HttpRequestor::Headers& headers)
    {
        AZStd::string appID;
        TwitchRequestBus::BroadcastResult(appID, &TwitchRequests::GetApplicationID);
        headers["Client-ID"] = appID;
    }

    void TwitchREST::AddAcceptToHeader(HttpRequestor::Headers& headers)
    {
        headers["Accept"] = kAcceptType;
    }

    void TwitchREST::AddToHeader(HttpRequestor::Headers& headers, const AZStd::string& name, const AZStd::string& key) const
    {
        headers[name] = key;
    }

    void TwitchREST::AddToHeader(HttpRequestor::Headers& headers, const AZStd::string& name, AZ::s64 key) const
    {
        AddToHeader(headers, name, AZStd::to_string(key));    
    }

    void TwitchREST::AddToHeader(HttpRequestor::Headers& headers, const AZStd::string& name, AZ::u64 key) const
    {
        AddToHeader(headers, name, AZStd::to_string(key));
    }
    
    AZ::u64 TwitchREST::SafeGetUserInfoFromUserContainer(UserInfo& userInfo, const Aws::Utils::Json::JsonView& jsonInfo) const
    {
        AZ::u64 itemCount = 0;

        if (jsonInfo.ValueExists("user") )
        {
            Aws::Utils::Json::JsonView jsonUser(jsonInfo.GetObject("user"));

            itemCount = SafeGetUserInfo(userInfo, jsonUser);
        }

        return itemCount;
    }

    AZ::u64 TwitchREST::SafeGetUserInfo(UserInfo& userInfo, const Aws::Utils::Json::JsonView& jsonInfo) const
    {
        AZ::u64 itemCount = 0;

        itemCount += SafeGetJSONString(userInfo.ID, "_id", jsonInfo);
        itemCount += SafeGetJSONString(userInfo.Bio, "bio", jsonInfo);
        itemCount += SafeGetJSONString(userInfo.CreatedDate, "created_at", jsonInfo);
        itemCount += SafeGetJSONString(userInfo.DisplayName, "display_name", jsonInfo);
        itemCount += SafeGetJSONString(userInfo.EMail, "email", jsonInfo);
        itemCount += SafeGetJSONString(userInfo.Logo, "logo", jsonInfo);
        itemCount += SafeGetJSONString(userInfo.Name, "name", jsonInfo);
        itemCount += SafeGetJSONString(userInfo.ProfileBanner, "profile_banner", jsonInfo);
        itemCount += SafeGetJSONString(userInfo.ProfileBannerBackgroundColor, "profile_banner_background_color", jsonInfo);
        itemCount += SafeGetJSONString(userInfo.Type, "type", jsonInfo);
        itemCount += SafeGetJSONString(userInfo.UpdatedDate, "updated_at", jsonInfo);
        itemCount += SafeGetJSONbool(userInfo.EMailVerified, "email_verified", jsonInfo); 
        itemCount += SafeGetJSONbool(userInfo.Partnered, "partnered", jsonInfo); 
        itemCount += SafeGetJSONbool(userInfo.TwitterConnected, "twitter_connected", jsonInfo);
        itemCount += SafeGetUserNotifications(userInfo.Notifications, jsonInfo);

        return itemCount;
    }

    bool TwitchREST::SafeGetJSONString(AZStd::string& value, const char *key, const Aws::Utils::Json::JsonView& json) const
    {
        bool success = false;
        if ( (key != nullptr)&& json.ValueExists(key) )
        {
            success = true;
            value = json.GetString(key).c_str();
        }

        return success;
    }

    bool TwitchREST::SafeGetJSONu64(AZ::u64& value, const char *key, const Aws::Utils::Json::JsonView& json) const
    {
        bool success = false;

        if ((key != nullptr)&& json.ValueExists(key))
        {
            success = true;
            value = static_cast<AZ::u64>(json.GetInt64(key));
        }

        return success;
    }
    
    bool TwitchREST::SafeGetJSONs64(AZ::s64& value, const char *key, const Aws::Utils::Json::JsonView& json) const
    {
        bool success = false;

        if ((key != nullptr)&& json.ValueExists(key))
        {
            success = true;
            value = json.GetInt64(key);
        }

        return success;
    }

    bool TwitchREST::SafeGetJSONbool(bool& value, const char *key, const Aws::Utils::Json::JsonView& json) const
    {
        bool success = false;

        if ((key != nullptr)&& json.ValueExists(key))
        {
            success = true;
            value = json.GetBool(key);
        }

        return success;
    }

    bool TwitchREST::SafeGetJSONdouble(double& value, const char* key, const Aws::Utils::Json::JsonView& json) const
    {
        bool success = false;

        if ((key != nullptr) && json.ValueExists(key))
        {
            success = true;
            value = json.GetDouble(key);
        }

        return success;
    }

    AZ::u64 TwitchREST::SafeGetUserNotifications(UserNotifications& userNotifications, const Aws::Utils::Json::JsonView& json) const
    {
        // assumes the json value contains:
        // "notifications": { "email": false, "push" : true }
        AZ::u64 numItems = 0;

        if (json.ValueExists("notifications"))
        {
            Aws::Utils::Json::JsonView jsonNotifications(json.GetObject("notifications"));

            numItems += SafeGetJSONbool(userNotifications.EMail, "email", jsonNotifications);
            numItems += SafeGetJSONbool(userNotifications.Push, "push", jsonNotifications);
        }

        return numItems;
    }
        
    bool TwitchREST::SafeGetPresenceActivityType(PresenceActivityType& activityType, const Aws::Utils::Json::JsonView& json) const
    {
        bool success = false;
        AZStd::string name;

        if (SafeGetJSONString(name, "availability", json))
        {
            activityType = GetPresenceActivityType(name);
            success = true;
        }
            
        return success;
    }

    bool TwitchREST::SafeGetPresenceAvailability(PresenceAvailability& availability, const Aws::Utils::Json::JsonView& json) const
    {
        // assumes the json doc contains
        //  "activity": { "type": "none"}
       
        bool success = false;
        
        if( json.ValueExists("activity") )
        {
            Aws::Utils::Json::JsonView jsonActivity( json.GetObject("activity") );
            AZStd::string typeName;
            if( SafeGetJSONString(typeName, "type", jsonActivity) )
            {
                availability = GetPresenceAvailability(typeName);

                success = true;
            }
        }

        return success;
    }

    AZ::u64 TwitchREST::SafeGetChannelInfo(ChannelInfo& channelInfo, const Aws::Utils::Json::JsonView& json) const
    {
        AZ::u64 itemCount = 0;
        
        itemCount += SafeGetJSONString(channelInfo.Id, "_id", json);
        itemCount += SafeGetJSONString(channelInfo.BroadcasterLanguage, "broadcaster_language", json);
        itemCount += SafeGetJSONString(channelInfo.CreatedDate, "created_at", json);
        itemCount += SafeGetJSONString(channelInfo.DisplayName, "display_name", json);
        itemCount += SafeGetJSONString(channelInfo.eMail, "email", json);                       // only returned when invoked via GetChannel
        itemCount += SafeGetJSONu64(channelInfo.NumFollowers, "followers", json);
        itemCount += SafeGetJSONString(channelInfo.GameName, "game", json);
        itemCount += SafeGetJSONString(channelInfo.Lanugage, "language", json);
        itemCount += SafeGetJSONString(channelInfo.Logo, "logo", json);
        itemCount += SafeGetJSONbool(channelInfo.Mature, "mature", json);
        itemCount += SafeGetJSONString(channelInfo.Name, "name", json);
        itemCount += SafeGetJSONbool(channelInfo.Partner, "partner", json);
        itemCount += SafeGetJSONString(channelInfo.ProfileBanner, "profile_banner", json);
        itemCount += SafeGetJSONString(channelInfo.ProfileBannerBackgroundColor, "profile_banner_background_color", json);
        itemCount += SafeGetJSONString(channelInfo.Status, "status", json);
        itemCount += SafeGetJSONString(channelInfo.StreamKey, "stream_key", json);              // only returned when invoked via GetChannel
        itemCount += SafeGetJSONString(channelInfo.UpdatedDate, "updated_at", json);
        itemCount += SafeGetJSONString(channelInfo.URL, "url", json);
        itemCount += SafeGetJSONString(channelInfo.VideoBanner, "video_banner", json);
        itemCount += SafeGetJSONu64(channelInfo.NumViews, "views", json);

        return itemCount;
    }

    AZ::u64 TwitchREST::SafeGetTeamInfo(TeamInfo& teamInfo, const Aws::Utils::Json::JsonView& json) const
    {
        AZ::u64 itemCount = 0;
    
        itemCount += SafeGetJSONString(teamInfo.ID, "_id", json);
        itemCount += SafeGetJSONString(teamInfo.Background, "background", json);
        itemCount += SafeGetJSONString(teamInfo.Banner, "banner", json);
        itemCount += SafeGetJSONString(teamInfo.CreatedDate, "created_at", json);
        itemCount += SafeGetJSONString(teamInfo.DisplayName, "display_name", json);
        itemCount += SafeGetJSONString(teamInfo.Info, "info", json);
        itemCount += SafeGetJSONString(teamInfo.Logo, "logo", json);
        itemCount += SafeGetJSONString(teamInfo.Name, "name", json);
        itemCount += SafeGetJSONString(teamInfo.UpdatedDate, "updated_at", json);
    
        return itemCount;
    }

    bool TwitchREST::SafeGetJSONBroadCastType(BroadCastType& type, [[maybe_unused]] const char*key, const Aws::Utils::Json::JsonView& json) const
    {
        bool success = false;
        AZStd::string typeName;

        if( SafeGetJSONString(typeName, "broadcast_type", json) )
        {
            BroadCastType tempType = GetBroadCastTypeFromName(typeName);

            if (tempType != BroadCastType::Default)
            {
                success = true;
                type = tempType;
            }
        }

        return success;
    }

    bool TwitchREST::SafeGetJSONVideoChannel(VideoChannelInfo& channelInfo, const Aws::Utils::Json::JsonView& json) const
    {
        // assumes the json doc contains
        //  "channel": { "_id": "20694610", "display_name" : "Towelliee", "name" : "towelliee" }
    
        bool success = false;

        if (json.ValueExists("channel"))
        {
            Aws::Utils::Json::JsonView jsonChannel(json.GetObject("channel"));
            
            SafeGetJSONString(channelInfo.ID, "_id", jsonChannel);
            SafeGetJSONString(channelInfo.DisplayName, "display_name", jsonChannel);
            SafeGetJSONString(channelInfo.Name, "name", jsonChannel);
            
            success = true;
        }

        return success;
    }

    bool TwitchREST::SafeGetJSONVideoFPS(FPSInfo & fps, const Aws::Utils::Json::JsonView& json) const
    {
        // assumes the json doc contains
        //  "fps": { "chunked": 59.9997939597903, "high" : 30.2491085172346, "low" : 30.249192959941, "medium" : 30.2491085172346, "mobile" : 30.249192959941 }

        bool success = false;

        if (json.ValueExists("fps"))
        {
            Aws::Utils::Json::JsonView jsonFPS(json.GetObject("fps"));

            SafeGetJSONdouble(fps.Chunked, "chunked", jsonFPS);
            SafeGetJSONdouble(fps.High, "high", jsonFPS);
            SafeGetJSONdouble(fps.Low, "low", jsonFPS);
            SafeGetJSONdouble(fps.Medium, "medium", jsonFPS);
            SafeGetJSONdouble(fps.Mobile, "mobile", jsonFPS);

            success = true;
        }

        return success;
    }

    bool TwitchREST::SafeGetJSONVideoPreview(PreviewInfo& preview, const Aws::Utils::Json::JsonView& json) const
    {
        // assumes the json doc contains
        //  "preview": { "large": "https://.../thumb102381501-640x360.jpg","medium" : "https://s...180.jpg","small" : "https://...81501-80x45.jpg", "template" : "https://.../thumb102381501-{width}x{height}.jpg" }
        bool success = false;

        if (json.ValueExists("preview"))
        {
            Aws::Utils::Json::JsonView jsonValue(json.GetObject("preview"));

            SafeGetJSONString(preview.Large, "large", jsonValue);
            SafeGetJSONString(preview.Medium, "medium", jsonValue);
            SafeGetJSONString(preview.Small, "small", jsonValue);
            SafeGetJSONString(preview.Template, "template", jsonValue);

            success = true;
        }

        return success;
    }

    bool TwitchREST::SafeGetJSONVideoResolutions(ResolutionsInfo& resolutions, const Aws::Utils::Json::JsonView& json) const
    {
        // assumes the json doc contains
        //  "resolutions": {"chunked": "1920x1080","high" : "1280x720","low" : "640x360","medium" : "852x480","mobile" : "400x226"}
        bool success = false;

        if (json.ValueExists("resolutions"))
        {
            Aws::Utils::Json::JsonView jsonValue(json.GetObject("resolutions"));

            SafeGetJSONString(resolutions.Chunked, "chunked", jsonValue);
            SafeGetJSONString(resolutions.High, "high", jsonValue);
            SafeGetJSONString(resolutions.Low, "low", jsonValue);
            SafeGetJSONString(resolutions.Medium, "medium", jsonValue);
            SafeGetJSONString(resolutions.Mobile, "mobile", jsonValue);

            success = true;
        }

        return success;
    }

    bool TwitchREST::SafeGetJSONVideoThumbnailInfo(ThumbnailInfo& info, const char *key, const Aws::Utils::Json::JsonView& json) const
    {
        // assumes the json doc contains
        // "<key>": [{"type": "generated", "url" : "https://.../thumb102381501-640x360.jpg"}],
        bool success = false;

        if (json.ValueExists(key))
        {
            success = true;
            Aws::Utils::Array<Aws::Utils::Json::JsonView> jsonArray( json.GetArray(key) );

            for (size_t index = 0; index < jsonArray.GetLength(); index++)
            {
                Aws::Utils::Json::JsonView item(jsonArray.GetItem(index));
                
                AZStd::string temp;
                if( SafeGetJSONString(temp, "type", item) )
                {
                    info.Type = temp;
                    temp.clear();
                }

                if (SafeGetJSONString(temp, "url", item))
                {
                    info.Url = temp;
                    temp.clear();
                }
            }
        }

        return success;
    }

    bool TwitchREST::SafeGetJSONVideoThumbnails(ThumbnailsInfo& thumbnails, const Aws::Utils::Json::JsonView& json) const
    {
        // assumes the json doc contains
        //  "thumbnails": {"large": [{"type": "...", "url" : "..."}],"medium" : [{"type": "...", "url" : "..."}],"small" : [{"type": "...", "url" : "..."}],"template" : [{"type": "...", "url" : "..."}] }
        bool success = false;

        if (json.ValueExists("thumbnails"))
        {
            Aws::Utils::Json::JsonView jsonValue(json.GetObject("thumbnails"));

            SafeGetJSONVideoThumbnailInfo(thumbnails.Large, "large", jsonValue);
            SafeGetJSONVideoThumbnailInfo(thumbnails.Medium, "medium", jsonValue);
            SafeGetJSONVideoThumbnailInfo(thumbnails.Small, "small", jsonValue);
            SafeGetJSONVideoThumbnailInfo(thumbnails.Template, "template", jsonValue);

            success = true;
        }

        return success;
    }

    bool TwitchREST::SafeGetChannelCommunityInfo(CommunityInfo & info, const Aws::Utils::Json::JsonView& json) const
    {
        // assumes the json doc contains
        // { "_id": "", "avatar_image_url": "", "cover_image_url": "", "description": "","description_html": "","language": "", "name": "", "owner_id": "", "rules": "", "rules_html": "", "summary": "" }
    
        AZ::u64 itemCount = 0;

        itemCount += SafeGetJSONString(info.ID, "_id", json);
        itemCount += SafeGetJSONString(info.AvatarImageURL, "avatar_image_url", json);
        itemCount += SafeGetJSONString(info.CoverImageURL, "cover_image_url", json);
        itemCount += SafeGetJSONString(info.Description, "description", json);
        itemCount += SafeGetJSONString(info.DescriptionHTML, "description_html", json);
        itemCount += SafeGetJSONString(info.Language, "language", json);
        itemCount += SafeGetJSONString(info.Name, "name", json);
        itemCount += SafeGetJSONString(info.OwnerID, "owner_id", json);
        itemCount += SafeGetJSONString(info.Rules, "rules", json);
        itemCount += SafeGetJSONString(info.RulesHTML, "rules_html", json);
        itemCount += SafeGetJSONString(info.Summary, "summary", json);

        return (itemCount > 0);
    }

    AZStd::string TwitchREST::GetPresenceAvailabilityName(PresenceAvailability availability) const
    {
        auto itr = m_availabilityMap.find(availability);

        if( itr != m_availabilityMap.end() )
        {
            return itr->second;
        }

        return "";
    }

    AZStd::string TwitchREST::GetPresenceActivityTypeName(PresenceActivityType activityType) const
    {
        auto itr = m_activityTypeMap.find(activityType);

        if (itr != m_activityTypeMap.end())
            return itr->second;

        return "";
    }

    PresenceAvailability TwitchREST::GetPresenceAvailability(const AZStd::string& name) const
    {
        for(const auto& i: m_availabilityMap)
            if( i.second == name)
                return i.first;
    
        return PresenceAvailability::Unknown;
    }

    PresenceActivityType TwitchREST::GetPresenceActivityType(const AZStd::string& name) const
    {
        for (const auto& i : m_activityTypeMap)
            if (i.second == name)
                return i.first;
    
        return PresenceActivityType::Unknown;
    }

    AZStd::string TwitchREST::GetBroadCastTypeNameFromType(BroadCastType type) const
    {
        AZStd::string name;
        AZ::u64 bits = static_cast<AZ::u64>(type);
        
        if( bits & static_cast<AZ::u64>(BroadCastType::Archive) )
        {
            name += "archive";
        }

        if( bits & static_cast<AZ::u64>(BroadCastType::Highlight) )
        {
            if( !name.empty() )
                name += ",";

            name += "highlight";
        }

        if (bits & static_cast<AZ::u64>(BroadCastType::Upload))
        {
            if (!name.empty())
                name += ",";

            name += "upload";
        }
           
        return name;
    }

    BroadCastType TwitchREST::GetBroadCastTypeFromName(const AZStd::string& name) const
    {
        AZ::u64 bits = 0;
    
        if ( name.find("archive") != AZStd::string::npos)
            bits |= static_cast<AZ::u64>(BroadCastType::Archive);

        if (name.find("highlight") != AZStd::string::npos)
            bits |= static_cast<AZ::u64>(BroadCastType::Highlight);

        if (name.find("upload") != AZStd::string::npos)
            bits |= static_cast<AZ::u64>(BroadCastType::Upload);

        return static_cast<BroadCastType>(bits);
    }

    AZ::u64 TwitchREST::GetComercialLength(CommercialLength length) const
    {
        AZ::u64 lengthInSeconds = 0;

        if (length == CommercialLength::T60Seconds)
            lengthInSeconds = 60;
        else if (length == CommercialLength::T90Seconds)
            lengthInSeconds = 90;
        else if (length == CommercialLength::T120Seconds)
            lengthInSeconds = 120;
        else if (length == CommercialLength::T150Seconds)
            lengthInSeconds = 150;
        else if (length == CommercialLength::T180Seconds)
            lengthInSeconds = 180;
        else
            lengthInSeconds = 30; // default is CommercialLength::T30Seconds

        return lengthInSeconds;
    }

}