/*
 * 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 "IpcConfig.h"
#include "ILog.h"
#include <string.h>

#define CHECK_MAP(map) (map.size() == 1 ? true : false)

IpcConfig::IpcConfig()
{
    mCfgChanged = CONFIG_HAS_NOT_CHANGED;

    std::map<std::string, std::reference_wrapper<int>> innerMapWorkMode;
    innerMapWorkMode.insert(std::make_pair("work_mode", std::reference_wrapper<int>(mAllData.workMode)));
    mCfgMapInt.insert(std::make_pair(IpcConfigKey::KEY_WORK_MODE, innerMapWorkMode));

    std::map<std::string, std::reference_wrapper<int>> innerMapContinuousShot;
    innerMapContinuousShot.insert(
        std::make_pair("continuous_shot", std::reference_wrapper<int>(mAllData.continuousShot)));
    mCfgMapInt.insert(std::make_pair(IpcConfigKey::KEY_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.burstPhotoInterval)));
    mCfgMapInt.insert(std::make_pair(IpcConfigKey::KEY_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::KEY_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::KEY_VIDEO_SIZE, innerMapVideoSize));

    std::map<std::string, std::reference_wrapper<int>> innerMapInfraredLampPower;
    innerMapInfraredLampPower.insert(
        std::make_pair("infrared_lamp_power", std::reference_wrapper<int>(mAllData.infraredIampPower)));
    mCfgMapInt.insert(std::make_pair(IpcConfigKey::KEY_INFRARED_LAMP_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::KEY_DELAYED, innerMapDelayed));

    std::map<std::string, std::reference_wrapper<int>> innerMapPirSensitivity;
    innerMapPirSensitivity.insert(
        std::make_pair("pir_sensitivity", std::reference_wrapper<int>(mAllData.pirSensitivity)));
    mCfgMapInt.insert(std::make_pair(IpcConfigKey::KEY_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.storageLoopSwitch)));
    mCfgMapBool.insert(std::make_pair(IpcConfigKey::KEY_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::KEY_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::KEY_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::KEY_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::KEY_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 IpcConfig::Init(void)
{
    memset(&mAllData, 0, sizeof(Config_s));
    mCfg = OpenConfigFile(IPC_CONFIG_FILE_PATH);
    if (nullptr == mCfg) {
        LogError("Open config file failed.\n");
        return CreateStatusCode(STATUS_CODE_NOT_OK);
    }
    ReadAllConfigParameters();
    return CreateStatusCode(STATUS_CODE_OK);
}
const StatusCode IpcConfig::UnInit(void)
{
    if (CONFIG_HAS_CHANGED == mCfgChanged) {
        LogInfo("Save config files.\n");
        ConfigSaveFile(mCfg);
    }
    CloseConfigFile(mCfg);
    return CreateStatusCode(STATUS_CODE_OK);
}
const StatusCode IpcConfig::ConfigFileSave(void) { return ConfigSaveFile(mCfg); }

const int IpcConfig::GetInt(const IpcConfigKey &key)
{
    std::map<IpcConfigKey, std::map<std::string, std::reference_wrapper<int>>>::iterator iter;
    iter = mCfgMapInt.find(key);
    if (iter != mCfgMapInt.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 IpcConfig::SetInt(const IpcConfigKey &key, const int &value)
{
    std::map<IpcConfigKey, std::map<std::string, std::reference_wrapper<int>>>::iterator iter;
    iter = mCfgMapInt.find(key);
    if (iter != mCfgMapInt.end() && CHECK_MAP(iter->second)) {
        iter->second.begin()->second.get() = value;
        const char *name = iter->second.begin()->first.c_str(); // const std::strinbg --> const char *
        ConfigSetInt(mCfg, name, iter->second.begin()->second);
        mCfgChanged = CONFIG_HAS_CHANGED;
    }
    else {
        LogError("Can't find the key.\n");
    }
}
const short IpcConfig::GetShort(const IpcConfigKey &key)
{
    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 IpcConfig::SetShort(const IpcConfigKey &key, const short &value)
{
    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(); // const std::strinbg --> const char *
        ConfigSetShort(mCfg, name, iter->second.begin()->second);
        mCfgChanged = CONFIG_HAS_CHANGED;
    }
    else {
        LogError("Can't find the key.\n");
    }
}
const long IpcConfig::GetLong(const IpcConfigKey &key)
{
    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 IpcConfig::SetLong(const IpcConfigKey &key, const long &value)
{
    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(); // const std::strinbg --> const char *
        ConfigSetLong(mCfg, name, iter->second.begin()->second);
        mCfgChanged = CONFIG_HAS_CHANGED;
    }
    else {
        LogError("Can't find the key.\n");
    }
}
const long long IpcConfig::GetLLong(const IpcConfigKey &key)
{
    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 IpcConfig::SetLLong(const IpcConfigKey &key, const long long &value)
{
    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(); // const std::strinbg --> const char *
        ConfigSetLLong(mCfg, name, iter->second.begin()->second);
        mCfgChanged = CONFIG_HAS_CHANGED;
    }
    else {
        LogError("Can't find the key.\n");
    }
}
const char IpcConfig::GetChar(const IpcConfigKey &key)
{
    std::map<IpcConfigKey, std::map<std::string, std::reference_wrapper<char>>>::iterator iter;
    iter = mCfgMapChar.find(key);
    if (iter != mCfgMapChar.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 IpcConfig::SetChar(const IpcConfigKey &key, const char &character)
{
    std::map<IpcConfigKey, std::map<std::string, std::reference_wrapper<char>>>::iterator iter;
    iter = mCfgMapChar.find(key);
    if (iter != mCfgMapChar.end() && CHECK_MAP(iter->second)) {
        iter->second.begin()->second.get() = character;
        const char *name = iter->second.begin()->first.c_str(); // const std::strinbg --> const char *
        ConfigSetChar(mCfg, name, iter->second.begin()->second);
        mCfgChanged = CONFIG_HAS_CHANGED;
    }
    else {
        LogError("Can't find the key.\n");
    }
}
const float IpcConfig::GetFloat(const IpcConfigKey &key)
{
    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 IpcConfig::SetFloat(const IpcConfigKey &key, const float &value)
{
    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(); // const std::strinbg --> const char *
        ConfigSetFloat(mCfg, name, iter->second.begin()->second);
        mCfgChanged = CONFIG_HAS_CHANGED;
    }
    else {
        LogError("Can't find the key.\n");
    }
}
const double IpcConfig::GetDouble(const IpcConfigKey &key)
{
    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 IpcConfig::SetDouble(const IpcConfigKey &key, const double &value)
{
    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(); // const std::strinbg --> const char *
        ConfigSetDouble(mCfg, name, iter->second.begin()->second);
        mCfgChanged = CONFIG_HAS_CHANGED;
    }
    else {
        LogError("Can't find the key.\n");
    }
}
const long double IpcConfig::GetLongDouble(const IpcConfigKey &key)
{
    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 IpcConfig::SetLongDouble(const IpcConfigKey &key, const long double &value)
{
    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 IpcConfig::GetBool(const IpcConfigKey &key)
{
    std::map<IpcConfigKey, std::map<std::string, std::reference_wrapper<bool>>>::iterator iter;
    iter = mCfgMapBool.find(key);
    if (iter != mCfgMapBool.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 IpcConfig::SetBool(const IpcConfigKey &key, const bool &value)
{
    std::map<IpcConfigKey, std::map<std::string, std::reference_wrapper<bool>>>::iterator iter;
    iter = mCfgMapBool.find(key);
    if (iter != mCfgMapBool.end() && CHECK_MAP(iter->second)) {
        iter->second.begin()->second.get() = value;
        const char *name = iter->second.begin()->first.c_str(); // const std::strinbg --> const char *
        ConfigSetBool(mCfg, name, iter->second.begin()->second);
        mCfgChanged = CONFIG_HAS_CHANGED;
    }
    else {
        LogError("Can't find the key.\n");
    }
}
const std::string IpcConfig::GetString(const IpcConfigKey &key)
{
    std::map<IpcConfigKey, std::map<std::string, std::reference_wrapper<CHAR_STRING>>>::iterator iter;
    iter = mCfgMapString.find(key);
    if (iter != mCfgMapString.end() && CHECK_MAP(iter->second)) {
        const std::string sv(iter->second.begin()->second); // char[] --> const std::strinbg
        return sv;
    }
    LogError("Can't find the key.\n");
    const std::string UNKNOWN_CONFIG = "undefine";
    return UNKNOWN_CONFIG;
}
void IpcConfig::SetString(const IpcConfigKey &key, const std::string string)
{
    std::map<IpcConfigKey, std::map<std::string, std::reference_wrapper<CHAR_STRING>>>::iterator iter;
    iter = mCfgMapString.find(key);
    if (iter != mCfgMapString.end() && CHECK_MAP(iter->second)) {
        strncpy(iter->second.begin()->second, string.c_str(), sizeof(CHAR_STRING)); // const std::strinbg --> char[]
        const char *name = iter->second.begin()->first.c_str(); // const std::strinbg --> const char *
        ConfigSetString(mCfg, name, iter->second.begin()->second);
        mCfgChanged = CONFIG_HAS_CHANGED;
    }
    else {
        LogError("Can't find the key.\n");
    }
}

void IpcConfig::ReadAllConfigParameters(void)
{
    StatusCode workModeCode = ConfigGetInt(mCfg, "work_mode", &(mAllData.workMode));
    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.workMode = WORK_MODE_PIC;
        ConfigSetInt(mCfg, "work_mode", mAllData.workMode);
    }

    StatusCode continuousShotCode = ConfigGetInt(mCfg, "continuous_shot", &(mAllData.continuousShot));
    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.continuousShot = CONTINUOUS_SHOT_ONE_PIC;
        ConfigSetInt(mCfg, "continuous_shot", mAllData.continuousShot);
    }

    StatusCode burstPhotoIntervalCode = ConfigGetInt(mCfg, "burst_photo_interval", &(mAllData.burstPhotoInterval));
    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.burstPhotoInterval = BURST_PHOTO_INTERVAL_DEFAULT;
        ConfigSetInt(mCfg, "burst_photo_interval", mAllData.burstPhotoInterval);
    }

    const char *imageSizeString = NULL;
    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 {
        strncpy(mAllData.imageSize, imageSizeString, sizeof(mAllData.imageSize));
    }

    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.infraredIampPower));
    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.infraredIampPower = INFRARED_IAMP_POWER_MID;
        ConfigSetInt(mCfg, "infrared_lamp_power", mAllData.infraredIampPower);
    }

    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.pirSensitivity));
    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.pirSensitivity = PIR_SENSITIVITY_DEFAULT;
        ConfigSetInt(mCfg, "pir_sensitivity", mAllData.pirSensitivity);
    }

    StatusCode storageLoopSwitchCode = ConfigGetBool(mCfg, "storage_loop_switch", &(mAllData.storageLoopSwitch));
    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.storageLoopSwitch = storageLoopSwitch;
        ConfigSetBool(mCfg, "storage_loop_switch", mAllData.storageLoopSwitch);
    }

    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 = NULL;
    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 {
        strncpy(mAllData.darkMode, darkModeString, sizeof(mAllData.darkMode));
    }

    const char *workIntervalString = NULL;
    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 {
        strncpy(mAllData.workingInterval, workIntervalString, sizeof(mAllData.workingInterval));
    }

    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);
    }
}