/*
 * Copyright (c) 2023 Fancy Code.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#include "IpcConfigImpl.h"
#include "ILog.h"
#include <dirent.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#define CHECK_MAP(map) (map.size() == 1 ? true : false)
const char *CONFIG_WIFI_SSID = "wifi_ssid";
const char *CONFIG_WIFI_SSID_DEFAULT = "Hunting 2024";
const char *CONFIG_WIFI_PASSWORD = "wifi_password";
const char *CONFIG_WIFI_PASSWORD_DEFAULT = "123456";
const char *CONFIG_WORK_MODE = "work_mode";
const char *CONFIG_CONTINUE_SHOT = "continuous_shot";
const char *CONFIG_BURST_PHOTO_INTERVAL = "continuous_interval";
const char *CONFIG_IMAGE_SIZE = "image_size";
const char *CONFIG_VIDEO_SIZE = "video_size";
const char *CONFIG_PIR_DELAYED = "pir_delayed";
const char *CONFIG_STORAGE_LOOP = "storage_loop";
const char *CONFIG_INFRARED_POWER = "infrared_power";
const char *CONFIG_PIR_SENSITIVITY = "pir_sensitivity";
IpcConfigImpl::IpcConfigImpl() : mThreadRuning(false), mCfgChanged(CONFIG_HAS_NOT_CHANGED), mCfg(nullptr)
{
    memset(&mAllData, 0, sizeof(Config_s));
    // std::map<std::string, std::reference_wrapper<int>> innerMapWorkMode;
    // innerMapWorkMode.insert(std::make_pair("work_mode", std::reference_wrapper<int>(mAllData.mWorkMode)));
    // mCfgMapInt.insert(std::make_pair(IpcConfigKey::WORK_MODE, innerMapWorkMode));

    // std::map<std::string, std::reference_wrapper<int>> innerMapContinuousShot;
    // innerMapContinuousShot.insert(
    //     std::make_pair("continuous_shot", std::reference_wrapper<int>(mAllData.mContinuousShot)));
    // mCfgMapInt.insert(std::make_pair(IpcConfigKey::CONTINUOUS_SHOT, innerMapContinuousShot));

    // std::map<std::string, std::reference_wrapper<int>> innerMapBurstPhotoInterval;
    // innerMapBurstPhotoInterval.insert(
    //     std::make_pair("burst_photo_interval", std::reference_wrapper<int>(mAllData.mBurstPhotoInterval)));
    // mCfgMapInt.insert(std::make_pair(IpcConfigKey::BURST_PHOTO_INTERVAL, innerMapBurstPhotoInterval));

    // std::map<std::string, std::reference_wrapper<CHAR_STRING>> innerMapImageSize;
    // innerMapImageSize.insert(std::make_pair("image_size", std::reference_wrapper<CHAR_STRING>(mAllData.imageSize)));
    // mCfgMapString.insert(std::make_pair(IpcConfigKey::IMGAE_SIZE, innerMapImageSize));

    // std::map<std::string, std::reference_wrapper<int>> innerMapVideoSize;
    // innerMapVideoSize.insert(std::make_pair("video_size", std::reference_wrapper<int>(mAllData.videoSize)));
    // mCfgMapInt.insert(std::make_pair(IpcConfigKey::VIDEO_LENGTH, innerMapVideoSize));

    // std::map<std::string, std::reference_wrapper<int>> innerMapInfraredLampPower;
    // innerMapInfraredLampPower.insert(
    //     std::make_pair("infrared_lamp_power", std::reference_wrapper<int>(mAllData.mInfraredPower)));
    // mCfgMapInt.insert(std::make_pair(IpcConfigKey::INFRARED_POWER, innerMapInfraredLampPower));

    // std::map<std::string, std::reference_wrapper<int>> innerMapDelayed;
    // innerMapDelayed.insert(std::make_pair("delayed", std::reference_wrapper<int>(mAllData.delayed)));
    // mCfgMapInt.insert(std::make_pair(IpcConfigKey::PIR_DELAYED, innerMapDelayed));

    // std::map<std::string, std::reference_wrapper<int>> innerMapPirSensitivity;
    // innerMapPirSensitivity.insert(
    //     std::make_pair("pir_sensitivity", std::reference_wrapper<int>(mAllData.mPirSensitivity)));
    // mCfgMapInt.insert(std::make_pair(IpcConfigKey::PIR_SENSITIVITY, innerMapPirSensitivity));

    // std::map<std::string, std::reference_wrapper<bool>> innerMapStorageLoopSwitch;
    // innerMapStorageLoopSwitch.insert(
    //     std::make_pair("storage_loop_switch", std::reference_wrapper<bool>(mAllData.mStorageLoopSwitch)));
    // mCfgMapBool.insert(std::make_pair(IpcConfigKey::STORAGE_LOOP_SWITCH, innerMapStorageLoopSwitch));

    // std::map<std::string, std::reference_wrapper<bool>> innerMapFactoryReset;
    // innerMapFactoryReset.insert(std::make_pair("factory_reset",
    // std::reference_wrapper<bool>(mAllData.factoryReset)));
    // mCfgMapBool.insert(std::make_pair(IpcConfigKey::FACTORY_RESET_FLAG, innerMapFactoryReset));

    // std::map<std::string, std::reference_wrapper<bool>> innerMapFormattingSDCard;
    // innerMapFormattingSDCard.insert(
    //     std::make_pair("formatting_SD_card", std::reference_wrapper<bool>(mAllData.formattingSDCard)));
    // mCfgMapBool.insert(std::make_pair(IpcConfigKey::FORMATTING_SD_CARD, innerMapFormattingSDCard));

    // std::map<std::string, std::reference_wrapper<CHAR_STRING>> innerMapDrakMode;
    // innerMapDrakMode.insert(std::make_pair("dark_mode", std::reference_wrapper<CHAR_STRING>(mAllData.darkMode)));
    // mCfgMapString.insert(std::make_pair(IpcConfigKey::DARK_MODE, innerMapDrakMode));

    // std::map<std::string, std::reference_wrapper<CHAR_STRING>> innerMapWorkInterval;
    // innerMapWorkInterval.insert(
    //     std::make_pair("work_interval", std::reference_wrapper<CHAR_STRING>(mAllData.workingInterval)));
    // mCfgMapString.insert(std::make_pair(IpcConfigKey::WORK_INTERVAL, innerMapWorkInterval));

    // std::map<std::string, std::reference_wrapper<short>> innerMapShort;
    // innerMapShort.insert(std::make_pair("test_short", std::reference_wrapper<short>(mAllData.testShort)));
    // mCfgMapShort.insert(std::make_pair(IpcConfigKey::TEST_SHORT, innerMapShort));

    // std::map<std::string, std::reference_wrapper<long>> innerMapLong;
    // innerMapLong.insert(std::make_pair("test_long", std::reference_wrapper<long>(mAllData.testLong)));
    // mCfgMapLong.insert(std::make_pair(IpcConfigKey::TEST_LONG, innerMapLong));

    // std::map<std::string, std::reference_wrapper<long long>> innerMapLLong;
    // innerMapLLong.insert(std::make_pair("test_llong", std::reference_wrapper<long long>(mAllData.testLLong)));
    // mCfgMapLLong.insert(std::make_pair(IpcConfigKey::TEST_LLONG, innerMapLLong));

    // std::map<std::string, std::reference_wrapper<char>> innerMapChar;
    // innerMapChar.insert(std::make_pair("test_char", std::reference_wrapper<char>(mAllData.testChar)));
    // mCfgMapChar.insert(std::make_pair(IpcConfigKey::TEST_CHAR, innerMapChar));

    // std::map<std::string, std::reference_wrapper<float>> innerMapFloat;
    // innerMapFloat.insert(std::make_pair("test_float", std::reference_wrapper<float>(mAllData.testFloat)));
    // mCfgMapFloat.insert(std::make_pair(IpcConfigKey::TEST_FLOAT, innerMapFloat));
}
const StatusCode IpcConfigImpl::Init(void)
{
    // memset(&mAllData, 0, sizeof(Config_s));
    // InitConfigMap();
    // mCfg = OpenConfigFile(IPC_CONFIG_FILE_PATH);
    // if (nullptr == mCfg) {
    //     LogError("Open config file failed.\n");
    //     return CreateStatusCode(STATUS_CODE_NOT_OK);
    // }
    // ReadAllConfigParameters();
    auto readingConfig = [](std::shared_ptr<IpcConfigImpl> impl) {
        impl->ReadingConfigThread();
    };
    std::shared_ptr<IpcConfigImpl> impl = shared_from_this();
    mInitThread = std::thread(readingConfig, impl);
    return CreateStatusCode(STATUS_CODE_OK);
}
const StatusCode IpcConfigImpl::UnInit(void)
{
    mThreadRuning = false;
    if (mInitThread.joinable()) {
        mInitThread.join();
    }
    std::lock_guard<std::mutex> locker(mMutex);
    if (CONFIG_HAS_CHANGED == mCfgChanged) {
        LogInfo("Save config files.\n");
        ConfigSaveFile(mCfg);
    }
    CloseConfigFile(mCfg);
    return CreateStatusCode(STATUS_CODE_OK);
}
const StatusCode IpcConfigImpl::ConfigFileSave(void)
{
    std::lock_guard<std::mutex> locker(mMutex);
    return ConfigSaveFile(mCfg);
}

const int IpcConfigImpl::GetInt(const IpcConfigKey &key)
{
    std::lock_guard<std::mutex> locker(mMutex);
    std::map<IpcConfigKey, std::map<std::string, int *>>::iterator iter;
    iter = mCfgMapIntV2.find(key);
    if (iter != mCfgMapIntV2.end() && CHECK_MAP(iter->second)) {
        return *(iter->second.begin()->second);
    }
    LogError("Can't find the key.\n");
    constexpr int UNKNOWN_CONFIG = -1;
    return UNKNOWN_CONFIG;
}
void IpcConfigImpl::SetInt(const IpcConfigKey &key, const int &value)
{
    std::lock_guard<std::mutex> locker(mMutex);
    std::map<IpcConfigKey, std::map<std::string, int *>>::iterator iter;
    iter = mCfgMapIntV2.find(key);
    if (iter != mCfgMapIntV2.end() && CHECK_MAP(iter->second)) {
        *(iter->second.begin()->second) = value;
        ConfigSetInt(mCfg, iter->second.begin()->first.c_str(), *(iter->second.begin()->second));
        mCfgChanged = CONFIG_HAS_CHANGED;
    }
    else {
        LogError("Can't find the key.\n");
    }
}
const short IpcConfigImpl::GetShort(const IpcConfigKey &key)
{
    std::lock_guard<std::mutex> locker(mMutex);
    std::map<IpcConfigKey, std::map<std::string, std::reference_wrapper<short>>>::iterator iter;
    iter = mCfgMapShort.find(key);
    if (iter != mCfgMapShort.end() && CHECK_MAP(iter->second)) {
        return iter->second.begin()->second;
    }
    LogError("Can't find the key.\n");
    constexpr short UNKNOWN_CONFIG = -1;
    return UNKNOWN_CONFIG;
}
void IpcConfigImpl::SetShort(const IpcConfigKey &key, const short &value)
{
    std::lock_guard<std::mutex> locker(mMutex);
    std::map<IpcConfigKey, std::map<std::string, std::reference_wrapper<short>>>::iterator iter;
    iter = mCfgMapShort.find(key);
    if (iter != mCfgMapShort.end() && CHECK_MAP(iter->second)) {
        iter->second.begin()->second.get() = value;
        const char *name = iter->second.begin()->first.c_str();
        ConfigSetShort(mCfg, name, iter->second.begin()->second);
        mCfgChanged = CONFIG_HAS_CHANGED;
    }
    else {
        LogError("Can't find the key.\n");
    }
}
const long IpcConfigImpl::GetLong(const IpcConfigKey &key)
{
    std::lock_guard<std::mutex> locker(mMutex);
    std::map<IpcConfigKey, std::map<std::string, std::reference_wrapper<long>>>::iterator iter;
    iter = mCfgMapLong.find(key);
    if (iter != mCfgMapLong.end() && CHECK_MAP(iter->second)) {
        return iter->second.begin()->second;
    }
    LogError("Can't find the key.\n");
    constexpr long UNKNOWN_CONFIG = -1;
    return UNKNOWN_CONFIG;
}
void IpcConfigImpl::SetLong(const IpcConfigKey &key, const long &value)
{
    std::lock_guard<std::mutex> locker(mMutex);
    std::map<IpcConfigKey, std::map<std::string, std::reference_wrapper<long>>>::iterator iter;
    iter = mCfgMapLong.find(key);
    if (iter != mCfgMapLong.end() && CHECK_MAP(iter->second)) {
        iter->second.begin()->second.get() = value;
        const char *name = iter->second.begin()->first.c_str();
        ConfigSetLong(mCfg, name, iter->second.begin()->second);
        mCfgChanged = CONFIG_HAS_CHANGED;
    }
    else {
        LogError("Can't find the key.\n");
    }
}
const long long IpcConfigImpl::GetLLong(const IpcConfigKey &key)
{
    std::lock_guard<std::mutex> locker(mMutex);
    std::map<IpcConfigKey, std::map<std::string, std::reference_wrapper<long long>>>::iterator iter;
    iter = mCfgMapLLong.find(key);
    if (iter != mCfgMapLLong.end() && CHECK_MAP(iter->second)) {
        return iter->second.begin()->second;
    }
    LogError("Can't find the key.\n");
    constexpr long long UNKNOWN_CONFIG = -1;
    return UNKNOWN_CONFIG;
}
void IpcConfigImpl::SetLLong(const IpcConfigKey &key, const long long &value)
{
    std::lock_guard<std::mutex> locker(mMutex);
    std::map<IpcConfigKey, std::map<std::string, std::reference_wrapper<long long>>>::iterator iter;
    iter = mCfgMapLLong.find(key);
    if (iter != mCfgMapLLong.end() && CHECK_MAP(iter->second)) {
        iter->second.begin()->second.get() = value;
        const char *name = iter->second.begin()->first.c_str();
        ConfigSetLLong(mCfg, name, iter->second.begin()->second);
        mCfgChanged = CONFIG_HAS_CHANGED;
    }
    else {
        LogError("Can't find the key.\n");
    }
}
const char IpcConfigImpl::GetChar(const IpcConfigKey &key)
{
    std::lock_guard<std::mutex> locker(mMutex);
    std::map<IpcConfigKey, std::map<std::string, char *>>::iterator iter;
    iter = mCfgMapCharV2.find(key);
    if (iter != mCfgMapCharV2.end() && CHECK_MAP(iter->second)) {
        return *(iter->second.begin()->second);
    }
    LogError("Can't find the key.\n");
    constexpr char UNKNOWN_CONFIG = '\0';
    return UNKNOWN_CONFIG;
}
void IpcConfigImpl::SetChar(const IpcConfigKey &key, const char &character)
{
    std::lock_guard<std::mutex> locker(mMutex);
    std::map<IpcConfigKey, std::map<std::string, char *>>::iterator iter;
    iter = mCfgMapCharV2.find(key);
    if (iter != mCfgMapCharV2.end() && CHECK_MAP(iter->second)) {
        *(iter->second.begin()->second) = character;
        const char *name = iter->second.begin()->first.c_str();
        ConfigSetChar(mCfg, name, *(iter->second.begin()->second));
        mCfgChanged = CONFIG_HAS_CHANGED;
    }
    else {
        LogError("Can't find the key.\n");
    }
}
const float IpcConfigImpl::GetFloat(const IpcConfigKey &key)
{
    std::lock_guard<std::mutex> locker(mMutex);
    std::map<IpcConfigKey, std::map<std::string, std::reference_wrapper<float>>>::iterator iter;
    iter = mCfgMapFloat.find(key);
    if (iter != mCfgMapFloat.end() && CHECK_MAP(iter->second)) {
        return iter->second.begin()->second;
    }
    LogError("Can't find the key.\n");
    constexpr float UNKNOWN_CONFIG = -1.00;
    return UNKNOWN_CONFIG;
}
void IpcConfigImpl::SetFloat(const IpcConfigKey &key, const float &value)
{
    std::lock_guard<std::mutex> locker(mMutex);
    std::map<IpcConfigKey, std::map<std::string, std::reference_wrapper<float>>>::iterator iter;
    iter = mCfgMapFloat.find(key);
    if (iter != mCfgMapFloat.end() && CHECK_MAP(iter->second)) {
        iter->second.begin()->second.get() = value;
        const char *name = iter->second.begin()->first.c_str();
        ConfigSetFloat(mCfg, name, iter->second.begin()->second);
        mCfgChanged = CONFIG_HAS_CHANGED;
    }
    else {
        LogError("Can't find the key.\n");
    }
}
const double IpcConfigImpl::GetDouble(const IpcConfigKey &key)
{
    std::lock_guard<std::mutex> locker(mMutex);
    std::map<IpcConfigKey, std::map<std::string, std::reference_wrapper<double>>>::iterator iter;
    iter = mCfgMapDouble.find(key);
    if (iter != mCfgMapDouble.end() && CHECK_MAP(iter->second)) {
        return iter->second.begin()->second;
    }
    LogError("Can't find the key.\n");
    constexpr double UNKNOWN_CONFIG = -1.00;
    return UNKNOWN_CONFIG;
}
void IpcConfigImpl::SetDouble(const IpcConfigKey &key, const double &value)
{
    std::lock_guard<std::mutex> locker(mMutex);
    std::map<IpcConfigKey, std::map<std::string, std::reference_wrapper<double>>>::iterator iter;
    iter = mCfgMapDouble.find(key);
    if (iter != mCfgMapDouble.end() && CHECK_MAP(iter->second)) {
        iter->second.begin()->second.get() = value;
        const char *name = iter->second.begin()->first.c_str();
        ConfigSetDouble(mCfg, name, iter->second.begin()->second);
        mCfgChanged = CONFIG_HAS_CHANGED;
    }
    else {
        LogError("Can't find the key.\n");
    }
}
const long double IpcConfigImpl::GetLongDouble(const IpcConfigKey &key)
{
    std::lock_guard<std::mutex> locker(mMutex);
    std::map<IpcConfigKey, std::reference_wrapper<long double>>::iterator iter;
    iter = mCfgMapLongDouble.find(key);
    if (iter != mCfgMapLongDouble.end()) {
        return iter->second;
    }
    LogError("Can't find the key.\n");
    constexpr long double UNKNOWN_CONFIG = -1.0;
    return UNKNOWN_CONFIG;
}
void IpcConfigImpl::SetLongDouble(const IpcConfigKey &key, const long double &value)
{
    std::lock_guard<std::mutex> locker(mMutex);
    std::map<IpcConfigKey, std::reference_wrapper<long double>>::iterator iter;
    iter = mCfgMapLongDouble.find(key);
    if (iter != mCfgMapLongDouble.end()) {
        iter->second.get() = value;
        mCfgChanged = CONFIG_HAS_CHANGED;
    }
    else {
        LogError("Can't find the key.\n");
    }
}
const bool IpcConfigImpl::GetBool(const IpcConfigKey &key)
{
    std::lock_guard<std::mutex> locker(mMutex);
    std::map<IpcConfigKey, std::map<std::string, bool *>>::iterator iter;
    iter = mCfgMapBoolV2.find(key);
    if (iter != mCfgMapBoolV2.end() && CHECK_MAP(iter->second)) {
        return *(iter->second.begin()->second);
    }
    LogError("Can't find the key.\n");
    constexpr bool UNKNOWN_CONFIG = false;
    return UNKNOWN_CONFIG;
}
void IpcConfigImpl::SetBool(const IpcConfigKey &key, const bool &value)
{
    std::lock_guard<std::mutex> locker(mMutex);
    std::map<IpcConfigKey, std::map<std::string, bool *>>::iterator iter;
    iter = mCfgMapBoolV2.find(key);
    if (iter != mCfgMapBoolV2.end() && CHECK_MAP(iter->second)) {
        *(iter->second.begin()->second) = value;
        ConfigSetBool(mCfg, iter->second.begin()->first.c_str(), *(iter->second.begin()->second));
        mCfgChanged = CONFIG_HAS_CHANGED;
    }
    else {
        LogError("Can't find the key.\n");
    }
}
const std::string IpcConfigImpl::GetString(const IpcConfigKey &key)
{
    std::lock_guard<std::mutex> locker(mMutex);
    std::map<IpcConfigKey, std::map<std::string, StringConfigPack>>::iterator iter;
    iter = mCfgMapStringV2.find(key);
    if (iter != mCfgMapStringV2.end() && CHECK_MAP(iter->second)) {
        const std::string sv(iter->second.begin()->second.mValue); // char[] --> const std::strinbg
        return sv;
    }
    LogError("Can't find the key.\n");
    const std::string UNKNOWN_CONFIG = "undefine";
    return UNKNOWN_CONFIG;
}
void IpcConfigImpl::SetString(const IpcConfigKey &key, const std::string &string)
{
    std::lock_guard<std::mutex> locker(mMutex);
    std::map<IpcConfigKey, std::map<std::string, StringConfigPack>>::iterator iter;
    iter = mCfgMapStringV2.find(key);
    if (iter != mCfgMapStringV2.end() && CHECK_MAP(iter->second)) {
        if (string.length() > iter->second.begin()->second.mLength) {
            LogError("The string is too long. Your string is %s, the max length is %d\n",
                     string.c_str(),
                     iter->second.begin()->second.mLength);
            return;
        }
        strncpy(iter->second.begin()->second.mValue, string.c_str(), iter->second.begin()->second.mLength);
        ConfigSetString(mCfg, iter->second.begin()->first.c_str(), iter->second.begin()->second.mValue);
        mCfgChanged = CONFIG_HAS_CHANGED;
    }
    else {
        LogError("Can't find the key.\n");
    }
}
WorkMode IpcConfigImpl::GetWorkMode(void)
{
    return static_cast<WorkMode>(GetChar(IpcConfigKey::WORK_MODE));
}
void IpcConfigImpl::SetWorkMode(const WorkMode &mode)
{
    SetChar(IpcConfigKey::WORK_MODE, static_cast<char>(mode));
}
ConfigSwitch IpcConfigImpl::GetSwitch(const IpcConfigKey &key)
{
    bool value = GetBool(key);
    return value == true ? ConfigSwitch::ON : ConfigSwitch::OFF;
}
void IpcConfigImpl::SetSwitch(const IpcConfigKey &key, const ConfigSwitch &value)
{
    bool config = value == ConfigSwitch::ON ? true : false;
    SetBool(key, config);
}
ConfigLevel IpcConfigImpl::GetLevel(const IpcConfigKey &key)
{
    char value = GetChar(key);
    return static_cast<ConfigLevel>(value);
}
void IpcConfigImpl::SetLevel(const IpcConfigKey &key, const ConfigLevel &value)
{
    char config = static_cast<char>(value);
    SetChar(key, config);
}
void IpcConfigImpl::ReadingConfigThread(void)
{
    constexpr int DIR_PATH_LENGTH = 32;
    char dirPath[DIR_PATH_LENGTH] = {0};
    strncpy(dirPath, IPC_CONFIG_FILE_PATH, DIR_PATH_LENGTH - 1);
    char *lastSlash = strrchr(dirPath, '/');
    if (lastSlash == NULL) {
        strcpy(dirPath, ".");
    }
    else {
        *lastSlash = '\0';
    }
    mThreadRuning = true;
    LogInfo("Reading config thread is running, dirPath = %s\n", dirPath);
    while (mThreadRuning) {
        if (CheckConfigPathMounted() == true) {
            memset(&mAllData, 0, sizeof(Config_s));
            mCfg = OpenConfigFile(IPC_CONFIG_FILE_PATH);
            if (nullptr == mCfg) {
                LogError("Open config file failed.\n");
                continue;
            }
            std::lock_guard<std::mutex> locker(mMutex);
            InitConfigMap();
            ReadAllConfigParameters();
            LogInfo("Read config file success.\n");
            break;
        }
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
    }
    mThreadRuning = false;
}
void IpcConfigImpl::InitConfigMap(void)
{
    {
        std::map<std::string, StringConfigPack> config;
        StringConfigPack pack = {WIFI_SSID_BUFF_SIZE, mAllData.mWifiSsid};
        config.insert(std::make_pair(CONFIG_WIFI_SSID, pack));
        mCfgMapStringV2.insert(std::make_pair(IpcConfigKey::WIFI_SSID, config));
    }
    {
        std::map<std::string, StringConfigPack> config;
        StringConfigPack pack = {WIFI_PASSWORD_BUFF_SIZE, mAllData.mWifiPassword};
        config.insert(std::make_pair(CONFIG_WIFI_PASSWORD, pack));
        mCfgMapStringV2.insert(std::make_pair(IpcConfigKey::WIFI_PASSWORD, config));
    }
    {
        std::map<std::string, char *> config;
        config.insert(std::make_pair(CONFIG_WORK_MODE, &mAllData.mWorkMode));
        mCfgMapCharV2.insert(std::make_pair(IpcConfigKey::WORK_MODE, config));
    }
    {
        std::map<std::string, char *> config;
        config.insert(std::make_pair(CONFIG_INFRARED_POWER, &mAllData.mInfraredPower));
        mCfgMapCharV2.insert(std::make_pair(IpcConfigKey::INFRARED_POWER, config));
    }
    {
        std::map<std::string, int *> config;
        config.insert(std::make_pair(CONFIG_CONTINUE_SHOT, &mAllData.mContinuousShot));
        mCfgMapIntV2.insert(std::make_pair(IpcConfigKey::CONTINUOUS_SHOT, config));
    }
    {
        std::map<std::string, int *> config;
        config.insert(std::make_pair(CONFIG_BURST_PHOTO_INTERVAL, &mAllData.mBurstPhotoInterval));
        mCfgMapIntV2.insert(std::make_pair(IpcConfigKey::BURST_PHOTO_INTERVAL, config));
    }
    {
        std::map<std::string, int *> config;
        config.insert(std::make_pair(CONFIG_IMAGE_SIZE, &mAllData.mImageSize));
        mCfgMapIntV2.insert(std::make_pair(IpcConfigKey::IMGAE_SIZE, config));
    }
    {
        std::map<std::string, int *> config;
        config.insert(std::make_pair(CONFIG_VIDEO_SIZE, &mAllData.mVideoLength));
        mCfgMapIntV2.insert(std::make_pair(IpcConfigKey::VIDEO_LENGTH, config));
    }
    {
        std::map<std::string, int *> config;
        config.insert(std::make_pair(CONFIG_PIR_DELAYED, &mAllData.mPirDelayed));
        mCfgMapIntV2.insert(std::make_pair(IpcConfigKey::PIR_DELAYED, config));
    }
    {
        std::map<std::string, int *> config;
        config.insert(std::make_pair(CONFIG_PIR_SENSITIVITY, &mAllData.mPirSensitivity));
        mCfgMapIntV2.insert(std::make_pair(IpcConfigKey::PIR_SENSITIVITY, config));
    }
    {
        std::map<std::string, bool *> config;
        config.insert(std::make_pair(CONFIG_STORAGE_LOOP, &mAllData.mStorageLoopSwitch));
        mCfgMapBoolV2.insert(std::make_pair(IpcConfigKey::STORAGE_LOOP_SWITCH, config));
    }
}
void IpcConfigImpl::ReadAllConfigParameters(void)
{
    {
        const char *config = nullptr;
        StatusCode code = ConfigGetString(mCfg, CONFIG_WIFI_SSID, &config);
        if (StatusCodeEqual(code, "CONFIG_CODE_PARAM_NOT_EXIST")) {
            LogWarning("CONFIG_WIFI_SSID doesn't exist, will make it as default.\n");
            mCfgChanged = CONFIG_HAS_CHANGED;
            strncpy(mAllData.mWifiSsid, CONFIG_WIFI_SSID_DEFAULT, sizeof(mAllData.mWifiSsid));
            ConfigSetString(mCfg, CONFIG_WIFI_SSID, mAllData.mWifiSsid);
        }
        else {
            if (nullptr != config) {
                strncpy(mAllData.mWifiSsid, config, sizeof(mAllData.mWifiSsid));
            }
            else {
                LogError("CONFIG_WIFI_SSID get failed.\n");
            }
        }
    }
    {
        const char *config = nullptr;
        StatusCode code = ConfigGetString(mCfg, CONFIG_WIFI_PASSWORD, &config);
        if (StatusCodeEqual(code, "CONFIG_CODE_PARAM_NOT_EXIST")) {
            LogWarning("CONFIG_WIFI_PASSWORD doesn't exist, will make it as default.\n");
            mCfgChanged = CONFIG_HAS_CHANGED;
            strncpy(mAllData.mWifiPassword, CONFIG_WIFI_PASSWORD_DEFAULT, sizeof(mAllData.mWifiPassword));
            ConfigSetString(mCfg, CONFIG_WIFI_PASSWORD, mAllData.mWifiPassword);
        }
        else {
            if (nullptr != config) {
                strncpy(mAllData.mWifiPassword, config, sizeof(mAllData.mWifiPassword));
            }
            else {
                LogError("CONFIG_WIFI_PASSWORD get failed.\n");
            }
        }
    }
    {
        StatusCode code = ConfigGetChar(mCfg, CONFIG_WORK_MODE, &mAllData.mWorkMode);
        if (StatusCodeEqual(code, "CONFIG_CODE_PARAM_NOT_EXIST")) {
            LogWarning("CONFIG_WORK_MODE doesn't exist, will make it as default.\n");
            mCfgChanged = CONFIG_HAS_CHANGED;
            mAllData.mWorkMode = CONFIG_WORK_MODE_DEFAULT;
            ConfigSetChar(mCfg, CONFIG_WORK_MODE, mAllData.mWorkMode);
        }
    }
    {
        StatusCode code = ConfigGetChar(mCfg, CONFIG_INFRARED_POWER, &mAllData.mInfraredPower);
        if (StatusCodeEqual(code, "CONFIG_CODE_PARAM_NOT_EXIST")) {
            LogWarning("CONFIG_INFRARED_POWER doesn't exist, will make it as default.\n");
            mCfgChanged = CONFIG_HAS_CHANGED;
            mAllData.mInfraredPower = CONFIG_INFRARED_POWER_DEFAULT;
            ConfigSetChar(mCfg, CONFIG_INFRARED_POWER, mAllData.mInfraredPower);
        }
    }
    {
        int config = -1;
        StatusCode code = ConfigGetInt(mCfg, CONFIG_CONTINUE_SHOT, &config);
        if (StatusCodeEqual(code, "CONFIG_CODE_PARAM_NOT_EXIST")) {
            LogWarning("CONFIG_CONTINUE_SHOT doesn't exist, will make it as default.\n");
            mCfgChanged = CONFIG_HAS_CHANGED;
            mAllData.mContinuousShot = CONFIG_CONTINUE_SHOT_DEFAULT;
            ConfigSetInt(mCfg, CONFIG_CONTINUE_SHOT, mAllData.mContinuousShot);
        }
        else {
            mAllData.mContinuousShot = config;
        }
    }
    {
        int config = -1;
        StatusCode code = ConfigGetInt(mCfg, CONFIG_BURST_PHOTO_INTERVAL, &config);
        if (StatusCodeEqual(code, "CONFIG_CODE_PARAM_NOT_EXIST")) {
            LogWarning("CONFIG_BURST_PHOTO_INTERVAL doesn't exist, will make it as default.\n");
            mCfgChanged = CONFIG_HAS_CHANGED;
            mAllData.mBurstPhotoInterval = CONFIG_BURST_PHOTO_INTERVAL_DEFAULT;
            ConfigSetInt(mCfg, CONFIG_BURST_PHOTO_INTERVAL, mAllData.mBurstPhotoInterval);
        }
        else {
            mAllData.mBurstPhotoInterval = config;
        }
    }
    {
        int config = -1;
        StatusCode code = ConfigGetInt(mCfg, CONFIG_IMAGE_SIZE, &config);
        if (StatusCodeEqual(code, "CONFIG_CODE_PARAM_NOT_EXIST")) {
            LogWarning("CONFIG_IMAGE_SIZE doesn't exist, will make it as default.\n");
            mCfgChanged = CONFIG_HAS_CHANGED;
            mAllData.mImageSize = CONFIG_IMAGE_SIZE_DEFAULT;
            ConfigSetInt(mCfg, CONFIG_IMAGE_SIZE, mAllData.mImageSize);
        }
        else {
            mAllData.mImageSize = config;
        }
    }
    {
        int config = -1;
        StatusCode code = ConfigGetInt(mCfg, CONFIG_VIDEO_SIZE, &config);
        if (StatusCodeEqual(code, "CONFIG_CODE_PARAM_NOT_EXIST")) {
            LogWarning("CONFIG_VIDEO_SIZE doesn't exist, will make it as default.\n");
            mCfgChanged = CONFIG_HAS_CHANGED;
            mAllData.mVideoLength = CONFIG_VIDEO_SIZE_DEFAULT;
            ConfigSetInt(mCfg, CONFIG_VIDEO_SIZE, mAllData.mVideoLength);
        }
        else {
            mAllData.mVideoLength = config;
        }
    }
    {
        int config = -1;
        StatusCode code = ConfigGetInt(mCfg, CONFIG_PIR_DELAYED, &config);
        if (StatusCodeEqual(code, "CONFIG_CODE_PARAM_NOT_EXIST")) {
            LogWarning("CONFIG_PIR_DELAYED doesn't exist, will make it as default.\n");
            mCfgChanged = CONFIG_HAS_CHANGED;
            mAllData.mPirDelayed = CONFIG_PIR_DELAYED_DEFAULT;
            ConfigSetInt(mCfg, CONFIG_PIR_DELAYED, mAllData.mPirDelayed);
        }
        else {
            mAllData.mPirDelayed = config;
        }
    }
    {
        int config = -1;
        StatusCode code = ConfigGetInt(mCfg, CONFIG_PIR_SENSITIVITY, &config);
        if (StatusCodeEqual(code, "CONFIG_CODE_PARAM_NOT_EXIST")) {
            LogWarning("CONFIG_PIR_SENSITIVITY doesn't exist, will make it as default.\n");
            mCfgChanged = CONFIG_HAS_CHANGED;
            mAllData.mPirSensitivity = CONFIG_PIR_SENSITIVITY_DEFAULT;
            ConfigSetInt(mCfg, CONFIG_PIR_SENSITIVITY, mAllData.mPirSensitivity);
        }
        else {
            mAllData.mPirSensitivity = config;
        }
    }
    {
        StatusCode code = ConfigGetBool(mCfg, CONFIG_STORAGE_LOOP, &(mAllData.mStorageLoopSwitch));
        if (StatusCodeEqual(code, "CONFIG_CODE_PARAM_NOT_EXIST")) {
            LogWarning("CONFIG_STORAGE_LOOP doesn't exist, will make it as default.\n");
            mCfgChanged = CONFIG_HAS_CHANGED;
            mAllData.mStorageLoopSwitch = CONFIG_STORAGE_LOOP_DEFAULT;
            ConfigSetBool(mCfg, CONFIG_STORAGE_LOOP, mAllData.mStorageLoopSwitch);
        }
    }

    // StatusCode workModeCode = ConfigGetInt(mCfg, "work_mode", &(mAllData.mWorkMode));
    // if (StatusCodeEqual(workModeCode, "CONFIG_CODE_PARAM_NOT_EXIST")) {
    //     LogWarning("work_mode doesn't exist, will make it as default.\n");
    //     mCfgChanged = CONFIG_HAS_CHANGED;
    //     mAllData.mWorkMode = MODE_PIC;
    //     ConfigSetInt(mCfg, "work_mode", mAllData.mWorkMode);
    // }

    // StatusCode continuousShotCode = ConfigGetInt(mCfg, "continuous_shot", &(mAllData.mContinuousShot));
    // if (StatusCodeEqual(continuousShotCode, "CONFIG_CODE_PARAM_NOT_EXIST")) {
    //     LogWarning("continuous_shot doesn't exist, will make it as default.\n");
    //     mCfgChanged = CONFIG_HAS_CHANGED;
    //     mAllData.mContinuousShot = CONTINUOUS_SHOT_ONE_PIC;
    //     ConfigSetInt(mCfg, "continuous_shot", mAllData.mContinuousShot);
    // }

    // StatusCode burstPhotoIntervalCode = ConfigGetInt(mCfg, "burst_photo_interval",
    // &(mAllData.mBurstPhotoInterval)); if (StatusCodeEqual(burstPhotoIntervalCode, "CONFIG_CODE_PARAM_NOT_EXIST"))
    // {
    //     LogWarning("burst_photo_interval doesn't exist, will make it as default.\n");
    //     mCfgChanged = CONFIG_HAS_CHANGED;
    //     mAllData.mBurstPhotoInterval = BURST_PHOTO_INTERVAL_DEFAULT;
    //     ConfigSetInt(mCfg, "burst_photo_interval", mAllData.mBurstPhotoInterval);
    // }

    // const char *imageSizeString = nullptr;
    // StatusCode imageSizeCode = ConfigGetString(mCfg, "image_size", &(imageSizeString));
    // if (StatusCodeEqual(imageSizeCode, "CONFIG_CODE_PARAM_NOT_EXIST")) {
    //     LogWarning("image_size doesn't exist, will make it as default.\n");
    //     mCfgChanged = CONFIG_HAS_CHANGED;
    //     char defaultImageSize[] = "320*320";
    //     strncpy(mAllData.imageSize, defaultImageSize, sizeof(mAllData.imageSize));
    //     ConfigSetString(mCfg, "image_size", mAllData.imageSize);
    // }
    // else {
    //     if (nullptr != imageSizeString) {
    //         strncpy(mAllData.imageSize, imageSizeString, sizeof(mAllData.imageSize));
    //     }
    //     else {
    //         LogError("image_size get failed.\n");
    //     }
    // }

    // StatusCode videoSizeCode = ConfigGetInt(mCfg, "video_size", &(mAllData.videoSize));
    // if (StatusCodeEqual(videoSizeCode, "CONFIG_CODE_PARAM_NOT_EXIST")) {
    //     LogWarning("video_size doesn't exist, will make it as default.\n");
    //     mCfgChanged = CONFIG_HAS_CHANGED;
    //     mAllData.videoSize = VIDEO_SIZE_15;
    //     ConfigSetInt(mCfg, "video_size", mAllData.videoSize);
    // }

    // StatusCode infraredIampPowerCode = ConfigGetInt(mCfg, "infrared_lamp_power", &(mAllData.mInfraredPower));
    // if (StatusCodeEqual(infraredIampPowerCode, "CONFIG_CODE_PARAM_NOT_EXIST")) {
    //     LogWarning("infrared_lamp_power doesn't exist, will make it as default.\n");
    //     mCfgChanged = CONFIG_HAS_CHANGED;
    //     mAllData.mInfraredPower = INFRARED_IAMP_POWER_MID;
    //     ConfigSetInt(mCfg, "infrared_lamp_power", mAllData.mInfraredPower);
    // }

    // StatusCode delayedCode = ConfigGetInt(mCfg, "delayed", &(mAllData.delayed));
    // if (StatusCodeEqual(delayedCode, "CONFIG_CODE_PARAM_NOT_EXIST")) {
    //     LogWarning("delayed doesn't exist, will make it as default.\n");
    //     mCfgChanged = CONFIG_HAS_CHANGED;
    //     mAllData.delayed = DELAYED_DEFAULT;
    //     ConfigSetInt(mCfg, "delayed", mAllData.delayed);
    // }

    // StatusCode pirSensitivityCode = ConfigGetInt(mCfg, "pir_sensitivity", &(mAllData.mPirSensitivity));
    // if (StatusCodeEqual(pirSensitivityCode, "CONFIG_CODE_PARAM_NOT_EXIST")) {
    //     LogWarning("pir_sensitivity doesn't exist, will make it as default.\n");
    //     mCfgChanged = CONFIG_HAS_CHANGED;
    //     mAllData.mPirSensitivity = PIR_SENSITIVITY_DEFAULT;
    //     ConfigSetInt(mCfg, "pir_sensitivity", mAllData.mPirSensitivity);
    // }

    // StatusCode storageLoopSwitchCode = ConfigGetBool(mCfg, "storage_loop_switch",
    // &(mAllData.mStorageLoopSwitch)); if (StatusCodeEqual(storageLoopSwitchCode, "CONFIG_CODE_PARAM_NOT_EXIST")) {
    //     LogWarning("storage_loop_switch doesn't exist, will make it as default.\n");
    //     mCfgChanged = CONFIG_HAS_CHANGED;
    //     constexpr bool storageLoopSwitch = true;
    //     mAllData.mStorageLoopSwitch = storageLoopSwitch;
    //     ConfigSetBool(mCfg, "storage_loop_switch", mAllData.mStorageLoopSwitch);
    // }

    // StatusCode factoryResetCode = ConfigGetBool(mCfg, "factory_reset", &(mAllData.factoryReset));
    // if (StatusCodeEqual(factoryResetCode, "CONFIG_CODE_PARAM_NOT_EXIST")) {
    //     LogWarning("factory_resetCode doesn't exist, will make it as default.\n");
    //     mCfgChanged = CONFIG_HAS_CHANGED;
    //     constexpr bool factoryReset = true;
    //     mAllData.factoryReset = factoryReset;
    //     ConfigSetBool(mCfg, "factory_reset", mAllData.factoryReset);
    // }

    // StatusCode formattingSDCardCode = ConfigGetBool(mCfg, "formatting_SD_card", &(mAllData.formattingSDCard));
    // if (StatusCodeEqual(formattingSDCardCode, "CONFIG_CODE_PARAM_NOT_EXIST")) {
    //     LogWarning("formatting_SD_card doesn't exist, will make it as default.\n");
    //     mCfgChanged = CONFIG_HAS_CHANGED;
    //     constexpr bool formattingSDCard = true;
    //     mAllData.formattingSDCard = formattingSDCard;
    //     ConfigSetBool(mCfg, "formatting_SD_card", mAllData.formattingSDCard);
    // }

    // const char *darkModeString = nullptr;
    // StatusCode darkModeCode = ConfigGetString(mCfg, "dark_mode", &(darkModeString));
    // if (StatusCodeEqual(darkModeCode, "CONFIG_CODE_PARAM_NOT_EXIST")) {
    //     LogWarning("dark_mode doesn't exist, will make it as default.\n");
    //     mCfgChanged = CONFIG_HAS_CHANGED;
    //     char defaultDarkMode[] = "19:00:00-07:00:00";
    //     strncpy(mAllData.darkMode, defaultDarkMode, sizeof(mAllData.darkMode));
    //     ConfigSetString(mCfg, "dark_mode", mAllData.darkMode);
    // }
    // else {
    //     if (nullptr != darkModeString) {
    //         strncpy(mAllData.darkMode, darkModeString, sizeof(mAllData.darkMode));
    //     }
    //     else {
    //         LogError("dark_mode get failed.\n");
    //     }
    // }

    // const char *workIntervalString = nullptr;
    // StatusCode workIntervalCode = ConfigGetString(mCfg, "work_interval", &(workIntervalString));
    // if (StatusCodeEqual(workIntervalCode, "CONFIG_CODE_PARAM_NOT_EXIST")) {
    //     LogWarning("work_interval doesn't exist, will make it as default.\n");
    //     mCfgChanged = CONFIG_HAS_CHANGED;
    //     char defaultWorkInterval[] = "07:00:01-07:00:00";
    //     strncpy(mAllData.workingInterval, defaultWorkInterval, sizeof(mAllData.workingInterval));
    //     ConfigSetString(mCfg, "work_interval", mAllData.workingInterval);
    // }
    // else {
    //     if (nullptr != workIntervalString) {
    //         strncpy(mAllData.workingInterval, workIntervalString, sizeof(mAllData.workingInterval));
    //     }
    //     else {
    //         LogError("work_interval get failed.\n");
    //     }
    // }

    // StatusCode shortCode = ConfigGetShort(mCfg, "test_short", &(mAllData.testShort));
    // if (StatusCodeEqual(shortCode, "CONFIG_CODE_PARAM_NOT_EXIST")) {
    //     LogWarning("test_short doesn't exist, will make it as default.\n");
    //     mCfgChanged = CONFIG_HAS_CHANGED;
    //     constexpr short DEFAULT_TEST_SHORT_NUM = 11;
    //     mAllData.testShort = DEFAULT_TEST_SHORT_NUM;
    //     ConfigSetShort(mCfg, "test_short", mAllData.testShort);
    // }

    // StatusCode longCode = ConfigGetLong(mCfg, "test_long", &(mAllData.testLong));
    // if (StatusCodeEqual(longCode, "CONFIG_CODE_PARAM_NOT_EXIST")) {
    //     LogWarning("test_long doesn't exist, will make it as default.\n");
    //     mCfgChanged = CONFIG_HAS_CHANGED;
    //     constexpr long DEFAULT_TEST_LONG_NUM = 12;
    //     mAllData.testLong = DEFAULT_TEST_LONG_NUM;
    //     ConfigSetLong(mCfg, "test_long", mAllData.testLong);
    // }

    // StatusCode llongCode = ConfigGetLLong(mCfg, "test_llong", &(mAllData.testLLong));
    // if (StatusCodeEqual(llongCode, "CONFIG_CODE_PARAM_NOT_EXIST")) {
    //     LogWarning("test_llong doesn't exist, will make it as default.\n");
    //     mCfgChanged = CONFIG_HAS_CHANGED;
    //     constexpr long long DEFAULT_TEST_LLONG_NUM = 13;
    //     mAllData.testLLong = DEFAULT_TEST_LLONG_NUM;
    //     ConfigSetLLong(mCfg, "test_llong", mAllData.testLLong);
    // }

    // StatusCode charCode = ConfigGetChar(mCfg, "test_char", &(mAllData.testChar));
    // if (StatusCodeEqual(charCode, "CONFIG_CODE_PARAM_NOT_EXIST")) {
    //     LogWarning("test_char doesn't exist, will make it as default.\n");
    //     mCfgChanged = CONFIG_HAS_CHANGED;
    //     constexpr char DEFAULT_TEST_CHAR_NUM = 'B';
    //     mAllData.testChar = DEFAULT_TEST_CHAR_NUM;
    //     ConfigSetChar(mCfg, "test_char", mAllData.testChar);
    // }

    // StatusCode floatCode = ConfigGetFloat(mCfg, "test_float", &(mAllData.testFloat));
    // if (StatusCodeEqual(floatCode, "CONFIG_CODE_PARAM_NOT_EXIST")) {
    //     LogWarning("test_float doesn't exist, will make it as default.\n");
    //     mCfgChanged = CONFIG_HAS_CHANGED;
    //     constexpr float DEFAULT_TEST_FLOAT_NUM = 1.123456;
    //     mAllData.testFloat = DEFAULT_TEST_FLOAT_NUM;
    //     ConfigSetFloat(mCfg, "test_float", mAllData.testFloat);
    // }

    if (CONFIG_HAS_CHANGED == mCfgChanged) {
        LogInfo("Save the config file.\n");
        mCfgChanged = CONFIG_HAS_NOT_CHANGED;
        ConfigSaveFile(mCfg);
    }
}
bool IpcConfigImpl::CheckConfigPathMounted(void)
{
    FILE *fp;
    char line[1024];
    char mount_point[1024] = {0};

    fp = fopen("/proc/mounts", "r");
    if (fp == NULL) {
        perror("Error opening /proc/mounts");
        return false;
    }

    while (fgets(line, sizeof(line), fp) != NULL) {
        if (sscanf(line, "%*s %1023s %*s %*s %*d %*d\n", mount_point) == 1) {
            // LogInfo("mount_point: %s\n", mount_point);
            if (strcmp("/userdata", mount_point) == 0) {
                fclose(fp);
                return true; // mounted
            }
        }
    }
    fclose(fp);
    return false; // unmounted
}