#include "rive/drawable.hpp"
#include "rive/artboard.hpp"
#include "rive/custom_property.hpp"
#include "rive/shapes/clipping_shape.hpp"
#include "rive/shapes/path_composer.hpp"
#include "rive/shapes/shape.hpp"
#include "rive/clip_result.hpp"
#include "rive/shapes/paint/paint_outset.hpp"

using namespace rive;

bool Drawable::hasCustomProperties()
{
#ifdef WITH_RIVE_EDITOR
    // Children change under the editor, so nothing cached stays true.
    for (auto child : children())
    {
        if (CustomProperty::tagging(child) != nullptr)
        {
            return true;
        }
    }
    return false;
#else
    return runtimeFlag(RuntimeFlags::hasCustomProperties);
#endif
}

CustomProperty* Drawable::customProperty(uint32_t nameId)
{
    for (auto child : children())
    {
        // Only tagging ones: the key of a missing name is what every other
        // property holds, a scripted drawable's inputs among them.
        auto property = CustomProperty::tagging(child);
        if (property != nullptr && property->nameId() == nameId)
        {
            return property;
        }
    }
    return nullptr;
}

StatusCode Drawable::onAddedDirty(CoreContext* context)
{
    auto code = Super::onAddedDirty(context);
    if (code != StatusCode::Ok)
    {
        return code;
    }
    auto blendMode = static_cast<rive::BlendMode>(blendModeValue());
    switch (blendMode)
    {
        case rive::BlendMode::srcOver:
        case rive::BlendMode::additive:
        case rive::BlendMode::screen:
        case rive::BlendMode::overlay:
        case rive::BlendMode::darken:
        case rive::BlendMode::lighten:
        case rive::BlendMode::colorDodge:
        case rive::BlendMode::colorBurn:
        case rive::BlendMode::hardLight:
        case rive::BlendMode::softLight:
        case rive::BlendMode::difference:
        case rive::BlendMode::exclusion:
        case rive::BlendMode::multiply:
        case rive::BlendMode::hue:
        case rive::BlendMode::saturation:
        case rive::BlendMode::color:
        case rive::BlendMode::luminosity:
            return StatusCode::Ok;
    }
    return StatusCode::InvalidObject;
}

void Drawable::addClippingShape(ClippingShape* shape)
{
    m_ClippingShapes.push_back(shape);
}

void Drawable::addLayerMask(LayerMask* mask) { m_layerMasks.push_back(mask); }

void Drawable::addSourceOfLayerMask(LayerMask* mask)
{
    m_sourceOfLayerMasks.push_back(mask);
}

bool Drawable::willDraw() { return !isHidden(); }

bool Drawable::isChildOfLayout(LayoutComponent* layout)
{
    for (ContainerComponent* parent = this; parent != nullptr;
         parent = parent->parent())
    {
        if (parent->is<LayoutComponent>() &&
            parent->as<LayoutComponent>() == layout)
        {
            return true;
        }
    }
    return false;
}

bool Drawable::hitTestPoint(const Vec2D& position,
                            bool skipOnUnclipped,
                            bool isPrimaryHit)
{
    if (isHidden())
    {
        return false;
    }
    auto hComponent = hittableComponent();
    if (hComponent != this && hComponent != nullptr)
    {
        return hComponent->hitTestPoint(position,
                                        skipOnUnclipped,
                                        isPrimaryHit);
    }
    return Component::hitTestPoint(position, skipOnUnclipped, isPrimaryHit);
}

Drawable* DrawableProxy::hittableComponent()
{
    return static_cast<LayoutComponent*>(proxyDrawing());
}

bool DrawableProxy::isTargetOpaque()
{
    return hittableComponent()->isTargetOpaque();
}

BoundsFidelity Drawable::paintedBoundsFromLocal(
    const AABB& local,
    const Mat2D& world,
    const ShapePaintContainer* paints,
    AABB* out)
{
    if (local.isEmptyOrNaN())
    {
        return BoundsFidelity::none;
    }
    AABB bounds = world.mapBoundingBox(local);
    if (bounds.isEmptyOrNaN())
    {
        // A degenerate transform -- scale 0, or a collapsed layout fold --
        // flattens the box to nothing. That is a real answer, not a failure:
        // nothing is painted there.
        *out = AABB();
        return BoundsFidelity::exact;
    }
    bool trustworthy = true;
    if (paints != nullptr)
    {
        const PaintReach reach = shapePaintsWorldReach(paints, world);
        if (reach.worldOutset > 0.0f)
        {
            bounds = bounds.outset(reach.worldOutset, reach.worldOutset);
        }
        trustworthy = reach.trustworthy;
    }
    *out = bounds;
    return trustworthy ? BoundsFidelity::exact : BoundsFidelity::approximate;
}

BoundsFidelity DrawableProxy::paintedWorldBounds(AABB* out)
{
    Drawable* target = hittableComponent();
    // hittableComponent() returns `this` on the base Drawable, and a proxy that
    // stands in for nothing has nothing to measure. Guarding also keeps this
    // from recursing forever if that ever changes.
    if (target == nullptr || target == this)
    {
        return BoundsFidelity::none;
    }
    return target->paintedWorldBounds(out);
}

const std::vector<LayerMask*>& DrawableProxy::layerMasks() const
{
    // const_cast because hittableComponent() is non-const; it is a pure
    // downcast of proxyDrawing() and mutates nothing.
    return const_cast<DrawableProxy*>(this)->hittableComponent()->layerMasks();
}

const std::vector<LayerMask*>& DrawableProxy::sourceOfLayerMasks() const
{
    return const_cast<DrawableProxy*>(this)
        ->hittableComponent()
        ->sourceOfLayerMasks();
}