larra/library/include/larra/serialization/auto.hpp

#pragma once
#include <libxml++/libxml++.h>

#include <boost/pfr.hpp>
#include <larra/serialization.hpp>
#include <larra/serialization/error.hpp>
#include <utempl/constexpr_string.hpp>
#include <utempl/tuple.hpp>
#include <utempl/utils.hpp>
#include <variant>

namespace larra::xmpp::serialization {

template <typename T>
struct Tag {};

template <typename T>
struct SerializationConfigT {
  static constexpr auto kValue = std::monostate{};
};

template <typename T>
inline constexpr auto kSerializationConfig = SerializationConfigT<T>::kValue;

template <typename T>
struct DeserializationConfigT {
  static constexpr auto kValue = kSerializationConfig<T>;
};

template <typename T>
inline constexpr auto kDeserializationConfig = DeserializationConfigT<T>::kValue;

template <typename T>
constexpr auto Parse(xmlpp::Element* element, Tag<T> = {}) -> T
  requires(!std::same_as<std::decay_t<decltype(kDeserializationConfig<T>)>, std::monostate>);

template <typename T>
constexpr auto Parse(xmlpp::Element* element, Tag<T> = {}) -> T;

template <typename T>
constexpr auto TryParse(xmlpp::Element* element, Tag<T> = {}) -> std::optional<T> {
  return Serialization<std::optional<T>>::Parse(element);
}

template <typename T>
constexpr auto Serialize(xmlpp::Element* node, const T& element) -> void
  requires(!std::same_as<std::decay_t<decltype(kSerializationConfig<T>)>, std::monostate>);

template <typename T>
constexpr auto Serialize(xmlpp::Element* node, const T& element) -> void;

template <typename T>
struct MetaInfo {
  static constexpr std::size_t kSize = boost::pfr::tuple_size_v<T>;
  template <std::size_t I>
  using TupleElement = boost::pfr::tuple_element_t<I, T>;

  template <std::size_t I>
  static constexpr std::string_view kFieldName = boost::pfr::get_name<I, T>();

  template <typename Self, std::size_t I>
  static constexpr auto Get(Self&& self) -> decltype(auto) {
    return boost::pfr::get<I>(std::forward<Self>(self));
  }
};

template <typename T>
struct DefaultValue {};

template <typename T>
  requires requires {
    { T::GetDefault() } -> std::convertible_to<T>;
  }
struct DefaultValue<T> {
  static constexpr auto Default() {
    return T::GetDefault();
  }
};

template <typename MainT, std::size_t Element>
struct FieldInfo {
  using Main = MainT;
  using Info = MetaInfo<Main>;
  using Type = Info::template TupleElement<Element>;
  static inline const std::string kName = [] {
    if constexpr(requires { Info::template TupleElement<Element>::kDefaultName; }) {
      return Info::template TupleElement<Element>::kDefaultName;
    } else {
      return static_cast<std::string>(Info::template kFieldName<Element>);
    }
  }();
  static inline const std::string kNamespace = [] {
    if constexpr(requires { Info::template TupleElement<Element>::kDefaultNamespace; }) {
      return Info::template TupleElement<Element>::kDefaultNamespace;
    } else {
      return std::string{};
    }
  }();
};

template <typename T>
struct Config {};

// GCC workaround: operator==

struct AttributeConfig {
  auto operator==(const AttributeConfig&) const -> bool = default;
  template <typename T>
  constexpr auto operator==(const Config<T>&) const -> bool {
    return false;
  }
  template <typename T>
  friend constexpr auto operator==(const Config<T>&, const AttributeConfig&) -> bool {
    return false;
  }
};

template <typename T>
constexpr auto operator==(const Config<T>&, const Config<T>&) -> bool {
  return false;
}

template <typename T>
struct Config<std::optional<T>> {
  std::optional<T> defaultValue = std::nullopt;
  bool strict = true;
  std::optional<Config<T>> main = std::nullopt;
};

namespace impl {
template <typename T>
concept HasParse = requires(xmlpp::Element* e) {
  { T::Parse(e) } -> std::same_as<T>;
};

template <typename T, typename V>
struct Config : V {
  using V::V;
  constexpr Config()
    requires HasParse<T>
      : V(::larra::xmpp::serialization::Config<T>{}) {
  }

  constexpr Config()
    requires(!HasParse<T>)
      : V(AttributeConfig{}) {
  }
  [[nodiscard]] constexpr auto Base() const -> const V& {
    return static_cast<const V&>(*this);
  }
  using type = T;
};

}  // namespace impl

template <typename T>
struct ElementConfig {
  using type = impl::Config<T, std::variant<AttributeConfig, Config<T>>>;
};

template <typename T, auto& Config, typename Info>
struct ElementSerializer {
  static constexpr auto Parse(xmlpp::Element* element) {
    auto node = element->get_first_child(Info::kName);
    if(!node) {
      throw ElementParsingError(std::format("[{}: {}] parsing error: [ Not found ]", Info::kName, nameof::nameof_full_type<T>()));
    }
    auto elementNode = dynamic_cast<xmlpp::Element*>(node);
    if(!elementNode) {
      throw ElementParsingError(std::format("[{}: {}] parsing error: [ Invalid node ]", Info::kName, nameof::nameof_full_type<T>()));
    }
    try {
      return ::larra::xmpp::serialization::Parse(elementNode, Tag<T>{});
    } catch(const std::exception& error) {
      throw ElementParsingError(std::format("[{}: {}] parsing error: [ {} ]", Info::kName, nameof::nameof_full_type<T>(), error.what()));
    }
  }

  static constexpr auto Serialize(xmlpp::Element* node, const T& element) {
    auto created = node->add_child_element(Info::kName);
    if(!node) {
      throw ElementSerializaionError(
          std::format("[{}: {}] serialization error: [ node creation failed ]", Info::kName, nameof::nameof_full_type<T>()));
    }
    try {
      ::larra::xmpp::serialization::Serialize(created, element);
    } catch(const std::exception& err) {
      throw ElementSerializaionError(
          std::format("[{}: {}] serialization error: [ {} ]", Info::kName, nameof::nameof_full_type<T>(), err.what()));
    }
  }
};

template <typename T, auto& Config, typename Info>
struct ElementSerializer<std::optional<T>, Config, Info> {
  static constexpr auto Parse(xmlpp::Element* element) -> std::optional<T> {
    return [&] {
      auto node = element->get_first_child(Info::kName);
      if(!node) {
        return std::nullopt;
      }
      auto elementNode = dynamic_cast<xmlpp::Element*>(node);
      if(!elementNode) {
        return std::nullopt;
      }
      if constexpr(Config.strict) {
        return ElementSerializer<T, Config.main, Info>::Parse(element);
      } else {
        return ElementSerializer<T, Config.main, Info>::TryParse(element);
      }
    }()
               .or_else([] {
                 return Config.defaultValue;
               });
  }
  static constexpr auto Serialize(xmlpp::Element* node, const std::optional<T>& element) {
    if(element) {
      ElementSerializer<T, Config.main, Info>::Serialize(node, *element);
    } else if(Config.defaultValue) {
      Serialize(node, Config.defaultValue);
    }
  }
};

template <typename T, auto& Config, typename Info>
struct ElementSerializer<std::vector<T>, Config, Info> {
  // TODO(sha512sum): Add Config and main options instead use Serialization<std::vector<T>>
  static constexpr auto Parse(xmlpp::Element* element) {
    try {
      return Serialization<std::vector<T>>::Parse(element);
    } catch(const std::exception& error) {
      throw ElementParsingError(
          std::format("[{}: {}] parsing error: [ {} ]", Info::kName, nameof::nameof_full_type<std::vector<T>>(), error.what()));
    }
  }
  static constexpr auto Serialize(xmlpp::Element* node, const std::vector<T>& element) {
    try {
      return Serialization<std::vector<T>>::Serialize(node, element);
    } catch(const std::exception& error) {
      throw ElementSerializaionError(
          std::format("[{}: {}] serialization error: [ {} ]", Info::kName, nameof::nameof_full_type<std::vector<T>>(), error.what()));
    }
  }
};

template <typename T, typename Info>
struct AttributeSerializer {
  static constexpr auto Parse(xmlpp::Element* element) -> T {
    auto node = element->get_attribute(Info::kName, Info::kNamespace);
    if(!node) {
      if constexpr(requires { DefaultValue<T>::Default(); }) {
        return DefaultValue<T>::Default();
      }
      throw AttributeParsingError(std::format("Attribute [{}{}{}: {}] parsing error",
                                              Info::kNamespace,
                                              Info::kNamespace == std::string{} ? "" : ":",
                                              Info::kName,
                                              nameof::nameof_full_type<T>()));
    }
    if constexpr(requires(std::string_view view) { T::Parse(view); }) {
      return T::Parse(node->get_value());
    } else {
      return node->get_value();
    }
  }
  static constexpr auto TryParse(xmlpp::Element* element) -> std::optional<T>
    requires requires { T::TryParse(std::string_view{}); }
  {
    auto node = element->get_attribute(Info::kName, Info::kNamespace);
    if(!node) {
      throw AttributeParsingError(std::format("Attribute [{}{}{}: {}] parsing error",
                                              Info::kNamespace,
                                              Info::kNamespace == std::string{} ? "" : ":",
                                              Info::kName,
                                              nameof::nameof_full_type<T>()));
    }
    return T::TryParse(node->get_value());
  }
  static constexpr auto Serialize(xmlpp::Element* element, const T& obj) {
    if constexpr(requires {
                   { ToString(obj) } -> std::convertible_to<const std::string&>;
                 }) {
      element->set_attribute(Info::kName, ToString(obj), Info::kNamespace);
    } else {
      element->set_attribute(Info::kName, obj, Info::kNamespace);
    }
  }
};

template <typename T, typename Info>
struct AttributeSerializer<std::optional<T>, Info> {
  static constexpr auto Parse(xmlpp::Element* element) -> std::optional<T> {
    auto node = element->get_attribute(Info::kName, Info::kNamespace);
    return node ? std::optional{AttributeSerializer<T, Info>::Parse(element)} : [] -> std::optional<T> {
      if constexpr(requires { DefaultValue<T>::Default(); }) {
        return DefaultValue<T>::Default();
      }
      return std::nullopt;
    }();
  }
  static constexpr auto Serialize(xmlpp::Element* element, const std::optional<T>& obj) {
    if(obj) {
      AttributeSerializer<T, Info>::Serialize(element, *obj);
    }
  }
};

template <typename... Ts, typename Info>
struct AttributeSerializer<std::variant<Ts...>, Info> {
  template <typename T>
  static constexpr auto FunctionForType(xmlpp::Element* element) {
    return [=] -> std::optional<T> {
      if constexpr(requires { AttributeSerializer<T, Info>::TryParse(element); }) {
        return AttributeSerializer<T, Info>::TryParse(element);
      } else {
        try {
          return AttributeSerializer<T, Info>::Parse(element);
        } catch(...) {
          return std::nullopt;
        }
      }
    };
  }
  static constexpr auto Parse(xmlpp::Element* element) -> std::variant<Ts...> {
    using T = Info::Type;
    auto node = element->get_attribute(Info::kName, Info::kNamespace);
    if(!node) {
      if constexpr(requires { DefaultValue<T>::Default(); }) {
        return DefaultValue<T>::Default();
      }
      throw AttributeParsingError(std::format("Attribute [{}{}{}: {}] parsing error",
                                              Info::kNamespace,
                                              Info::kNamespace == std::string{} ? "" : ":",
                                              Info::kName,
                                              nameof::nameof_full_type<T>()));
    }
    return [&]<typename... TTs>(utempl::TypeList<TTs...>) {
      // operator* is safe because in or_else Parse returns Ts...[sizeof...(Ts) - 1] (not optional)
      return *utempl::FirstOf(utempl::Tuple{FunctionForType<TTs>(element)...}, std::optional<std::variant<Ts...>>{})
                  .or_else([&] -> std::optional<std::variant<Ts...>> {
                    return AttributeSerializer<decltype(utempl::Get<sizeof...(Ts) - 1>(utempl::kTypeList<Ts...>)), Info>::Parse(element);
                  });
    }(utempl::TakeFrom<sizeof...(Ts) - 1>(utempl::kTypeList<Ts...>));
  }
  static constexpr auto Serialize(xmlpp::Element* element, const std::variant<Ts...>& obj) {
    std::visit(
        [&]<typename T>(const T& value) {
          AttributeSerializer<T, Info>::Serialize(element, value);
        },
        obj);
  }
};

namespace impl {

template <typename T>
consteval auto FindElement(std::string_view field, utempl::TypeList<T> = {}) {
  auto fields = boost::pfr::names_as_array<T>();
  return std::ranges::find(fields, field) - fields.begin();
}

template <auto& Config, typename Info>
auto ParseField(xmlpp::Element* main) -> std::decay_t<decltype(Config)>::type {
  using Type = std::decay_t<decltype(Config)>::type;
  if constexpr(std::holds_alternative<AttributeConfig>(Config.Base())) {
    return AttributeSerializer<Type, Info>::Parse(main);
  } else {
    return ElementSerializer<Type, Config, Info>::Parse(main);
  }
}

template <auto& Config, typename Info, typename T>
auto SerializeField(xmlpp::Element* main, const T& obj) {
  if constexpr(std::holds_alternative<AttributeConfig>(Config.Base())) {
    AttributeSerializer<T, Info>::Serialize(main, obj);
  } else {
    ElementSerializer<T, Config, Info>::Serialize(main, obj);
  }
}

}  // namespace impl

template <typename T>
struct SerializationConfig {
  decltype([] {
    return [](auto... is) {
      return utempl::Tuple<typename ElementConfig<boost::pfr::tuple_element_t<*is, T>>::type...>{};
    } | utempl::kSeq<boost::pfr::tuple_size_v<T>>;
  }()) tuple{};
  template <std::size_t I, typename Self>  // NOLINTNEXTLINE
  consteval auto With(this Self&& self, ElementConfig<boost::pfr::tuple_element_t<I, T>>::type config) -> SerializationConfig {
    auto tuple = std::forward_like<Self>(self.tuple);
    Get<I>(tuple) = std::move(config);
    return {std::move(tuple)};
  }
  template <utempl::ConstexprString Name, typename Self>
  constexpr auto With(this Self&& self, ElementConfig<boost::pfr::tuple_element_t<impl::FindElement<T>(Name), T>>::type config)
      -> SerializationConfig {
    return std::forward<Self>(self).template With<impl::FindElement<T>(Name)>(std::move(config));
  }
};

template <typename T>
constexpr auto Parse(xmlpp::Element* element, Tag<T>) -> T {
  return Serialization<T>::Parse(element);
}
template <typename T>
constexpr auto Parse(xmlpp::Element* element, Tag<T>) -> T
  requires(!std::same_as<std::decay_t<decltype(kDeserializationConfig<T>)>, std::monostate>)
{
  static constexpr SerializationConfig config = kDeserializationConfig<T>;
  constexpr auto tuple = utempl::Map(config.tuple, [](auto& ref) {
    return &ref;
  });
  return utempl::Unpack(utempl::PackConstexprWrapper<utempl::Enumerate(tuple)>(), [&](auto... configs) {
    try {
      return T{impl::ParseField<*((*configs).second), FieldInfo<T, (*configs).first>>(element)...};
    } catch(const ParsingError& error) {
      throw ElementParsingError(std::format("[{}] parsing error: [ {} ]", nameof::nameof_full_type<T>(), error.what()));
    }
  });
}

template <typename T>
constexpr auto Serialize(xmlpp::Element* node, const T& element) -> void
  requires(!std::same_as<std::decay_t<decltype(kSerializationConfig<T>)>, std::monostate>)
{
  static constexpr SerializationConfig config = kSerializationConfig<T>;
  constexpr auto tuple = utempl::Map(config.tuple, [](auto& ref) {
    return &ref;
  });

  return utempl::Unpack(utempl::PackConstexprWrapper<utempl::Enumerate(tuple)>(), [&](auto... configs) {
    try {
      (impl::SerializeField<*((*configs).second), FieldInfo<T, (*configs).first>>(node, boost::pfr::get<(*configs).first>(element)), ...);
    } catch(const ParsingError& error) {
      throw ElementParsingError(std::format("[{}] parsing error: [ {} ]", nameof::nameof_full_type<T>(), error.what()));
    }
  });
}

template <typename T>
constexpr auto Serialize(xmlpp::Element* node, const T& element) -> void {
  Serialization<T>::Serialize(node, element);
}

}  // namespace larra::xmpp::serialization