// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.

// WARNING! Do not edit this file manually, your changes will be overwritten.

#pragma once

#ifndef QUERYOBJECT_H
#define QUERYOBJECT_H

#include "StarWarsSchema.h"

namespace graphql::learn::object {
namespace methods::QueryHas {

template 
concept getHeroWithParams = requires (TImpl impl, service::FieldParams params, std::optional episodeArg)
{
	{ service::AwaitableObject { impl.getHero(std::move(params), std::move(episodeArg)) } };
};

template 
concept getHero = requires (TImpl impl, std::optional episodeArg)
{
	{ service::AwaitableObject { impl.getHero(std::move(episodeArg)) } };
};

template 
concept getHumanWithParams = requires (TImpl impl, service::FieldParams params, response::IdType idArg)
{
	{ service::AwaitableObject { impl.getHuman(std::move(params), std::move(idArg)) } };
};

template 
concept getHuman = requires (TImpl impl, response::IdType idArg)
{
	{ service::AwaitableObject { impl.getHuman(std::move(idArg)) } };
};

template 
concept getDroidWithParams = requires (TImpl impl, service::FieldParams params, response::IdType idArg)
{
	{ service::AwaitableObject { impl.getDroid(std::move(params), std::move(idArg)) } };
};

template 
concept getDroid = requires (TImpl impl, response::IdType idArg)
{
	{ service::AwaitableObject { impl.getDroid(std::move(idArg)) } };
};

template 
concept beginSelectionSet = requires (TImpl impl, const service::SelectionSetParams params)
{
	{ impl.beginSelectionSet(params) };
};

template 
concept endSelectionSet = requires (TImpl impl, const service::SelectionSetParams params)
{
	{ impl.endSelectionSet(params) };
};

} // namespace methods::QueryHas

class [[nodiscard("unnecessary construction")]] Query final
	: public service::Object
{
private:
	[[nodiscard("unnecessary call")]] service::AwaitableResolver resolveHero(service::ResolverParams&& params) const;
	[[nodiscard("unnecessary call")]] service::AwaitableResolver resolveHuman(service::ResolverParams&& params) const;
	[[nodiscard("unnecessary call")]] service::AwaitableResolver resolveDroid(service::ResolverParams&& params) const;

	[[nodiscard("unnecessary call")]] service::AwaitableResolver resolve_typename(service::ResolverParams&& params) const;
	[[nodiscard("unnecessary call")]] service::AwaitableResolver resolve_schema(service::ResolverParams&& params) const;
	[[nodiscard("unnecessary call")]] service::AwaitableResolver resolve_type(service::ResolverParams&& params) const;

	std::shared_ptr _schema;

	struct [[nodiscard("unnecessary construction")]] Concept
	{
		virtual ~Concept() = default;

		virtual void beginSelectionSet(const service::SelectionSetParams& params) const = 0;
		virtual void endSelectionSet(const service::SelectionSetParams& params) const = 0;

		[[nodiscard("unnecessary call")]] virtual service::AwaitableObject getHero(service::FieldParams&& params, std::optional&& episodeArg) const = 0;
		[[nodiscard("unnecessary call")]] virtual service::AwaitableObject getHuman(service::FieldParams&& params, response::IdType&& idArg) const = 0;
		[[nodiscard("unnecessary call")]] virtual service::AwaitableObject getDroid(service::FieldParams&& params, response::IdType&& idArg) const = 0;
	};

	template 
	struct [[nodiscard("unnecessary construction")]] Model final
		: Concept
	{
		explicit Model(std::shared_ptr pimpl) noexcept
			: _pimpl { std::move(pimpl) }
		{
		}

		[[nodiscard("unnecessary call")]] service::AwaitableObject getHero(service::FieldParams&& params, std::optional&& episodeArg) const override
		{
			if constexpr (methods::QueryHas::getHeroWithParams)
			{
				return { _pimpl->getHero(std::move(params), std::move(episodeArg)) };
			}
			else
			{
				static_assert(methods::QueryHas::getHero, R"msg(Query::getHero is not implemented)msg");
				return { _pimpl->getHero(std::move(episodeArg)) };
			}
		}

		[[nodiscard("unnecessary call")]] service::AwaitableObject getHuman(service::FieldParams&& params, response::IdType&& idArg) const override
		{
			if constexpr (methods::QueryHas::getHumanWithParams)
			{
				return { _pimpl->getHuman(std::move(params), std::move(idArg)) };
			}
			else
			{
				static_assert(methods::QueryHas::getHuman, R"msg(Query::getHuman is not implemented)msg");
				return { _pimpl->getHuman(std::move(idArg)) };
			}
		}

		[[nodiscard("unnecessary call")]] service::AwaitableObject getDroid(service::FieldParams&& params, response::IdType&& idArg) const override
		{
			if constexpr (methods::QueryHas::getDroidWithParams)
			{
				return { _pimpl->getDroid(std::move(params), std::move(idArg)) };
			}
			else
			{
				static_assert(methods::QueryHas::getDroid, R"msg(Query::getDroid is not implemented)msg");
				return { _pimpl->getDroid(std::move(idArg)) };
			}
		}

		void beginSelectionSet(const service::SelectionSetParams& params) const override
		{
			if constexpr (methods::QueryHas::beginSelectionSet)
			{
				_pimpl->beginSelectionSet(params);
			}
		}

		void endSelectionSet(const service::SelectionSetParams& params) const override
		{
			if constexpr (methods::QueryHas::endSelectionSet)
			{
				_pimpl->endSelectionSet(params);
			}
		}

	private:
		const std::shared_ptr _pimpl;
	};

	explicit Query(std::unique_ptr pimpl) noexcept;

	[[nodiscard("unnecessary call")]] service::TypeNames getTypeNames() const noexcept;
	[[nodiscard("unnecessary call")]] service::ResolverMap getResolvers() const noexcept;

	void beginSelectionSet(const service::SelectionSetParams& params) const override;
	void endSelectionSet(const service::SelectionSetParams& params) const override;

	const std::unique_ptr _pimpl;

public:
	template 
	explicit Query(std::shared_ptr pimpl) noexcept
		: Query { std::unique_ptr { std::make_unique(std::move(pimpl)) } }
	{
	}

	[[nodiscard("unnecessary call")]] static constexpr std::string_view getObjectType() noexcept
	{
		return { R"gql(Query)gql" };
	}
};

} // namespace graphql::learn::object

#endif // QUERYOBJECT_H