#ifdef WITH_RIVE_SCRIPTING
// Scoped asset reference resolution, shared between the Luau backend and the
// wasm module blob (which cannot link rive_lua_libs.cpp).
#include "rive/lua/rive_lua_libs.hpp"

#include "lua.h"

using namespace rive;

ScriptingContext::ScopedAssetReference::ScopedAssetReference(
    lua_State* L,
    const char* reference)
{
    std::string request(reference);
    static const std::string kLibraryPrefix = "lib:";
    if (request.compare(0, kLibraryPrefix.size(), kLibraryPrefix) == 0)
    {
        size_t slash = request.find('/', kLibraryPrefix.size());
        if (slash != std::string::npos)
        {
            m_label = request.substr(kLibraryPrefix.size(),
                                     slash - kLibraryPrefix.size());
            m_path = request.substr(slash + 1);
            return;
        }
    }
    m_bare = std::move(request);
    if (L == nullptr)
    {
        return;
    }
    // Mangled chunknames self-describe; the calling chunk's first segment
    // carries its scope. Skip C frames like lua_require does.
    lua_Debug ar;
    int level = 1;
    do
    {
        if (!lua_getinfo(L, level++, "s", &ar))
        {
            return;
        }
    } while (ar.what[0] == 'C');
    if (ar.source == nullptr)
    {
        return;
    }
    std::string chunkname(ar.source);
    size_t slash = chunkname.find('/');
    if (slash == std::string::npos)
    {
        return;
    }
    size_t at = chunkname.find('@');
    if (at > 0 && at < slash)
    {
        m_scopePrefix = chunkname.substr(0, slash);
    }
}

bool ScriptingContext::ScopedAssetReference::matchesLibrary(
    const std::string& registeredName) const
{
    // <label>[#<digits>]@<digits>/<path>
    if (registeredName.size() <= m_label.size() ||
        registeredName.compare(0, m_label.size(), m_label) != 0)
    {
        return false;
    }
    size_t i = m_label.size();
    if (registeredName[i] == '#')
    {
        size_t start = ++i;
        while (i < registeredName.size() && registeredName[i] >= '0' &&
               registeredName[i] <= '9')
        {
            i++;
        }
        if (i == start)
        {
            return false;
        }
    }
    if (i >= registeredName.size() || registeredName[i] != '@')
    {
        return false;
    }
    size_t start = ++i;
    while (i < registeredName.size() && registeredName[i] >= '0' &&
           registeredName[i] <= '9')
    {
        i++;
    }
    if (i == start || i >= registeredName.size() || registeredName[i] != '/')
    {
        return false;
    }
    return registeredName.compare(i + 1, std::string::npos, m_path) == 0;
}

int ScriptingContext::ScopedAssetReference::match(
    const std::string& registeredName,
    const std::string& shortName) const
{
    if (!m_label.empty())
    {
        return matchesLibrary(registeredName) ? 1 : 0;
    }
    if (!m_scopePrefix.empty() &&
        registeredName.size() > m_scopePrefix.size() &&
        registeredName[m_scopePrefix.size()] == '/' &&
        registeredName.compare(0, m_scopePrefix.size(), m_scopePrefix) == 0)
    {
        // Inside the caller's library both the scope relative path and the
        // short name address it.
        if (registeredName.compare(m_scopePrefix.size() + 1,
                                   std::string::npos,
                                   m_bare) == 0 ||
            shortName == m_bare)
        {
            return 2;
        }
        return 0;
    }
    // Host assets only; other libraries need lib: or their own scope.
    size_t slash = registeredName.find('/');
    size_t firstSegment =
        slash == std::string::npos ? registeredName.size() : slash;
    size_t at = registeredName.find('@');
    if (at > 0 && at < firstSegment)
    {
        return 0;
    }
    return registeredName == m_bare || shortName == m_bare ? 1 : 0;
}

#endif