
#include "rive/foreground_layout_drawable.hpp"
#include "rive/layout_component.hpp"
#include "rive/shapes/paint/fill.hpp"
#include "rive/shapes/paint/stroke.hpp"

using namespace rive;

void ForegroundLayoutDrawable::buildDependencies()
{
  Super::buildDependencies();
  // Set the blend mode on all the shape paints. If we ever animate this
  // property, we'll need to update it in the update cycle/mark dirty when the
  // blend mode changes.
  auto parentLayout = (parent()->as<LayoutComponent>());
  if (parentLayout != nullptr)
  {
    parentLayout->registerForegroundDrawable();
    for (auto paint : m_ShapePaints)
    {
      paint->blendMode(
          parentLayout->blendMode(),
          parentLayout->additiveAmount());
    }
  }
}

void ForegroundLayoutDrawable::update(ComponentDirt value)
{
  Super::update(value);
  auto parentLayout = (parent()->as<LayoutComponent>());
  if (parentLayout != nullptr)
  {
    if (hasDirt(value, ComponentDirt::RenderOpacity))
    {
      propagateOpacity(parentLayout->childOpacity());
    }
    if (hasDirt(value, ComponentDirt::Path | ComponentDirt::WorldTransform))
    {
      invalidateStrokeEffects();
    }
  }
}

void ForegroundLayoutDrawable::draw(Renderer* renderer)
{
  auto parentLayoutComponent = (parent()->as<LayoutComponent>());

  for (auto shapePaint : m_ShapePaints)
  {
    // Our paints blend against the layout we draw over, and its
    // additiveAmount animates, so re-read it rather than relying on the
    // one-shot sync in buildDependencies().
    shapePaint->blendMode(
        parentLayoutComponent->blendMode(),
        parentLayoutComponent->additiveAmount());
    if (!shapePaint->shouldDraw())
    {
      continue;
    }
    auto shapePaintPath = shapePaint->pickPath(parentLayoutComponent);
    if (shapePaintPath == nullptr)
    {
      continue;
    }
    shapePaint->draw(
        renderer,
        shapePaintPath,
        parentLayoutComponent->worldTransform());
  }
}

Core* ForegroundLayoutDrawable::hitTest(HitInfo* hinfo, const Mat2D& xform)
{
  return nullptr;
}

Component* ForegroundLayoutDrawable::pathBuilder() { return parent(); }

ShapePaintPath* ForegroundLayoutDrawable::worldPath()
{
  return parent()->as<LayoutComponent>()->worldPath();
}

ShapePaintPath* ForegroundLayoutDrawable::localPath()
{
  return parent()->as<LayoutComponent>()->localPath();
}

ShapePaintPath* ForegroundLayoutDrawable::localClockwisePath()
{
  return parent()->as<LayoutComponent>()->localClockwisePath();
}

BoundsFidelity ForegroundLayoutDrawable::paintedWorldBounds(AABB* out)
{
  // It has no box of its own: it paints the parent layout's outline, at the
  // layout's transform, with its own paints.
  ContainerComponent* container = parent();
  if (container == nullptr || !container->is<LayoutComponent>())
  {
    return BoundsFidelity::none;
  }
  return paintedBoundsFromLocal(
      container->as<LayoutComponent>()->localBounds(),
      worldTransform(),
      this,
      out);
}