GrabBag/AppUtils/AppCommon/Inc/DebugDataSaver.h

#ifndef DEBUG_DATA_SAVER_H
#define DEBUG_DATA_SAVER_H

#include <atomic>
#include <condition_variable>
#include <cstdint>
#include <map>
#include <mutex>
#include <queue>
#include <string>
#include <thread>
#include <utility>
#include <vector>

#include "VZNL_Types.h"

class DebugDataSaver
{
public:
    explicit DebugDataSaver(int maxThreads = 4);
    ~DebugDataSaver();

    void SaveAsync(const std::string& basePath,
                   const std::string& timestamp,
                   const std::vector<std::pair<EVzResultDataType, SVzLaserLineData>>& data,
                   const std::string& deviceName = "");

    void Stop();

    void SetMaxStorageSize(int64_t bytes) { m_maxStorageSize = bytes; }
    void SetMaxQueueSize(int maxTasks);
    void PrepareStorageCache(const std::string& basePath);

private:
    struct SaveTask {
        std::string basePath;
        std::string filePath;
        std::string deviceName;
        std::vector<std::pair<EVzResultDataType, SVzLaserLineData>> data;
    };

    struct StorageFileInfo {
        std::string path;
        int64_t size = 0;
        int64_t lastModifiedMSecs = 0;
    };

    struct StorageCache {
        bool initialized = false;
        int64_t totalSize = 0;
        std::vector<StorageFileInfo> files;
    };

    void WorkerThread();

    static std::vector<std::pair<EVzResultDataType, SVzLaserLineData>> DeepCopyData(
        const std::vector<std::pair<EVzResultDataType, SVzLaserLineData>>& src);
    static void FreeData(std::vector<std::pair<EVzResultDataType, SVzLaserLineData>>& data);

    std::string GenerateSavePath(const std::string& basePath,
                                 const std::string& timestamp,
                                 const std::string& deviceName = "");

    void EnsureStorageLimit(const std::string& basePath);
    void EnsureStorageLimitLocked(const std::string& basePath, StorageCache& cache);
    void BuildStorageCacheLocked(const std::string& basePath, StorageCache& cache);
    void AddFileToCacheLocked(StorageCache& cache, const StorageFileInfo& fileInfo);
    void RecordSavedFile(const std::string& basePath, const std::string& filePath);

    static bool RemoveFileFromCache(StorageCache& cache, const std::string& filePath);
    static bool IsOlderFile(const StorageFileInfo& lhs, const StorageFileInfo& rhs);
    static int64_t ComputeDirSize(const std::string& rootPath);
    static std::string FindOldestFile(const std::string& rootPath);

    int m_maxThreads;
    std::vector<std::thread> m_workers;
    std::queue<SaveTask> m_taskQueue;
    std::mutex m_queueMutex;
    std::condition_variable m_queueCondition;
    std::atomic<bool> m_running;
    std::atomic<int> m_maxQueueSize{10};

    std::mutex m_diskSpaceMutex;
    std::atomic<int64_t> m_maxStorageSize{10LL * 1024 * 1024 * 1024};
    std::map<std::string, StorageCache> m_storageCaches;
};

#endif // DEBUG_DATA_SAVER_H