#include "ProxyClient.h"

#include "graphqlservice/internal/SortedMap.h"

#include <algorithm>

#include <array>

#include <cstddef>

#include <stdexcept>

#include <string_view>

#include <utility>

using namespace std::literals;

namespace graphql {

namespace proxy {

namespace client {

const std::string& GetRequestText() noexcept

{

static const auto s_request = R"gql(

)gql"s;

return s_request;

}

const peg::ast& GetRequestObject() noexcept

{

static const auto s_request = []() noexcept {

auto ast = peg::parseString(GetRequestText());

// This has already been validated against the schema by clientgen.

ast.validated = true;

return ast;

}();

return s_request;

}

} // namespace client

} // namespace proxy

namespace client {

using namespace proxy;

template <>

response::Value Variable<OperationType>::serialize(OperationType&& value)

{

static const std::array<std::string_view, 3> s_names = {

R"gql(QUERY)gql"sv,

R"gql(MUTATION)gql"sv,

R"gql(SUBSCRIPTION)gql"sv

};

response::Value result { response::Type::EnumValue };

result.set<std::string>(std::string { s_names[static_cast<std::size_t>(value)] });

return result;

}

template <>

response::Value Variable<QueryInput>::serialize(QueryInput&& inputValue)

{

response::Value result { response::Type::Map };

result.emplace_back(R"js(type)js"s, ModifiedVariable<OperationType>::serialize(std::move(inputValue.type)));

result.emplace_back(R"js(query)js"s, ModifiedVariable<std::string>::serialize(std::move(inputValue.query)));

result.emplace_back(R"js(operationName)js"s, ModifiedVariable<std::string>::serialize<TypeModifier::Nullable>(std::move(inputValue.operationName)));

result.emplace_back(R"js(variables)js"s, ModifiedVariable<std::string>::serialize<TypeModifier::Nullable>(std::move(inputValue.variables)));

return result;

}

static const std::array<std::pair<std::string_view, OperationType>, 3> s_valuesOperationType = {

std::make_pair(R"gql(QUERY)gql"sv, OperationType::QUERY),

std::make_pair(R"gql(MUTATION)gql"sv, OperationType::MUTATION),

std::make_pair(R"gql(SUBSCRIPTION)gql"sv, OperationType::SUBSCRIPTION)

};

template <>

OperationType Response<OperationType>::parse(response::Value&& value)

{

if (!value.maybe_enum())

{

throw std::logic_error { R"ex(not a valid OperationType value)ex" };

}

const auto result = internal::sorted_map_lookup<internal::shorter_or_less>(

s_valuesOperationType,

std::string_view { value.get<std::string>() });

if (!result)

{

throw std::logic_error { R"ex(not a valid OperationType value)ex" };

}

return *result;

}

template <>

graphql::proxy::client::query::relayQuery::Response::relay_QueryResults Response<graphql::proxy::client::query::relayQuery::Response::relay_QueryResults>::parse(response::Value&& response)

{

graphql::proxy::client::query::relayQuery::Response::relay_QueryResults result;

if (response.type() == response::Type::Map)

{

auto members = response.release<response::MapType>();

for (auto& member : members)

{

if (member.first == R"js(data)js"sv)

{

result.data = ModifiedResponse<std::string>::parse<TypeModifier::Nullable>(std::move(member.second));

continue;

}

if (member.first == R"js(errors)js"sv)

{

result.errors = ModifiedResponse<std::string>::parse<TypeModifier::Nullable, TypeModifier::List, TypeModifier::Nullable>(std::move(member.second));

continue;

}

}

}

return result;

}

} // namespace client

namespace proxy::client::query::relayQuery {

const std::string& GetOperationName() noexcept

{

static const auto s_name = R"gql(relayQuery)gql"s;

return s_name;

}

response::Value serializeVariables(Variables&& variables)

}

struct ResponseVisitor::impl

{

enum class VisitorState

};

VisitorState state { VisitorState::Start };

Response response {};

};

ResponseVisitor::ResponseVisitor() noexcept

: _pimpl { std::make_unique<impl>() }

{

}

ResponseVisitor::~ResponseVisitor()

{

}

void ResponseVisitor::add_value([[maybe_unused]] std::shared_ptr<const response::Value>&& value)

}

void ResponseVisitor::reserve([[maybe_unused]] std::size_t count)

}

void ResponseVisitor::start_object()

}

void ResponseVisitor::add_member([[maybe_unused]] std::string&& key)

}

void ResponseVisitor::end_object()

}

void ResponseVisitor::start_array()

}

void ResponseVisitor::end_array()

}

void ResponseVisitor::add_null()

}

void ResponseVisitor::add_string([[maybe_unused]] std::string&& value)

}

void ResponseVisitor::add_enum([[maybe_unused]] std::string&& value)

}

void ResponseVisitor::add_id([[maybe_unused]] response::IdType&& value)

}

void ResponseVisitor::add_bool([[maybe_unused]] bool value)

}

void ResponseVisitor::add_int([[maybe_unused]] int value)

}

void ResponseVisitor::add_float([[maybe_unused]] double value)

}

void ResponseVisitor::complete()

{

_pimpl->state = impl::VisitorState::Complete;

}

Response ResponseVisitor::response()

}

Response parseResponse(response::Value&& response)

}

[[nodiscard("unnecessary call")]] const std::string& Traits::GetRequestText() noexcept

{

return client::GetRequestText();

}

[[nodiscard("unnecessary call")]] const peg::ast& Traits::GetRequestObject() noexcept

{

return client::GetRequestObject();

}

[[nodiscard("unnecessary call")]] const std::string& Traits::GetOperationName() noexcept

{

return relayQuery::GetOperationName();

}

[[nodiscard("unnecessary conversion")]] response::Value Traits::serializeVariables(Traits::Variables&& variables)

{

return relayQuery::serializeVariables(std::move(variables));

}

[[nodiscard("unnecessary conversion")]] Traits::Response Traits::parseResponse(response::Value&& response)

{

return relayQuery::parseResponse(std::move(response));

}

} // namespace proxy::client::query::relayQuery

} // namespace graphql