#include "rive/constraints/scale_constraint.hpp"
#include "rive/transform_component.hpp"
#include "rive/math/mat2d.hpp"
#include <cmath>

using namespace rive;

void ScaleConstraint::constrain(TransformComponent* component)
{
    const Mat2D& transformA = component->worldTransform();
    Mat2D transformB;
    Mat2D::decompose(m_ComponentsA, transformA);
    if (m_Target == nullptr)
    {
        Mat2D::copy(transformB, transformA);
        TransformComponents::copy(m_ComponentsB, m_ComponentsA);
    }
    else
    {
        Mat2D::copy(transformB, m_Target->worldTransform());
        if (sourceSpace() == TransformSpace::local)
        {
            Mat2D inverse;
            if (!Mat2D::invert(inverse, getParentWorld(*m_Target)))
            {
                return;
            }
            Mat2D::multiply(transformB, inverse, transformB);
        }
        Mat2D::decompose(m_ComponentsB, transformB);

        if (!doesCopy())
        {
            m_ComponentsB.scaleX(destSpace() == TransformSpace::local
                                     ? 1.0f
                                     : m_ComponentsA.scaleX());
        }
        else
        {
            m_ComponentsB.scaleX(m_ComponentsB.scaleX() * copyFactor());
            if (offset())
            {
                m_ComponentsB.scaleX(m_ComponentsB.scaleX() *
                                     component->scaleX());
            }
        }

        if (!doesCopyY())
        {
            m_ComponentsB.scaleY(destSpace() == TransformSpace::local
                                     ? 1.0f
                                     : m_ComponentsA.scaleY());
        }
        else
        {
            m_ComponentsB.scaleY(m_ComponentsB.scaleY() * copyFactorY());
            if (offset())
            {
                m_ComponentsB.scaleY(m_ComponentsB.scaleY() *
                                     component->scaleY());
            }
        }

        if (destSpace() == TransformSpace::local)
        {
            // Destination space is in parent transform coordinates. Recompose
            // the parent local transform and get it in world, then decompose
            // the world for interpolation.

            Mat2D::compose(transformB, m_ComponentsB);
            Mat2D::multiply(transformB, getParentWorld(*component), transformB);
            Mat2D::decompose(m_ComponentsB, transformB);
        }
    }

    bool clamplocal = minMaxSpace() == TransformSpace::local;
    if (clamplocal)
    {
        // Apply min max in local space, so transform to local coordinates
        // first.
        Mat2D::compose(transformB, m_ComponentsB);
        Mat2D inverse;
        if (!Mat2D::invert(inverse, getParentWorld(*component)))
        {
            return;
        }
        Mat2D::multiply(transformB, inverse, transformB);
        Mat2D::decompose(m_ComponentsB, transformB);
    }
    if (max() && m_ComponentsB.scaleX() > maxValue())
    {
        m_ComponentsB.scaleX(maxValue());
    }
    if (min() && m_ComponentsB.scaleX() < minValue())
    {
        m_ComponentsB.scaleX(minValue());
    }
    if (maxY() && m_ComponentsB.scaleY() > maxValueY())
    {
        m_ComponentsB.scaleY(maxValueY());
    }
    if (minY() && m_ComponentsB.scaleY() < minValueY())
    {
        m_ComponentsB.scaleY(minValueY());
    }
    if (clamplocal)
    {
        // Transform back to world.
        Mat2D::compose(transformB, m_ComponentsB);
        Mat2D::multiply(transformB, getParentWorld(*component), transformB);
        Mat2D::decompose(m_ComponentsB, transformB);
    }

    float t = strength();
    float ti = 1.0f - t;

    m_ComponentsB.rotation(m_ComponentsA.rotation());
    m_ComponentsB.x(m_ComponentsA.x());
    m_ComponentsB.y(m_ComponentsA.y());
    m_ComponentsB.scaleX(m_ComponentsA.scaleX() * ti +
                         m_ComponentsB.scaleX() * t);
    m_ComponentsB.scaleY(m_ComponentsA.scaleY() * ti +
                         m_ComponentsB.scaleY() * t);
    m_ComponentsB.skew(m_ComponentsA.skew());

    Mat2D::compose(component->mutableWorldTransform(), m_ComponentsB);
}