#include "rive/bones/skin.hpp"
#include "rive/bones/bone.hpp"
#include "rive/bones/skinnable.hpp"
#include "rive/bones/tendon.hpp"
#include "rive/shapes/vertex.hpp"
#include "rive/shapes/path_vertex.hpp"
#include "rive/constraints/constraint.hpp"
#include <algorithm>

#include <cmath>

using namespace rive;

Skin::~Skin() { delete[] m_BoneTransforms; }

StatusCode Skin::onAddedDirty(CoreContext* context)
{
    StatusCode code = Super::onAddedDirty(context);
    if (code != StatusCode::Ok)
    {
        return code;
    }
    m_WorldTransform[0] = xx();
    m_WorldTransform[1] = xy();
    m_WorldTransform[2] = yx();
    m_WorldTransform[3] = yy();
    m_WorldTransform[4] = tx();
    m_WorldTransform[5] = ty();
    m_Skinnable = Skinnable::from(parent());
    if (m_Skinnable == nullptr)
    {
        return StatusCode::MissingObject;
    }

#ifndef WITH_RIVE_EDITOR
    // Runtime-only; editor build registers via editorParentChanged.
    m_Skinnable->skin(this);
#endif

    return StatusCode::Ok;
}

void Skin::update(ComponentDirt value)
{
    int bidx = 6;
    for (auto tendon : m_Tendons)
    {
#ifdef WITH_RIVE_EDITOR
        // Edit-time: a partially-hydrated coop batch can leave a
        // Tendon with a null `m_Bone` (its Bone hasn't been delivered
        // yet, or was deleted). Without this guard `update` reads the
        // null bone's world transform and crashes mid-frame. Emit the
        // identity transform so the skin can still render in its
        // bind pose until the bone reappears.
        if (tendon->bone() == nullptr)
        {
            const auto& inv = tendon->inverseBind();
            m_BoneTransforms[bidx++] = inv[0];
            m_BoneTransforms[bidx++] = inv[1];
            m_BoneTransforms[bidx++] = inv[2];
            m_BoneTransforms[bidx++] = inv[3];
            m_BoneTransforms[bidx++] = inv[4];
            m_BoneTransforms[bidx++] = inv[5];
            continue;
        }
#endif
        auto world = tendon->bone()->worldTransform() * tendon->inverseBind();
        m_BoneTransforms[bidx++] = world[0];
        m_BoneTransforms[bidx++] = world[1];
        m_BoneTransforms[bidx++] = world[2];
        m_BoneTransforms[bidx++] = world[3];
        m_BoneTransforms[bidx++] = world[4];
        m_BoneTransforms[bidx++] = world[5];
    }
}

int Skin::windingSign() const
{
    if (m_BoneTransforms == nullptr)
    {
        return 0;
    }
    bool anyMirrored = false;
    bool anyUpright = false;
    const float* transform = m_BoneTransforms;
    for (auto tendon : m_Tendons)
    {
        transform += 6;
#ifdef WITH_RIVE_EDITOR
        if (tendon->bone() == nullptr)
        {
            continue;
        }
#else
        (void)tendon;
#endif
        int sign =
            orientation(transform[0], transform[1], transform[2], transform[3]);
        anyMirrored |= sign < 0;
        anyUpright |= sign > 0;
    }
    return anyMirrored == anyUpright ? 0 : (anyMirrored ? -1 : 1);
}

int Skin::orientation(float xx, float xy, float yx, float yy)
{
    float xxyy = xx * yy;
    float xyyx = xy * yx;
    float determinant = xxyy - xyyx;
    // The determinant is only zero up to the rounding of the two products.
    if (std::abs(determinant) <= 1e-6f * (std::abs(xxyy) + std::abs(xyyx)))
    {
        return 0;
    }
    return determinant < 0 ? -1 : 1;
}

void Skin::buildDependencies()
{
    // depend on bones from tendons
    for (auto tendon : m_Tendons)
    {
        auto bone = tendon->bone();
#ifdef WITH_RIVE_EDITOR
        // See `Skin::update` — coop can leave an unresolved Tendon
        // with a null bone. `editor_native/finalizeBatch` calls
        // `Tendon::resolveBone` on every tendon before us, so this
        // is only hit for tendons whose bone genuinely isn't in the
        // file yet. Skip; the dependency edge rewires when the bone
        // arrives in a later batch and we re-run finalizeBatch.
        if (bone == nullptr)
        {
            continue;
        }
#endif
        bone->addDependent(this);
        for (auto constraint : bone->peerConstraints())
        {
            constraint->parent()->addDependent(this);
        }
    }

#ifdef WITH_RIVE_EDITOR
    // Editor re-runs buildDependencies after every batch (Pass-B-prep
    // wipes the dependents list, then the typed per-class method
    // rewires it). For Skin that means a second allocation of the
    // bone-transform buffer — `assert` below would catch the runtime-
    // only invariant. Free the prior buffer so the editor case stays
    // leak-free while keeping the runtime guard intact.
    if (m_BoneTransforms != nullptr)
    {
        delete[] m_BoneTransforms;
        m_BoneTransforms = nullptr;
    }
#else
    // Make sure no-one is calling this twice.
    assert(m_BoneTransforms == nullptr);
#endif
    // We can now init the bone buffer.
    auto size = (m_Tendons.size() + 1) * 6;
    m_BoneTransforms = new float[size];
    m_BoneTransforms[0] = 1;
    m_BoneTransforms[1] = 0;
    m_BoneTransforms[2] = 0;
    m_BoneTransforms[3] = 1;
    m_BoneTransforms[4] = 0;
    m_BoneTransforms[5] = 0;
}

void Skin::deform(Span<Vertex*> vertices)
{
    for (auto vertex : vertices)
    {
        vertex->deform(m_WorldTransform, m_BoneTransforms);
    }
}
void Skin::addTendon(Tendon* tendon)
{
    m_Tendons.push_back(tendon);
#ifdef WITH_RIVE_EDITOR
    bindingChangedForEditor();
#endif
}

#ifdef WITH_RIVE_EDITOR
void Skin::bindingChangedForEditor()
{
    if (m_Skinnable != nullptr)
    {
        m_Skinnable->bindingChangedForEditor();
    }
}

void Skin::sortTendonsForEditor()
{
    auto byChildOrder = [](const Tendon* a, const Tendon* b) {
        return a->childOrder().compareTo(b->childOrder()) < 0;
    };
    if (std::is_sorted(m_Tendons.begin(), m_Tendons.end(), byChildOrder))
    {
        return;
    }
    std::sort(m_Tendons.begin(), m_Tendons.end(), byChildOrder);
    bindingChangedForEditor();
    // Weights index m_BoneTransforms by tendon position, so a reorder has to
    // rebuild the buffer and re-deform the skinnable.
    addDirt(ComponentDirt::WorldTransform);
}
#endif

void Skin::onDirty(ComponentDirt dirt)
{
    // Render opacity alone, a fade reaching us through our bones, can't move a
    // bone, so the skinned vertices stay where they are. Collapsed is a state
    // this dirt keeps while we are hidden, not work.
    if ((dirt & ~ComponentDirt::Collapsed) == ComponentDirt::RenderOpacity)
    {
        return;
    }
    if (m_Skinnable != nullptr)
    {
        m_Skinnable->markSkinDirty();
    }
}