LogBuffer.cpp

#include "LogBuffer.h"

#include "XPLMUtilities.h"

#include <algorithm>
#include <fstream>
#include <mutex>
#include <string>

namespace vr_image_client
{

namespace
{

std::string ConvertHfsPathToPosix(const std::string &hfs_path)
{
    const auto first_colon = hfs_path.find(':');
    if (first_colon == std::string::npos)
    {
        return hfs_path;
    }
    std::string volume = hfs_path.substr(0, first_colon);
    std::string remainder = hfs_path.substr(first_colon + 1);
    std::replace(remainder.begin(), remainder.end(), ':', '/');
    std::string result("/Volumes/");
    result.append(volume);
    if (!remainder.empty() && remainder.front() != '/')
    {
        result.push_back('/');
    }
    result.append(remainder);
    return result;
}

std::string ResolveLogFilePath()
{
    char system_path[1024] = {0};
    XPLMGetSystemPath(system_path);
    std::string path(system_path);
    const char *separator = XPLMGetDirectorySeparator();
    char separator_char = (separator != nullptr && separator[0] != '\0') ? separator[0] : '/';
    if (separator_char == ':' && path.find('/') == std::string::npos)
    {
        path = ConvertHfsPathToPosix(path);
        separator_char = '/';
    }
    if (!path.empty() && path.back() != separator_char)
    {
        path.push_back(separator_char);
    }
    path.append("VR_Plugin.txt");
    return path;
}

const std::string &GetLogFilePath()
{
    static const std::string path = ResolveLogFilePath();
    return path;
}

std::mutex &LogFileMutex()
{
    static std::mutex mutex;
    return mutex;
}

bool OpenLogFile(std::ofstream &file, std::ios::openmode mode)
{
    const std::string &path = GetLogFilePath();
    file.open(path, mode);
    if (!file)
    {
        static bool reported = false;
        if (!reported)
        {
            reported = true;
            XPLMDebugString("[VR_ImageClient] Failed to open VR_Plugin.txt for logging.\n");
        }
        return false;
    }
    return true;
}

void AppendUnlocked(const std::string &message)
{
    std::ofstream file;
    if (!OpenLogFile(file, std::ios::out | std::ios::app))
    {
        if (!message.empty())
        {
            XPLMDebugString(message.c_str());
        }
        return;
    }
    file << message;
}

} // namespace

void LogBuffer::Push(const std::string &message)
{
    std::lock_guard<std::mutex> lock(mutex_);
    queue_.push_back(message);
}

void LogBuffer::Flush()
{
    std::deque<std::string> drained;
    {
        std::lock_guard<std::mutex> lock(mutex_);
        drained.swap(queue_);
    }
    for (const auto &line : drained)
    {
        WriteToPluginLog(line);
    }
}

void InitializePluginLog()
{
    std::lock_guard<std::mutex> lock(LogFileMutex());
    std::ofstream file;
    OpenLogFile(file, std::ios::out | std::ios::trunc);
}

void WriteToPluginLog(const std::string &message)
{
    std::lock_guard<std::mutex> lock(LogFileMutex());
    AppendUnlocked(message);
}

void WriteToPluginLog(const char *message)
{
    if (message == nullptr)
    {
        return;
    }
    WriteToPluginLog(std::string(message));
}

} // namespace vr_image_client