#ifndef DEVICE_CTRL_FILE_UTIL_H
#define DEVICE_CTRL_FILE_UTIL_H
#include <filesystem>
#include <fstream>
#include "common/spdlog/logging.h"

namespace zsy::FileUtil
{
    /**
     * 创建文件夹（递归）
     *
     * @param path 文件夹
     */
    inline void createDir(const std::filesystem::path &path)
    {
        try
        {
            if (!std::filesystem::exists(path))
            {
                if (!std::filesystem::create_directories(path))
                {
                    LOGGER_ERROR("创建文件夹失败");
                }
            }
        } catch (const std::filesystem::filesystem_error &e)
        {
            LOGGER_ERROR("创建文件夹失败：{}", e.what());
        } catch (const std::exception &e)
        {
            LOGGER_ERROR("创建文件夹时发生错误：{}", e.what());
        } catch (...)
        {
            LOGGER_ERROR("创建文件夹时发生未知错误");
        }
    }

    inline std::vector<uint8_t> readBytes(const std::string &filePath)
    {
        std::vector<uint8_t> fileBytes;

        if (filePath.empty())
        {
            LOGGER_ERROR("文件读取失败，未指定文件地址");
            return fileBytes;
        }

        if (!std::filesystem::exists(filePath))
        {
            LOGGER_ERROR("文件不存在：{}", filePath);
            return fileBytes;
        }

        std::uintmax_t fileSize = 0;
        try
        {
            fileSize = std::filesystem::file_size(filePath);
        } catch (const std::filesystem::filesystem_error &e)
        {
            LOGGER_ERROR("获取文件大小失败，{}", e.what());
            return fileBytes;
        }

        std::ifstream file(filePath, std::ios::binary);
        if (!file.is_open())
        {
            LOGGER_ERROR("错误: 无法打开文件 {}", filePath);
            return fileBytes;
        }

        fileBytes.reserve(fileSize);

        constexpr std::size_t bufferSize = 4096;
        char buffer[bufferSize];

        while (file.read(buffer, bufferSize))
        {
            fileBytes.insert(fileBytes.end(), buffer, buffer + bufferSize);
        }

        std::streamsize remainingBytes = file.gcount();
        if (remainingBytes > 0)
        {
            fileBytes.insert(fileBytes.end(), buffer, buffer + remainingBytes);
        }

        if (!file.eof())
        {
            LOGGER_ERROR("错误: 读取文件 '{}' 时发生错误", filePath);
            fileBytes.clear();
            return fileBytes;
        }
        return fileBytes;
    }

    inline bool exists(const std::string &filePath)
    {
        return std::filesystem::exists(filePath);
    }

    inline std::string read(const std::string &filePath)
    {
        std::vector<uint8_t> fileBytes = readBytes(filePath);
        return {fileBytes.begin(), fileBytes.end()};
    }

    inline void remove(const std::string &photographPath)
    {
        if (!photographPath.empty())
        {
            if (std::remove(photographPath.c_str()) != 0)
            {
                LOGGER_ERROR("文件删除失败：{}", photographPath);
            }
        } else
        {
            LOGGER_ERROR("文件删除失败，未指定文件地址");
        }
    }

    /**
         * 写入文件
         *
         * @param filePath 文件路径
         * @param content 文件内容
         */
    inline void writeFile(const std::string &filePath, const std::string &content)
    {
        std::ofstream file(filePath, std::ios::binary);
        if (!file.is_open())
        {
            LOGGER_ERROR("错误: 无法打开文件 {}", filePath);
            return;
        }
        file.write(content.data(), content.size());
        if (!file.flush())
        {
            LOGGER_ERROR("错误: 写入文件 '{}' 时发生错误", filePath);
        }
    }
}
#endif //DEVICE_CTRL_FILE_UTIL_H