#include "rive/scripted/scripted_transition.hpp"
#include "rive/nested_artboard.hpp"
#include "rive/artboard.hpp"
#include "rive/file.hpp"
#include "rive/component.hpp"
#include "rive/component_dirt.hpp"
#include "rive/drawable_flag.hpp"
#include "rive/enums.hpp"
#include "rive/animation/state_machine_instance.hpp"
#include "rive/viewmodel/viewmodel_instance.hpp"
#include "rive/viewmodel/viewmodel_instance_list_item.hpp"
#ifdef WITH_RIVE_LAYOUT
#include "rive/layout_component.hpp"
#endif

using namespace rive;

// v1: only NestedArtboard children participate in the design-time solo set.
static bool isTransitionChild(Component* child)
{
    return child->is<NestedArtboard>();
}

// Toggle the loop-exclusion (Hidden drawable flag) on a design child. Hidden
// removes the child from the artboard draw walk (Drawable::isHidden()) without
// collapsing it, so NestedArtboard::advanceComponent keeps advancing its
// content while the container composites it in draw().
static void setChildHidden(Drawable* drawable, bool hidden)
{
    uint32_t flags = drawable->drawableFlags();
    if (hidden)
    {
        flags |= static_cast<uint32_t>(DrawableFlag::Hidden);
    }
    else
    {
        flags &= ~static_cast<uint32_t>(DrawableFlag::Hidden);
    }
    drawable->drawableFlags(flags);
}

ScriptedTransition::~ScriptedTransition() { clearListInstances(); }

// ---------------------------------------------------------------------------
// Design-time solo set
// ---------------------------------------------------------------------------

int ScriptedTransition::designChildCount()
{
    int count = 0;
    for (Component* child : children())
    {
        if (isTransitionChild(child))
        {
            count++;
        }
    }
    return count;
}

NestedArtboard* ScriptedTransition::designChildAt(int index)
{
    int i = 0;
    for (Component* child : children())
    {
        if (!isTransitionChild(child))
        {
            continue;
        }
        if (i == index)
        {
            return child->as<NestedArtboard>();
        }
        i++;
    }
    return nullptr;
}

int ScriptedTransition::sourceIndex(const TransitionSource& source)
{
    if (source.instance != nullptr)
    {
        for (size_t i = 0; i < m_listInstancesByIndex.size(); i++)
        {
            if (m_listInstancesByIndex[i] == source.instance)
            {
                return designChildCount() + (int)i;
            }
        }
        return -1;
    }
    if (source.design != nullptr)
    {
        int i = 0;
        for (Component* child : children())
        {
            if (!isTransitionChild(child))
            {
                continue;
            }
            if (child == source.design)
            {
                return i;
            }
            i++;
        }
    }
    return -1;
}

Component* ScriptedTransition::activeComponent()
{
    auto* ab = artboard();
    Core* active = ab != nullptr ? ab->resolve(activeComponentId()) : nullptr;
    for (Component* child : children())
    {
        if (child == active && isTransitionChild(child))
        {
            return child;
        }
    }
    return nullptr;
}

bool ScriptedTransition::scriptReady() const
{
#ifdef WITH_RIVE_SCRIPTING
    return m_vm != nullptr && m_self != 0;
#else
    return false;
#endif
}

bool ScriptedTransition::scriptManagesTo() const
{
#ifdef WITH_RIVE_SCRIPTING
    if (m_vm == nullptr || !m_vm->valid() || m_self == 0)
    {
        return true;
    }
    return m_vm->transitionManagesTo(m_self);
#else
    return true;
#endif
}

void ScriptedTransition::propagateCollapse(bool collapse)
{
    Core* active = collapse || artboard() == nullptr
                       ? nullptr
                       : artboard()->resolve(activeComponentId());
    for (Component* child : children())
    {
        if (!isTransitionChild(child))
        {
            child->collapse(collapse);
            continue;
        }
        if (!collapse && m_transitioning &&
            (child == m_from.design || child == m_to.design))
        {
            // Both transitioning design children stay live; drawn by draw().
            child->collapse(false);
        }
        else
        {
            child->collapse(child != active);
        }
    }
}

bool ScriptedTransition::collapse(bool value)
{
    if (!Component::collapse(value))
    {
        return false;
    }
    propagateCollapse(value);
    return true;
}

// ---------------------------------------------------------------------------
// List instancing (lazy) — modeled on ArtboardComponentList
// ---------------------------------------------------------------------------

Artboard* ScriptedTransition::findListArtboard(
    const rcp<ViewModelInstanceListItem>& item)
{
    if (m_file == nullptr || item == nullptr)
    {
        return nullptr;
    }
    auto vmi = item->viewModelInstance();
    if (vmi == nullptr)
    {
        return nullptr;
    }
    uint32_t viewModelId = vmi->viewModelId();
    auto cached = m_artboardsMap.find(viewModelId);
    if (cached != m_artboardsMap.end())
    {
        return cached->second;
    }
    for (auto ab : m_file->artboards())
    {
        if (ab->viewModelId() == viewModelId)
        {
            m_artboardsMap[viewModelId] = ab;
            return ab;
        }
    }
    return nullptr;
}

ArtboardInstance* ScriptedTransition::ensureListInstance(int index)
{
    if (index < 0 || index >= (int)m_listItems.size())
    {
        return nullptr;
    }
    if (index < (int)m_listInstancesByIndex.size() &&
        m_listInstancesByIndex[index] != nullptr)
    {
        return m_listInstancesByIndex[index];
    }
    auto& item = m_listItems[index];
    auto existing = m_listInstances.find(item);
    if (existing != m_listInstances.end())
    {
        return existing->second.get();
    }
    Artboard* source = findListArtboard(item);
    if (source == nullptr)
    {
        return nullptr;
    }
    std::unique_ptr<ArtboardInstance> inst = source->instance();
    ArtboardInstance* raw = inst.get();
    if (raw == nullptr)
    {
        return nullptr;
    }
    if (artboard() != nullptr)
    {
        raw->bindViewModelInstance(item->viewModelInstance(),
                                   artboard()->dataContext());
        raw->updateDataBinds();
    }
    raw->frameOrigin(false);
    // Default state machine so the instanced artboard animates.
    int smIndex = raw->defaultStateMachineIndex();
    std::unique_ptr<StateMachineInstance> sm =
        raw->stateMachineAt(smIndex >= 0 ? (size_t)smIndex : 0u);
    if (sm != nullptr)
    {
        sm->dataContext(raw->dataContext());
        sm->updateDataBinds(false);
        m_listStateMachines[raw] = std::move(sm);
    }
    m_listInstances[item] = std::move(inst);
    if ((int)m_listInstancesByIndex.size() <= index)
    {
        m_listInstancesByIndex.resize(m_listItems.size(), nullptr);
    }
    m_listInstancesByIndex[index] = raw;
    return raw;
}

void ScriptedTransition::forgetInstance(ArtboardInstance* instance)
{
    if (instance == nullptr)
    {
        return;
    }
    if (m_transitioning &&
        (m_from.instance == instance || m_to.instance == instance))
    {
        // The transition can't run against a source that's about to be freed:
        // settle it now, which also un-hides any design child it had hidden.
        completeTransition();
    }
    if (m_current.instance == instance)
    {
        // completeTransition() may have just seated it as current.
        m_current = TransitionSource();
    }
}

void ScriptedTransition::disposeListItem(
    const rcp<ViewModelInstanceListItem>& item)
{
    auto instIt = m_listInstances.find(item);
    if (instIt != m_listInstances.end())
    {
        forgetInstance(instIt->second.get());
        // State machine before artboard (avoids use-after-free in teardown).
        m_listStateMachines.erase(instIt->second.get());
        m_listInstances.erase(instIt);
    }
}

void ScriptedTransition::clearListInstances()
{
    if (m_transitioning &&
        (m_from.instance != nullptr || m_to.instance != nullptr))
    {
        completeTransition();
    }
    if (m_current.instance != nullptr)
    {
        m_current = TransitionSource();
    }
    m_listStateMachines.clear(); // state machines before artboards
    m_listInstances.clear();
    m_listInstancesByIndex.clear();
    m_listItems.clear();
    m_artboardsMap.clear();
    m_activeListIndex = -1;
}

static bool listsAreEqual(
    const std::vector<rcp<ViewModelInstanceListItem>>& current,
    std::vector<rcp<ViewModelInstanceListItem>>* incoming)
{
    if (incoming == nullptr)
    {
        return current.empty();
    }
    if (current.size() != incoming->size())
    {
        return false;
    }
    for (size_t i = 0; i < current.size(); i++)
    {
        if (current[i] != (*incoming)[i])
        {
            return false;
        }
    }
    return true;
}

void ScriptedTransition::updateList(
    std::vector<rcp<ViewModelInstanceListItem>>* list)
{
    if (listsAreEqual(m_listItems, list))
    {
        return;
    }
    std::vector<rcp<ViewModelInstanceListItem>> old = m_listItems;
    if (list != nullptr)
    {
        m_listItems = *list;
    }
    else
    {
        m_listItems.clear();
    }
    // Dispose cached instances for items no longer present.
    for (auto& item : old)
    {
        bool present = false;
        for (auto& current : m_listItems)
        {
            if (current == item)
            {
                present = true;
                break;
            }
        }
        if (!present)
        {
            disposeListItem(item);
        }
    }
    // Assign each item its `index` symbol (if any) + rebuild the lazy index
    // cache, keeping instances that survived.
    m_listInstancesByIndex.assign(m_listItems.size(), nullptr);
    for (size_t i = 0; i < m_listItems.size(); i++)
    {
        m_listItems[i]->assignListIndex((uint32_t)i);
        auto it = m_listInstances.find(m_listItems[i]);
        if (it != m_listInstances.end())
        {
            m_listInstancesByIndex[i] = it->second.get();
        }
    }
    addDirt(ComponentDirt::Components);
    applySelection(); // clamps m_activeListIndex and (re)selects
    wakeAdvance();
}

void ScriptedTransition::listSourceChanged()
{
    // Unbound: clear the instanced children.
    if (listSource() == (uint32_t)-1)
    {
        std::vector<rcp<ViewModelInstanceListItem>> empty;
        updateList(&empty);
    }
}

// ---------------------------------------------------------------------------
// Unified selection over the combined solo set
// ---------------------------------------------------------------------------

ScriptedTransition::TransitionSource ScriptedTransition::intendedSource()
{
    TransitionSource source;
    if (m_activeListIndex >= 0 && m_activeListIndex < (int)m_listItems.size())
    {
        source.instance = ensureListInstance(m_activeListIndex);
        if (source.instance != nullptr)
        {
            return source;
        }
    }
    Component* design = activeComponent();
    if (design != nullptr && design->is<NestedArtboard>())
    {
        source.design = design->as<NestedArtboard>();
    }
    return source;
}

void ScriptedTransition::applySelection()
{
    selectActiveSource(intendedSource());
}

void ScriptedTransition::selectActiveSource(const TransitionSource& next)
{
    if (next == m_current)
    {
        return;
    }
    TransitionSource prev = m_current;
    m_current = next;
    if (scriptReady() && !prev.empty() && !next.empty())
    {
        startTransition(prev, next);
        return;
    }
    // Instant: clear any in-flight transition and settle collapse.
    if (m_transitioning)
    {
        if (m_from.design != nullptr)
        {
            setChildHidden(m_from.design, false);
        }
        if (m_to.design != nullptr)
        {
            setChildHidden(m_to.design, false);
        }
        m_transitioning = false;
        m_from = TransitionSource();
        m_to = TransitionSource();
        m_manageTo = true;
    }
    propagateCollapse(isCollapsed());
    addScriptedDirt(ComponentDirt::Paint);
}

void ScriptedTransition::startTransition(const TransitionSource& from,
                                         const TransitionSource& to)
{
    TransitionSource previousFrom =
        m_transitioning ? m_from : TransitionSource();

    m_from = from;
    m_to = to;
    m_transitioning = true;

    // Interruption: retire a previously-outgoing design child not in the new
    // pair (list instances need no un-hide — they are never in the draw loop).
    if (!previousFrom.empty() && previousFrom != m_from &&
        previousFrom != m_to && previousFrom.design != nullptr)
    {
        setChildHidden(previousFrom.design, false);
        previousFrom.design->collapse(true);
    }

    // Keep design sources live; list instances are host-drawn regardless.
    if (m_from.design != nullptr)
    {
        m_from.design->collapse(false);
    }
    if (m_to.design != nullptr)
    {
        m_to.design->collapse(false);
    }
    propagateCollapse(isCollapsed());

    callChanged(m_from, m_to);

    // A list `to` has no draw-loop entry to fall back to, so it must always be
    // script-composited; a design `to` may opt out via `managesTo`.
    m_manageTo = m_to.instance != nullptr ? true : scriptManagesTo();
    if (m_from.design != nullptr)
    {
        setChildHidden(m_from.design, true);
    }
    if (m_to.design != nullptr)
    {
        setChildHidden(m_to.design, m_manageTo);
    }

    wakeAdvance();
    addScriptedDirt(ComponentDirt::Components);
}

void ScriptedTransition::completeTransition()
{
    if (!m_transitioning)
    {
        return;
    }
    TransitionSource from = m_from;
    TransitionSource to = m_to;
    m_transitioning = false;
    m_from = TransitionSource();
    m_to = TransitionSource();
    m_manageTo = true;
    if (from.design != nullptr)
    {
        setChildHidden(from.design, false);
    }
    if (to.design != nullptr)
    {
        setChildHidden(to.design, false);
    }
    m_current = to;
    propagateCollapse(isCollapsed());
    addScriptedDirt(ComponentDirt::Paint);
}

void ScriptedTransition::activeComponentIdChanged()
{
    // A genuine design child was chosen -> leave list mode.
    if (activeComponent() != nullptr)
    {
        m_activeListIndex = -1;
    }
    applySelection();
#ifdef WITH_RIVE_LAYOUT
    recollectOwningLayout();
#endif
}

StatusCode ScriptedTransition::onAddedClean(CoreContext* context)
{
    StatusCode code = Super::onAddedClean(context);
    if (code != StatusCode::Ok)
    {
        return code;
    }
    m_current = intendedSource();
    propagateCollapse(isCollapsed());
#ifdef WITH_RIVE_LAYOUT
    recollectOwningLayout();
#endif
    return StatusCode::Ok;
}

// ---------------------------------------------------------------------------
// Advance / draw / update
// ---------------------------------------------------------------------------

void ScriptedTransition::advanceLiveInstance(const TransitionSource& source,
                                             float elapsedSeconds,
                                             AdvanceFlags flags,
                                             bool& keepGoing)
{
    if (source.instance == nullptr)
    {
        return;
    }
    auto smIt = m_listStateMachines.find(source.instance);
    StateMachineInstance* sm =
        smIt != m_listStateMachines.end() ? smIt->second.get() : nullptr;
    if (sm != nullptr && enums::is_flag_set(flags, AdvanceFlags::AdvanceNested))
    {
        if (sm->advanceAndApply(elapsedSeconds, false))
        {
            keepGoing = true;
        }
    }
    else if (source.instance->advanceInternal(elapsedSeconds, flags))
    {
        keepGoing = true;
    }
}

bool ScriptedTransition::advanceComponent(float elapsedSeconds,
                                          AdvanceFlags flags)
{
    bool keepGoing = false;

    if (m_transitioning)
    {
        // In design mode (no nested/real time), settle immediately rather than
        // freezing mid-blend.
        if (!enums::is_flag_set(flags, AdvanceFlags::AdvanceNested))
        {
            completeTransition();
        }
        else if (elapsedSeconds == 0)
        {
            // Waiting for real elapsed time; keep requesting frames.
            keepGoing = true;
        }
        else
        {
            bool scriptGoing = scriptAdvance(elapsedSeconds);
            addScriptedDirt(ComponentDirt::Paint);
            if (!scriptGoing)
            {
                completeTransition();
            }
            else
            {
                keepGoing = true;
            }
        }
    }

    // Advance the live list instance(s). Design sources advance via the
    // artboard's own advancing-component loop, so only list instances here.
    if (m_transitioning)
    {
        advanceLiveInstance(m_from, elapsedSeconds, flags, keepGoing);
        advanceLiveInstance(m_to, elapsedSeconds, flags, keepGoing);
    }
    else
    {
        advanceLiveInstance(m_current, elapsedSeconds, flags, keepGoing);
    }
    return keepGoing;
}

void ScriptedTransition::draw(Renderer* renderer)
{
#ifdef WITH_RIVE_SCRIPTING
    if (m_transitioning && m_vm != nullptr && m_vm->valid() && draws())
    {
        ScriptBackend::TransitionChildRef from = childRef(m_from);
        ScriptBackend::TransitionChildRef to = childRef(m_to);
        // When the script opts out of managing the to child (design only) it
        // renders through the normal loop, so hand the script nil instead.
        if (!m_manageTo)
        {
            to.artboard = nullptr;
        }

        renderer->save();
        m_vm->callTransitionDraw(this, m_self, renderer, from, to);
        renderer->restore();
        return;
    }
#endif
    // Idle: an active LIST instance has no draw-loop entry, so draw it here
    // (design children draw through the normal loop, gated by collapse).
    if (m_current.instance != nullptr)
    {
        renderer->save();
        renderer->transform(worldTransform());
        artboard()->drawHosted(m_current.instance, renderer);
        renderer->restore();
    }
}

bool ScriptedTransition::willDraw()
{
    return Super::willDraw() &&
           (m_transitioning || m_current.instance != nullptr);
}

void ScriptedTransition::update(ComponentDirt value)
{
    Super::update(value);

    auto forward = [this, value](const TransitionSource& source) {
        ArtboardInstance* inst = source.instance;
        if (inst == nullptr)
        {
            return;
        }
        if ((value & ComponentDirt::RenderOpacity) ==
            ComponentDirt::RenderOpacity)
        {
            inst->opacity(renderOpacity());
        }
        if ((value & ComponentDirt::Components) == ComponentDirt::Components)
        {
            inst->updatePass(false);
        }
    };
    if (m_transitioning)
    {
        forward(m_from);
        forward(m_to);
    }
    else
    {
        forward(m_current);
    }
}

void ScriptedTransition::callChanged(const TransitionSource& from,
                                     const TransitionSource& to)
{
#ifdef WITH_RIVE_SCRIPTING
    if (m_vm == nullptr || !m_vm->valid())
    {
        return;
    }
    // 1 when the incoming child is at a higher combined index than the
    // outgoing one, -1 when lower, 0 when unknown (e.g. first show).
    int fromIndex = sourceIndex(from);
    int toIndex = sourceIndex(to);
    int direction =
        (fromIndex >= 0 && toIndex >= 0)
            ? (toIndex > fromIndex ? 1 : (toIndex < fromIndex ? -1 : 0))
            : 0;
    m_vm->callTransitionChanged(this,
                                m_self,
                                childRef(from),
                                childRef(to),
                                direction);
#endif
}

#ifdef WITH_RIVE_SCRIPTING
ScriptBackend::TransitionChildRef ScriptedTransition::childRef(
    const TransitionSource& source) const
{
    ScriptBackend::TransitionChildRef ref;
    if (source.design != nullptr)
    {
        ref.artboard = static_cast<Artboard*>(source.design->sourceArtboard());
        ref.transform = source.design->worldTransform();
    }
    else
    {
        ref.artboard = static_cast<Artboard*>(source.instance);
        ref.transform = worldTransform();
    }
    return ref;
}
#endif

Core* ScriptedTransition::clone() const
{
    ScriptedTransition* twin =
        ScriptedTransitionBase::clone()->as<ScriptedTransition>();
    if (m_fileAsset != nullptr)
    {
        twin->setAsset(m_fileAsset);
    }
    twin->file(m_file);
    return twin;
}

#ifdef WITH_RIVE_LAYOUT
void ScriptedTransition::recollectOwningLayout()
{
    for (Component* p = parent(); p != nullptr; p = p->parent())
    {
        if (p->is<LayoutComponent>())
        {
            p->as<LayoutComponent>()->syncLayoutChildren();
            return;
        }
    }
}
#endif

// ---------------------------------------------------------------------------
// Combined-index selectors (design children then list instances)
// ---------------------------------------------------------------------------

void ScriptedTransition::updateByIndex(size_t index)
{
    int designCount = designChildCount();
    // The data-binding path casts rounded floats to size_t without clamping,
    // so a negative binding arrives as a huge index. Reject it before the
    // narrowing below turns it back into a negative int, which would pass the
    // design-child test and clear an active list selection (mirrors
    // Solo::updateByIndex).
    if (index >= (size_t)designCount + m_listItems.size())
    {
        return;
    }
    if ((int)index < designCount)
    {
        m_activeListIndex = -1;
        NestedArtboard* child = designChildAt((int)index);
        if (child != nullptr && artboard() != nullptr)
        {
            activeComponentId(artboard()->idOf(child));
        }
        applySelection();
        return;
    }
    size_t listIndex = index - (size_t)designCount;
    if (listIndex >= m_listItems.size())
    {
        return;
    }
    m_activeListIndex = (int)listIndex;
    // Neutralize the design selection (0 == runtime "missing"); resolves to no
    // child, so activeComponentIdChanged leaves m_activeListIndex intact.
    if (activeComponentId() != 0)
    {
        activeComponentId(0);
    }
    applySelection();
}

void ScriptedTransition::updateByName(const std::string& name)
{
    // v1: name selection covers design children only (list items have no
    // stable names).
    if (!artboard())
    {
        return;
    }
    for (auto& child : children())
    {
        if (!isTransitionChild(child))
        {
            continue;
        }
        if (child->name() == name)
        {
            m_activeListIndex = -1;
            activeComponentId(artboard()->idOf(child));
            break;
        }
    }
}

int ScriptedTransition::getActiveChildIndex()
{
    if (m_activeListIndex >= 0)
    {
        return designChildCount() + m_activeListIndex;
    }
    if (!artboard())
    {
        return -1;
    }
    Core* active = artboard()->resolve(activeComponentId());
    if (active)
    {
        int index = 0;
        for (auto& child : children())
        {
            if (!isTransitionChild(child))
            {
                continue;
            }
            if (child == active)
            {
                return index;
            }
            index++;
        }
    }
    return -1;
}

std::string ScriptedTransition::getActiveChildName()
{
    if (!artboard())
    {
        return "";
    }
    Core* active = artboard()->resolve(activeComponentId());
    if (active && active->is<Component>())
    {
        return active->as<Component>()->name();
    }
    return "";
}