/*
 * Copyright 2025 Rive
 */

#include "rive/logging_scripting_context.hpp"

#ifdef WITH_RIVE_SCRIPTING
#include "rive/lua/rive_lua_libs.hpp"

#include <cstring>
#include <string>
#include <utility>

namespace rive
{
namespace
{
// Routes a script's console output and errors to a host-provided sink instead
// of stdout/stderr. print() may be called several times per line, so text is
// accumulated between printBeginLine()/printEndLine() and flushed as one line.
class LoggingScriptingContext : public CPPRuntimeScriptingContext
{
public:
  LoggingScriptingContext(Factory* factory, ScriptingLogSink sink)
      : CPPRuntimeScriptingContext(factory)
      , m_sink(std::move(sink))
  {}

  void printBeginLine(lua_State*) override { m_line.clear(); }

  void print(Span<const char> data) override
  {
    m_line.append(data.data(), data.size());
  }

  // print() is redirected into m_line, so the base's stdout separator would
  // land somewhere this line never sees.
  void printSeparator() override { print(Span<const char>("\t", 1)); }

  void printEndLine() override
  {
    m_sink(ScriptingLogLevel::info, m_line.c_str(), m_line.size());
    m_line.clear();
  }

  void printError(lua_State* state) override
  {
    const char* error = lua_tostring(state, -1);
    if (error != nullptr)
    {
      m_sink(ScriptingLogLevel::error, error, std::strlen(error));
    }
  }

private:
  ScriptingLogSink m_sink;
  std::string m_line;
};
} // namespace

ScriptingContextFactory makeLoggingScriptingContextFactory(
    ScriptingLogSink sink)
{
  if (!sink)
  {
    return nullptr;
  }
  return [sink = std::move(sink)](
             Factory* factory) -> std::unique_ptr<ScriptingContext> {
    return std::make_unique<LoggingScriptingContext>(factory, sink);
  };
}
} // namespace rive

#else // !WITH_RIVE_SCRIPTING

namespace rive
{
ScriptingContextFactory makeLoggingScriptingContextFactory(ScriptingLogSink)
{
  return nullptr;
}
} // namespace rive

#endif