#include "semantic_inference_registry.hpp"

#include "rive/component.hpp"
#include "rive/generated/text/text_base.hpp"
#include "rive/semantic/semantic_role.hpp"
#include "rive/text/text.hpp"

namespace rive
{
#ifdef WITH_RIVE_TEXT
namespace
{

using InferSemanticFn = bool (*)(Component*, ResolvedSemanticData&);

struct InferenceRule
{
  uint16_t typeKey;
  InferSemanticFn infer;
};

static std::string inferredTextLabel(Text* text)
{
  std::string label;
  for (auto run : text->runs())
  {
    if (run != nullptr)
    {
      label += run->text();
    }
  }
  return label;
}

static bool inferTextSemantics(Component* component, ResolvedSemanticData& out)
{
  const auto label = inferredTextLabel(component->as<Text>());
  if (label.empty())
  {
    return false;
  }

  out.hasSemantics = true;
  out.role = static_cast<uint32_t>(SemanticRole::text);
  out.label = label;
  return true;
}

static constexpr InferenceRule kInferenceRules[] = {
    {TextBase::typeKey, inferTextSemantics},
};

} // namespace

bool supportsInferredSemantics(Component* component)
{
  if (component == nullptr)
  {
    return false;
  }
  for (const auto& rule : kInferenceRules)
  {
    if (component->isTypeOf(rule.typeKey))
    {
      return true;
    }
  }
  return false;
}

bool resolveInferredSemantics(Component* component, ResolvedSemanticData& out)
{
  if (component == nullptr)
  {
    return false;
  }
  for (const auto& rule : kInferenceRules)
  {
    if (component->isTypeOf(rule.typeKey) && rule.infer(component, out))
    {
      return true;
    }
  }
  return false;
}
#else
// No inference rules are active when the text engine is compiled out —
// Text is the only current rule and it needs Text::runs().
bool supportsInferredSemantics(Component*) { return false; }

bool resolveInferredSemantics(Component*, ResolvedSemanticData&)
{
  return false;
}
#endif

} // namespace rive