WebResponse.hpp

#pragma once
 
#include "../Utils/MonoPtr.hpp"
#include "../Utils/Json.hpp"
 
#include <UnityEngine/Networking/UnityWebRequest.hpp>
#include <System/Net/HttpStatusCode.hpp>
#include <System/String.hpp>
 
#include <memory>
#include <optional>
 
namespace CP_SDK::Network {
 
    namespace _u
    {
        using namespace System::Net;
        using namespace UnityEngine::Networking;
    }
    namespace _v
    {
        using namespace CP_SDK::Utils;
    }
 
    class WebResponse
    {
        CP_SDK_NO_COPYMOVE_CTORS(WebResponse);
        CP_SDK_PRIV_TAG();
 
        private:
            _u::HttpStatusCode                  m_StatusCode;
            std::u16string                      m_ReasonPhrase;
            bool                                m_IsSuccessStatusCode;
            bool                                m_ShouldRetry;
            _v::MonoPtr<::Array<uint8_t>>       m_BodyBytes;
            std::optional<std::u16string>       m_BodyString;
 
        public:
            _u::HttpStatusCode StatusCode();
            std::u16string_view ReasonPhrase();
            bool IsSuccessStatusCode();
            bool ShouldRetry();
            _v::MonoPtr<::Array<uint8_t>>& BodyBytes();
            std::u16string_view BodyString();
 
        public:
            using Ptr = std::shared_ptr<WebResponse>;
 
            WebResponse(_u::UnityWebRequest* p_Request);
 
        public:
            bool TryAsJObject(std::shared_ptr<_v::Json::U16Document>& p_Object)
            {
                p_Object = nullptr;
 
                auto l_New = std::make_shared<_v::Json::U16Document>();
                try
                {
                    if (!_v::Json::TryFromU16String(BodyString(), *l_New.get()))
                        return false;
 
                    p_Object = l_New;
                }
                catch (const std::exception& l_Exception)
                {
                    p_Object = nullptr;
                    return false;
                }
 
                return p_Object != nullptr;
            }
 
            template<typename t_Type>
            bool TryGetObject(std::shared_ptr<t_Type>& p_Object)
            {
                p_Object = nullptr;
                try
                {
                    _v::Json::U16Document l_Document;
                    _v::Json::TryFromU16String(BodyString(), l_Document);
 
                    p_Object = std::make_shared<t_Type>();
                    p_Object->Unserialize(l_Document);
                }
                catch (const std::exception& l_Exception)
                {
                    p_Object = nullptr;
                    return false;
                }
 
                return p_Object != nullptr;
            }
 
    };
 
}