#include "DebugDataSaver.h"
#include "LaserDataLoader.h"
#include "VrError.h"
#include "VrLog.h"

#include <QCoreApplication>
#include <QDateTime>
#include <QDir>
#include <QDirIterator>
#include <QFile>
#include <QFileInfo>
#include <QString>

#include <algorithm>
#include <cstring>
#include <utility>
#include <chrono>
#include <iomanip>
#include <limits>
#include <stdexcept>

namespace {

std::pair<size_t, size_t> PointStorageSizes(EVzResultDataType dataType)
{
    switch (dataType) {
    case keResultDataType_Position:
        return {sizeof(SVzNL3DPosition), sizeof(SVzNL2DPosition)};
    case keResultDataType_PositionF:
        return {sizeof(SVzNL3DPosition), sizeof(SVzNL2DPositionF)};
    case keResultDataType_PointXYZRGBA:
        return {sizeof(SVzNLPointXYZRGBA), sizeof(SVzNL2DLRPoint)};
    case keResultDataType_PointXYZI:
        return {sizeof(SVzNLPointXYZI), sizeof(SVzNL2DLRPoint)};
    default:
        return {0, 0};
    }
}

QString AppName()
{
    QString name = QFileInfo(QCoreApplication::applicationFilePath()).baseName();
    if (name.isEmpty()) {
        name = QStringLiteral("app");
    }
    return name;
}

// 调试目录按 <应用名>_<年月日> 划分，同一天的扫描数据、二维图和结果文本放在一起。
QString SubDirPrefix()
{
    return AppName() + QStringLiteral("_");
}

// 只认 <应用名>_<yyyyMMdd>；旧版本 <应用名>_PointCloud_<yyyyMMdd> 同样纳入
// 容量管理，避免升级后历史目录不再参与清理。删除逻辑依赖该判断，
// 不能放宽成一个前缀匹配，否则可能误删同名开头的其它目录。
bool MatchesDebugSubDir(const QString& dirName)
{
    const QString prefix = SubDirPrefix();
    if (!dirName.startsWith(prefix))
    {
        return false;
    }
    const QString legacyTag = QStringLiteral("PointCloud_");
    QString suffix = dirName.mid(prefix.size());
    if (suffix.startsWith(legacyTag))
    {
        suffix = suffix.mid(legacyTag.size());
    }
    if (suffix.size() != 8)
    {
        return false;
    }
    for (const QChar ch : suffix)
    {
        if (!ch.isDigit())
        {
            return false;
        }
    }
    return true;
}

std::string NormalizeBasePath(const std::string& basePath)
{
    return QDir(QString::fromStdString(basePath)).absolutePath().toStdString();
}

std::string NormalizeFilePath(const std::string& filePath)
{
    return QFileInfo(QString::fromStdString(filePath)).absoluteFilePath().toStdString();
}

} // namespace

DebugDataSaver::DebugDataSaver(int maxThreads)
    : m_maxThreads(std::max(1, std::min(maxThreads, 4)))
    , m_running(true)
{
    for (int i = 0; i < m_maxThreads; ++i) {
        m_workers.emplace_back(&DebugDataSaver::WorkerThread, this);
    }
    LOG_INFO("[DebugDataSaver] started %d storage threads\n", m_maxThreads);
}

DebugDataSaver::~DebugDataSaver()
{
    Stop();
}

void DebugDataSaver::Stop()
{
    FinishAllStreams();
    if (!m_running.exchange(false)) {
        return;
    }

    m_queueCondition.notify_all();

    for (auto& worker : m_workers) {
        if (worker.joinable()) {
            worker.join();
        }
    }
    m_workers.clear();

    std::lock_guard<std::mutex> lock(m_queueMutex);
    while (!m_taskQueue.empty()) {
        FreeData(m_taskQueue.front().data);
        m_taskQueue.pop();
    }

    LOG_INFO("[DebugDataSaver] stopped\n");
}

void DebugDataSaver::SetMaxQueueSize(int maxTasks)
{
    if (maxTasks < 1) {
        maxTasks = 1;
    }
    m_maxQueueSize = maxTasks;
}

void DebugDataSaver::PrepareStorageCache(const std::string& basePath)
{
    std::lock_guard<std::mutex> lock(m_diskSpaceMutex);
    StorageCache& cache = m_storageCaches[NormalizeBasePath(basePath)];
    if (!cache.initialized) {
        BuildStorageCacheLocked(basePath, cache);
        LOG_INFO("[DebugDataSaver] storage cache ready: %s, files=%zu, size=%lld\n",
                 basePath.c_str(), cache.files.size(), static_cast<long long>(cache.totalSize));
    }
    EnsureStorageLimitLocked(basePath, cache);
}

uint64_t DebugDataSaver::GetLineStorageSize(EVzResultDataType dataType, const SVzLaserLineData& line)
{
    if (line.nPointCount < 0) return 0;
    const auto sizes = PointStorageSizes(dataType);
    if (sizes.first == 0) return 0;
    return sizeof(StreamLine) + static_cast<uint64_t>(sizes.first + sizes.second) * line.nPointCount;
}

bool DebugDataSaver::StartStream(int cameraIndex, const std::string& basePath,
                                 const std::string& timestamp, const std::string& deviceName)
{
    FinishStream(cameraIndex, false);
    if (!m_running.load()) return false;
    PrepareStorageCache(basePath);
    auto task = std::make_shared<StreamTask>();
    task->basePath = basePath;
    const QString requested = QString::fromStdString(GenerateSavePath(basePath, timestamp, deviceName));
    const QFileInfo info(requested);
    if (!info.absoluteDir().mkpath(QStringLiteral("."))) return false;
    QString path = requested;
    int suffix = 0;
    while (QFileInfo::exists(path) || QFileInfo::exists(path + QStringLiteral(".part"))) {
        path = info.absoluteDir().filePath(info.completeBaseName() + QStringLiteral("_%1.txt").arg(++suffix));
    }
    task->filePath = path.toStdString();
    task->output.open(task->filePath + ".part", std::ios::binary | std::ios::trunc);
    task->output << "LineNum:" << std::left << std::setw(20) << 0
                 << "\nDataType:0\nScanSpeed:0\nPointAdjust: 1\nMaxTimeStamp:0_0\n";
    task->output.flush();
    if (!task->output.good()) {
        LOG_ERROR("[DebugDataSaver] stream open failed: %s\n", task->filePath.c_str());
        return false;
    }
    {
        std::lock_guard<std::mutex> lock(m_streamMutex);
        m_streams[cameraIndex] = task;
        try {
            task->worker = std::thread(&DebugDataSaver::StreamWorker, task);
        } catch (const std::exception& error) {
            m_streams.erase(cameraIndex);
            LOG_ERROR("[DebugDataSaver] stream worker failed: %s\n", error.what());
            return false;
        }
    }
    LOG_INFO("[DebugDataSaver] streaming TXT started: %s\n", task->filePath.c_str());
    return true;
}

bool DebugDataSaver::AppendStream(int cameraIndex, EVzResultDataType dataType, const SVzLaserLineData& line)
{
    std::shared_ptr<StreamTask> task;
    std::unique_lock<std::mutex> appendLock;
    {
        std::lock_guard<std::mutex> lock(m_streamMutex);
        const auto entry = m_streams.find(cameraIndex);
        if (entry == m_streams.end()) return true;
        task = entry->second;
        appendLock = std::unique_lock<std::mutex>(task->appendMutex);
    }
    try {
        const uint64_t bytes = GetLineStorageSize(dataType, line);
        if (bytes == 0 || (line.nPointCount > 0 && !line.p3DPoint)) {
            throw std::runtime_error("Invalid point-cloud line");
        }
        auto copy = std::make_unique<StreamLine>();
        copy->dataType = dataType;
        copy->line = line;
        copy->line.p3DPoint = nullptr;
        copy->line.p2DPoint = nullptr;
        copy->bytes = static_cast<size_t>(bytes);
        const auto sizes = PointStorageSizes(dataType);
        if (line.nPointCount > 0) {
            const size_t bytes3D = sizes.first * line.nPointCount;
            const size_t bytes2D = sizes.second * line.nPointCount;
            copy->points3D = std::make_unique<unsigned char[]>(bytes3D);
            std::memcpy(copy->points3D.get(), line.p3DPoint, bytes3D);
            copy->points2D = std::make_unique<unsigned char[]>(bytes2D);
            if (line.p2DPoint) std::memcpy(copy->points2D.get(), line.p2DPoint, bytes2D);
            copy->line.p3DPoint = copy->points3D.get();
            copy->line.p2DPoint = copy->points2D.get();
        }
        std::lock_guard<std::mutex> lock(task->queueMutex);
        if (task->closing || task->failed) return false;
        task->lines.push(std::move(copy));
        task->queuedBytes += bytes;
        task->condition.notify_all();
        return true;
    } catch (const std::exception& error) {
        std::lock_guard<std::mutex> lock(task->queueMutex);
        task->failed = true;
        task->condition.notify_all();
        LOG_ERROR("[DebugDataSaver] stream enqueue failed: %s\n", error.what());
        return false;
    }
}

void DebugDataSaver::StreamWorker(const std::shared_ptr<StreamTask>& task)
{
    try {
        auto lastFlush = std::chrono::steady_clock::now();
        while (true) {
            std::unique_ptr<StreamLine> line;
            {
                std::unique_lock<std::mutex> lock(task->queueMutex);
                task->condition.wait_for(lock, std::chrono::milliseconds(500), [&]() {
                    return task->closing || task->failed || !task->lines.empty();
                });
                if (task->lines.empty() && (task->closing || task->failed)) break;
                if (!task->lines.empty()) {
                    line = std::move(task->lines.front());
                    task->lines.pop();
                }
            }
            if (line && !LaserDataLoader::WriteLaserScanLine(task->output, line->dataType, line->line)) {
                throw std::runtime_error("Point-cloud TXT write failed");
            }
            const auto now = std::chrono::steady_clock::now();
            if (now - lastFlush >= std::chrono::milliseconds(500)) {
                task->output.flush();
                lastFlush = now;
            }
            std::lock_guard<std::mutex> lock(task->queueMutex);
            if (line) task->queuedBytes -= line->bytes;
            if (!task->output.good()) {
                task->failed = true;
                task->condition.notify_all();
                LOG_ERROR("[DebugDataSaver] stream write failed: %s\n", task->filePath.c_str());
                break;
            }
            if (line) ++task->writtenLines;
            task->condition.notify_all();
        }
    } catch (const std::exception& error) {
        std::lock_guard<std::mutex> lock(task->queueMutex);
        task->failed = true;
        task->condition.notify_all();
        LOG_ERROR("[DebugDataSaver] stream worker failed: %s\n", error.what());
    }
}

bool DebugDataSaver::FinishStream(int cameraIndex, bool complete)
{
    std::shared_ptr<StreamTask> task;
    {
        std::lock_guard<std::mutex> lock(m_streamMutex);
        const auto entry = m_streams.find(cameraIndex);
        if (entry == m_streams.end()) return true;
        task = entry->second;
        m_streams.erase(entry);
    }
    std::lock_guard<std::mutex> appendLock(task->appendMutex);
    {
        std::lock_guard<std::mutex> lock(task->queueMutex);
        task->closing = true;
        task->condition.notify_all();
    }
    if (task->worker.joinable()) task->worker.join();
    task->output.seekp(sizeof("LineNum:") - 1);
    task->output << std::left << std::setw(20) << task->writtenLines;
    task->output.flush();
    const bool written = task->output.good() && !task->failed &&
                         task->writtenLines <= static_cast<uint64_t>((std::numeric_limits<int>::max)());
    task->output.close();
    bool success = written && task->output.good() && complete;
    std::string savedPath = task->filePath + ".part";
    if (success) {
        success = QFile::rename(QString::fromStdString(savedPath), QString::fromStdString(task->filePath));
        if (success) savedPath = task->filePath;
    }
    LOG_INFO("[DebugDataSaver] stream finished: complete=%d lines=%llu path=%s\n",
             success ? 1 : 0, static_cast<unsigned long long>(task->writtenLines), savedPath.c_str());
    RecordSavedFile(task->basePath, savedPath, true);
    return success;
}

void DebugDataSaver::FinishAllStreams()
{
    std::vector<int> cameras;
    {
        std::lock_guard<std::mutex> lock(m_streamMutex);
        for (const auto& entry : m_streams) cameras.push_back(entry.first);
    }
    for (int cameraIndex : cameras) FinishStream(cameraIndex, false);
}

void DebugDataSaver::SaveAsync(const std::string& basePath,
                               const std::string& timestamp,
                               const std::vector<std::pair<EVzResultDataType, SVzLaserLineData>>& data,
                               const std::string& deviceName,
                               bool binary)
{
    if (data.empty() || !m_running.load()) {
        return;
    }

    const int maxQueueSize = m_maxQueueSize.load();
    {
        std::lock_guard<std::mutex> lock(m_queueMutex);
        if (static_cast<int>(m_taskQueue.size()) >= maxQueueSize) {
            LOG_WARNING("[DebugDataSaver] save queue full (%zu/%d), skip point cloud save: %s\n",
                        m_taskQueue.size(), maxQueueSize, deviceName.c_str());
            return;
        }
    }

    SaveTask task;
    task.basePath = basePath;
    task.deviceName = deviceName;
    task.binary = binary;
    task.filePath = GenerateSavePath(basePath, timestamp, deviceName, binary);
    if (!QFileInfo(QString::fromStdString(task.filePath)).absoluteDir().mkpath(QStringLiteral(".")))
    {
        LOG_ERROR("[DebugDataSaver] cannot create output directory: %s\n", task.filePath.c_str());
        return;
    }
    task.data = DeepCopyData(data);

    {
        std::lock_guard<std::mutex> lock(m_queueMutex);
        if (static_cast<int>(m_taskQueue.size()) >= maxQueueSize) {
            LOG_WARNING("[DebugDataSaver] save queue full after copy (%zu/%d), skip point cloud save: %s\n",
                        m_taskQueue.size(), maxQueueSize, deviceName.c_str());
            FreeData(task.data);
            return;
        }
        m_taskQueue.push(std::move(task));
    }
    m_queueCondition.notify_one();
}

void DebugDataSaver::WorkerThread()
{
    LaserDataLoader dataLoader;

    while (true) {
        SaveTask task;
        {
            std::unique_lock<std::mutex> lock(m_queueMutex);
            m_queueCondition.wait(lock, [this] {
                return !m_taskQueue.empty() || !m_running.load();
            });

            if (!m_running.load() && m_taskQueue.empty()) {
                break;
            }
            if (m_taskQueue.empty()) {
                continue;
            }

            task = std::move(m_taskQueue.front());
            m_taskQueue.pop();
        }

        int lineNum = static_cast<int>(task.data.size());
        float scanSpeed = 0.0f;
        int maxTimeStamp = 0;
        int clockPerSecond = 0;

        int result = task.binary
            ? dataLoader.SaveLaserScanDataBinary(task.filePath, task.data, lineNum, scanSpeed, maxTimeStamp, clockPerSecond)
            : dataLoader.SaveLaserScanData(task.filePath, task.data, lineNum, scanSpeed, maxTimeStamp, clockPerSecond);

        if (result == SUCCESS) {
            RecordSavedFile(task.basePath, task.filePath);
            LOG_INFO("[DebugDataSaver] saved: %s lines=%d firstFrame=%llu lastFrame=%llu\n",
                     task.filePath.c_str(), lineNum,
                     task.data.front().second.llFrameIdx, task.data.back().second.llFrameIdx);
        } else {
            LOG_ERROR("[DebugDataSaver] save failed: %s, error: %s\n", task.filePath.c_str(), dataLoader.GetLastError().c_str());
            // 失败文件也计入空间管理，避免磁盘写满后残留文件长期绕过容量限制。
            RecordSavedFile(task.basePath, task.filePath);
        }

        FreeData(task.data);
    }
}

std::vector<std::pair<EVzResultDataType, SVzLaserLineData>> DebugDataSaver::DeepCopyData(
    const std::vector<std::pair<EVzResultDataType, SVzLaserLineData>>& src)
{
    std::vector<std::pair<EVzResultDataType, SVzLaserLineData>> dst;
    dst.reserve(src.size());

    for (const auto& item : src) {
        EVzResultDataType dataType = item.first;
        const SVzLaserLineData& srcLine = item.second;

        SVzLaserLineData dstLine;
        memset(&dstLine, 0, sizeof(SVzLaserLineData));

        if (srcLine.nPointCount > 0) {
            if (dataType == keResultDataType_Position) {
                dstLine.p3DPoint = new SVzNL3DPosition[srcLine.nPointCount]();
                if (srcLine.p3DPoint) {
                    memcpy(dstLine.p3DPoint, srcLine.p3DPoint, sizeof(SVzNL3DPosition) * srcLine.nPointCount);
                }
                dstLine.p2DPoint = new SVzNL2DPosition[srcLine.nPointCount]();
                if (srcLine.p2DPoint) {
                    memcpy(dstLine.p2DPoint, srcLine.p2DPoint, sizeof(SVzNL2DPosition) * srcLine.nPointCount);
                }
            } else if (dataType == keResultDataType_PositionF) {
                dstLine.p3DPoint = new SVzNL3DPosition[srcLine.nPointCount]();
                if (srcLine.p3DPoint) {
                    memcpy(dstLine.p3DPoint, srcLine.p3DPoint, sizeof(SVzNL3DPosition) * srcLine.nPointCount);
                }
                dstLine.p2DPoint = new SVzNL2DPositionF[srcLine.nPointCount]();
                if (srcLine.p2DPoint) {
                    memcpy(dstLine.p2DPoint, srcLine.p2DPoint, sizeof(SVzNL2DPositionF) * srcLine.nPointCount);
                }
            } else if (dataType == keResultDataType_PointXYZRGBA) {
                dstLine.p3DPoint = new SVzNLPointXYZRGBA[srcLine.nPointCount]();
                if (srcLine.p3DPoint) {
                    memcpy(dstLine.p3DPoint, srcLine.p3DPoint, sizeof(SVzNLPointXYZRGBA) * srcLine.nPointCount);
                }
                dstLine.p2DPoint = new SVzNL2DLRPoint[srcLine.nPointCount]();
                if (srcLine.p2DPoint) {
                    memcpy(dstLine.p2DPoint, srcLine.p2DPoint, sizeof(SVzNL2DLRPoint) * srcLine.nPointCount);
                }
            } else if (dataType == keResultDataType_PointXYZI) {
                dstLine.p3DPoint = new SVzNLPointXYZI[srcLine.nPointCount]();
                if (srcLine.p3DPoint) {
                    memcpy(dstLine.p3DPoint, srcLine.p3DPoint, sizeof(SVzNLPointXYZI) * srcLine.nPointCount);
                }
                dstLine.p2DPoint = new SVzNL2DLRPoint[srcLine.nPointCount]();
                if (srcLine.p2DPoint) {
                    memcpy(dstLine.p2DPoint, srcLine.p2DPoint, sizeof(SVzNL2DLRPoint) * srcLine.nPointCount);
                }
            }
        }

        dstLine.nPointCount = srcLine.nPointCount;
        dstLine.dTotleOffset = srcLine.dTotleOffset;
        dstLine.dStep = srcLine.dStep;
        dstLine.llTimeStamp = srcLine.llTimeStamp;
        dstLine.llFrameIdx = srcLine.llFrameIdx;
        dstLine.nEncodeNo = srcLine.nEncodeNo;
        dstLine.fSwingAngle = srcLine.fSwingAngle;
        dstLine.bEndOnceScan = srcLine.bEndOnceScan;

        dst.push_back(std::make_pair(dataType, dstLine));
    }

    return dst;
}

void DebugDataSaver::FreeData(std::vector<std::pair<EVzResultDataType, SVzLaserLineData>>& data)
{
    LaserDataLoader loader;
    loader.FreeLaserScanData(data);
    data.clear();
}

std::string DebugDataSaver::GenerateSavePath(const std::string& basePath, const std::string& timestamp, const std::string& deviceName, bool binary)
{
    const QString timestampText = QString::fromStdString(timestamp);
    const QString dateDirectory = SubDirPrefix() + timestampText.left(8);
    const QString fullPath = QDir(QString::fromStdString(basePath))
        .filePath(dateDirectory);

    QString name = deviceName.empty() ? QStringLiteral("pointcloud")
                                      : QString::fromStdString(deviceName);
    QString fileName = QString("%1/%2_%3.%4").arg(fullPath)
                           .arg(name)
                           .arg(QString::fromStdString(timestamp))
                           .arg(binary ? QStringLiteral("dat") : QStringLiteral("txt"));

    return fileName.toStdString();
}

void DebugDataSaver::EnsureStorageLimit(const std::string& basePath)
{
    std::lock_guard<std::mutex> lock(m_diskSpaceMutex);
    StorageCache& cache = m_storageCaches[NormalizeBasePath(basePath)];
    if (!cache.initialized) {
        BuildStorageCacheLocked(basePath, cache);
    }
    EnsureStorageLimitLocked(basePath, cache);
}

void DebugDataSaver::EnsureStorageLimitLocked(const std::string& basePath, StorageCache& cache,
                                             const std::string& protectedPath)
{
    Q_UNUSED(basePath);

    const int64_t limit = m_maxStorageSize.load();
    if (limit <= 0) {
        return;
    }

    while (cache.totalSize > limit && !cache.files.empty()) {
        auto candidate = std::find_if(cache.files.begin(), cache.files.end(), [&](const StorageFileInfo& file) {
            return file.path != protectedPath;
        });
        if (candidate == cache.files.end()) break;
        StorageFileInfo oldest = *candidate;
        cache.files.erase(candidate);

        QString filePath = QString::fromStdString(oldest.path);
        QFileInfo info(filePath);
        QString parentPath = info.absolutePath();
        int64_t fileSize = oldest.size;

        if (QFileInfo::exists(filePath) && !QFile::remove(filePath)) {
            cache.files.insert(cache.files.begin(), oldest);
            LOG_ERROR("[DebugDataSaver] delete failed: %s\n", oldest.path.c_str());
            break;
        }

        cache.totalSize -= fileSize;
        if (cache.totalSize < 0) {
            cache.totalSize = 0;
        }

        LOG_INFO("[DebugDataSaver] storage limit exceeded, delete oldest file: %s (%lld bytes)\n",
                 oldest.path.c_str(), static_cast<long long>(fileSize));

        QDir parentDir(parentPath);
        const QString parentName = parentDir.dirName();
        if (MatchesDebugSubDir(parentName) && parentDir.isEmpty()) {
            parentDir.cdUp();
            if (parentDir.rmdir(parentName)) {
                LOG_INFO("[DebugDataSaver] removed empty directory: %s\n", parentPath.toStdString().c_str());
            }
        }
    }
}

void DebugDataSaver::BuildStorageCacheLocked(const std::string& basePath, StorageCache& cache)
{
    cache.files.clear();
    cache.totalSize = 0;

    QDir rootDir(QString::fromStdString(basePath));
    if (rootDir.exists()) {
        const QStringList subDirs = rootDir.entryList(QDir::Dirs | QDir::NoDotAndDotDot);
        for (const QString& name : subDirs) {
            if (!MatchesDebugSubDir(name)) {
                continue;
            }
            QString subPath = rootDir.absoluteFilePath(name);
            QDirIterator it(subPath, QStringList() << "*.txt" << "*.dat", QDir::Files, QDirIterator::Subdirectories);
            while (it.hasNext()) {
                it.next();
                QFileInfo info = it.fileInfo();
                StorageFileInfo fileInfo;
                fileInfo.path = info.absoluteFilePath().toStdString();
                fileInfo.size = info.size();
                fileInfo.lastModifiedMSecs = info.lastModified().toMSecsSinceEpoch();
                cache.totalSize += fileInfo.size;
                cache.files.push_back(fileInfo);
            }
        }
    }

    std::sort(cache.files.begin(), cache.files.end(), DebugDataSaver::IsOlderFile);
    cache.initialized = true;
}

void DebugDataSaver::AddFileToCacheLocked(StorageCache& cache, const StorageFileInfo& fileInfo)
{
    RemoveFileFromCache(cache, fileInfo.path);
    auto it = std::lower_bound(cache.files.begin(), cache.files.end(), fileInfo, DebugDataSaver::IsOlderFile);
    cache.files.insert(it, fileInfo);
    cache.totalSize += fileInfo.size;
}

void DebugDataSaver::RecordSavedFile(const std::string& basePath, const std::string& filePath, bool protectFile)
{
    std::lock_guard<std::mutex> lock(m_diskSpaceMutex);
    StorageCache& cache = m_storageCaches[NormalizeBasePath(basePath)];
    if (!cache.initialized) {
        BuildStorageCacheLocked(basePath, cache);
    }

    std::string normalizedFilePath = NormalizeFilePath(filePath);
    QFileInfo info(QString::fromStdString(normalizedFilePath));
    if (info.exists() && info.isFile()) {
        StorageFileInfo fileInfo;
        fileInfo.path = normalizedFilePath;
        fileInfo.size = info.size();
        fileInfo.lastModifiedMSecs = info.lastModified().toMSecsSinceEpoch();
        AddFileToCacheLocked(cache, fileInfo);
    }

    EnsureStorageLimitLocked(basePath, cache, protectFile ? normalizedFilePath : std::string());
}

bool DebugDataSaver::RemoveFileFromCache(StorageCache& cache, const std::string& filePath)
{
    auto it = std::find_if(cache.files.begin(), cache.files.end(), [&filePath](const StorageFileInfo& item) {
        return item.path == filePath;
    });
    if (it == cache.files.end()) {
        return false;
    }

    cache.totalSize -= it->size;
    if (cache.totalSize < 0) {
        cache.totalSize = 0;
    }
    cache.files.erase(it);
    return true;
}

bool DebugDataSaver::IsOlderFile(const StorageFileInfo& lhs, const StorageFileInfo& rhs)
{
    if (lhs.lastModifiedMSecs == rhs.lastModifiedMSecs) {
        return lhs.path < rhs.path;
    }
    return lhs.lastModifiedMSecs < rhs.lastModifiedMSecs;
}

int64_t DebugDataSaver::ComputeDirSize(const std::string& rootPath)
{
    QDir rootDir(QString::fromStdString(rootPath));
    if (!rootDir.exists()) {
        return 0;
    }

    int64_t total = 0;
    const QStringList subDirs = rootDir.entryList(QDir::Dirs | QDir::NoDotAndDotDot);
    for (const QString& name : subDirs) {
        if (!MatchesDebugSubDir(name)) {
            continue;
        }
        QString subPath = rootDir.absoluteFilePath(name);
        QDirIterator it(subPath, QStringList() << "*.txt" << "*.dat", QDir::Files, QDirIterator::Subdirectories);
        while (it.hasNext()) {
            it.next();
            total += it.fileInfo().size();
        }
    }
    return total;
}

std::string DebugDataSaver::FindOldestFile(const std::string& rootPath)
{
    QDir rootDir(QString::fromStdString(rootPath));
    if (!rootDir.exists()) {
        return std::string();
    }

    QString oldestPath;
    QDateTime oldestTime;
    bool first = true;

    const QStringList subDirs = rootDir.entryList(QDir::Dirs | QDir::NoDotAndDotDot);
    for (const QString& name : subDirs) {
        if (!MatchesDebugSubDir(name)) {
            continue;
        }
        QString subPath = rootDir.absoluteFilePath(name);
        QDirIterator it(subPath, QStringList() << "*.txt" << "*.dat", QDir::Files, QDirIterator::Subdirectories);
        while (it.hasNext()) {
            it.next();
            QFileInfo info = it.fileInfo();
            QDateTime mtime = info.lastModified();
            if (first || mtime < oldestTime) {
                oldestTime = mtime;
                oldestPath = info.absoluteFilePath();
                first = false;
            }
        }
    }

    return oldestPath.toStdString();
}