src/scripted/scripted_transition.cpp

#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 "";
}