/*
 * ================================
 * eli960@qq.com
 * http://linuxmail.cn/
 * 2015年11月12日
 * ================================
 */

#include <fstream>
#include "zcc/zcc_stdlib.h"

zcc_namespace_begin;

/**
 * @brief 全局配置对象
 */
config var_main_config;

/**
 * @brief 配置类的构造函数
 *
 * 目前构造函数为空,不执行任何初始化操作
 */
config::config()
{
}

/**
 * @brief 配置类的析构函数
 *
 * 目前析构函数为空,不执行任何清理操作
 */
config::~config()
{
}

/**
 * @brief 重置配置对象,清除所有配置项
 *
 * @return config& 返回当前配置对象的引用,支持链式调用
 */
config &config::reset()
{
 // 调用 clear 方法清除所有配置项
 clear();
 return *this;
}

/**
 * @brief 使用 C 风格字符串更新配置项
 *
 * @param key 配置项的键
 * @param val 配置项的值
 * @param vlen 值的长度,如果为 -1,则自动计算字符串长度
 * @return config& 返回当前配置对象的引用,支持链式调用
 */
config &config::update(const char *key, const char *val, int vlen)
{
 // 如果未指定值的长度,则自动计算
 if (vlen < 0)
 {
 vlen = (int)std::strlen(val);
 }
 // 将配置项添加或更新到配置对象中
 (*this)[key] = std::string(val, vlen);
 // 调用更新后的处理函数
 afterUpdate();
 return *this;
}

config &config::update(const std::string &key, const char *val, int vlen)
{
 // 如果未指定值的长度,则自动计算
 if (vlen < 0)
 {
 vlen = (int)std::strlen(val);
 }
 // 将配置项添加或更新到配置对象中
 (*this)[key] = std::string(val, vlen);
 // 调用更新后的处理函数
 afterUpdate();
 return *this;
}

/**
 * @brief 使用 std::string 和 C 风格字符串更新配置项
 *
 * @param key 配置项的键
 * @param val 配置项的值
 * @return config& 返回当前配置对象的引用,支持链式调用
 */
config &config::update(const char *key, const std::string &val)
{
 // 将配置项添加或更新到配置对象中
 (*this)[key] = val;
 // 调用更新后的处理函数
 afterUpdate();
 return *this;
}

/**
 * @brief 使用两个 std::string 更新配置项
 *
 * @param key 配置项的键
 * @param val 配置项的值
 * @return config& 返回当前配置对象的引用,支持链式调用
 */
config &config::update(const std::string &key, const std::string &val)
{
 // 将配置项添加或更新到配置对象中
 (*this)[key] = val;
 // 调用更新后的处理函数
 afterUpdate();
 return *this;
}

/**
 * @brief 使用 C 风格字符串移除配置项
 *
 * @param key 要移除的配置项的键
 * @return config& 返回当前配置对象的引用,支持链式调用
 */
config &config::remove(const char *key)
{
 // 查找指定键的配置项
 auto it = find(key);
 // 如果找到该配置项
 if (it != end())
 {
 // 从配置对象中移除该配置项
 erase(it);
 // 调用更新后的处理函数
 afterUpdate();
 }
 return *this;
}

/**
 * @brief 使用 std::string 移除配置项
 *
 * @param key 要移除的配置项的键
 * @return config& 返回当前配置对象的引用,支持链式调用
 */
config &config::remove(const std::string &key)
{
 // 查找指定键的配置项
 auto it = find(key);
 // 如果找到该配置项
 if (it != end())
 {
 // 从配置对象中移除该配置项
 erase(it);
 // 调用更新后的处理函数
 afterUpdate();
 }
 return *this;
}

/**
 * @brief 从文件中加载配置项
 *
 * @param pathname 配置文件的路径
 * @return bool 加载成功返回 true,失败返回 false
 */
bool config::load_from_file(const char *pathname)
{
 // 空字符串,用于处理没有值的配置项
 char blank[1] = "";

 // 配置项的名称
 char *name;
 // 配置项的值
 char *value;
 // 用于存储文件读取的行
 char *line_buf;
 // 以二进制模式打开配置文件
 std::ifstream file(pathname, std::ifstream::binary);

 // 如果文件打开失败
 if (!file)
 {
 return false;
 }
 // 每行的最大长度限制
 const int limit = 1024000;
 // 分配内存用于存储每行内容
 line_buf = new char[limit + 11];
 // 逐行读取文件,直到文件结束
 while (!file.eof())
 {
 // 从文件中读取一行
 file.getline(line_buf, limit);
 // 如果读取失败
 if (file.fail())
 {
 break;
 }
 // 去除行首的空白字符
 name = trim_left(line_buf);
 // 如果行为空或者是注释行
 if (zcc::empty(name) || (*name == '#'))
 {
 continue;
 }
 // 查找等号的位置
 value = std::strchr(name, '=');
 if (value)
 {
 *value++ = 0;
 }
 else
 {
 // 如果没有等号,使用空字符串作为值
 value = blank;
 }
 // 去除名称的尾部空白字符
 name = trim_right(name);
 // 如果值不为空,去除值的首尾空白字符
 if (!zcc::empty(value))
 {
 value = trim(value);
 }
 // 更新配置项
 update(name, value);
 }
 // 释放分配的内存
 delete[] line_buf;

 return true;
}

/**
 * @brief 加载另一个配置对象的所有配置项
 *
 * @param another 另一个配置对象
 * @return config& 返回当前配置对象的引用,支持链式调用
 */
config &config::load_another(config &another)
{
 // 遍历另一个配置对象的所有配置项
 for (auto it = another.begin(); it != another.end(); it++)
 {
 // 将配置项添加或更新到当前配置对象中
 (*this)[it->first] = it->second;
 }
 return *this;
}

/**
 * @brief 调试输出所有配置项
 *
 * 将所有配置项以 "key = value" 的格式输出到标准错误流
 * @return config& 返回当前配置对象的引用,支持链式调用
 */
config &config::debug_show()
{
 // 用于存储调试输出的字符串
 std::string s;
 // 遍历所有配置项
 for (auto it = begin(); it != end(); it++)
 {
 // 拼接配置项信息
 s.append(it->first).append(" = ").append(it->second).append("\r\n");
 }
 // 输出调试信息到标准错误流
 std::fprintf(stderr, "%s\n", s.c_str());
 return *this;
}

/**
 * @brief 使用 C 风格字符串获取配置项的值
 *
 * @param key 配置项的键
 * @return std::string* 如果找到配置项,返回其值的指针;否则返回 nullptr
 */
std::string *config::get_value(const char *key)
{
 // 查找指定键的配置项
 auto it = find(key);
 // 如果未找到该配置项
 if (it == end())
 {
 return nullptr;
 }
 return &(it->second);
}

/**
 * @brief 使用 std::string 获取配置项的值
 *
 * @param key 配置项的键
 * @return std::string* 如果找到配置项,返回其值的指针;否则返回 nullptr
 */
std::string *config::get_value(const std::string &key)
{
 // 查找指定键的配置项
 auto it = find(key);
 // 如果未找到该配置项
 if (it == end())
 {
 return nullptr;
 }
 return &(it->second);
}

/**
 * @brief 使用 C 风格字符串获取配置项的 C 风格字符串值
 *
 * @param key 配置项的键
 * @param def_val 默认值,如果未找到配置项,返回该默认值
 * @return const char* 配置项的值或默认值
 */
const char *config::get_cstring(const char *key, const char *def_val)
{
 // 查找指定键的配置项
 auto it = find(key);
 // 如果未找到该配置项
 if (it == end())
 {
 return def_val;
 }
 return it->second.c_str();
}

/**
 * @brief 使用 std::string 获取配置项的 C 风格字符串值
 *
 * @param key 配置项的键
 * @param def_val 默认值,如果未找到配置项,返回该默认值
 * @return const char* 配置项的值或默认值
 */
const char *config::get_cstring(const std::string &key, const char *def_val)
{
 // 查找指定键的配置项
 auto it = find(key);
 // 如果未找到该配置项
 if (it == end())
 {
 return def_val;
 }
 return it->second.c_str();
}

/**
 * @brief 使用 C 风格字符串获取配置项的 std::string 值
 *
 * @param key 配置项的键
 * @param def_val 默认值,如果未找到配置项,返回该默认值
 * @return std::string 配置项的值或默认值
 */
std::string config::get_string(const char *key, const char *def_val)
{
 // 查找指定键的配置项
 auto it = find(key);
 // 如果未找到该配置项
 if (it == end())
 {
 return def_val;
 }
 return it->second;
}

/**
 * @brief 使用 std::string 获取配置项的 std::string 值
 *
 * @param key 配置项的键
 * @param def_val 默认值,如果未找到配置项,返回该默认值
 * @return std::string 配置项的值或默认值
 */
std::string config::get_string(const std::string &key, const char *def_val)
{
 // 查找指定键的配置项
 auto it = find(key);
 // 如果未找到该配置项
 if (it == end())
 {
 return def_val;
 }
 return it->second;
}

/**
 * @brief 使用 std::string 获取配置项的 std::string 引用值
 *
 * @param key 配置项的键
 * @param def_val 默认值,如果未找到配置项,返回该默认值的引用
 * @return const std::string& 配置项的值或默认值的引用
 */
const std::string &config::get_string(const std::string &key, const std::string &def_val)
{
 // 查找指定键的配置项
 auto it = find(key);
 // 如果未找到该配置项
 if (it == end())
 {
 return def_val;
 }
 return it->second;
}

/**
 * @brief 使用 C 风格字符串获取配置项的布尔值
 *
 * @param key 配置项的键
 * @param def_val 默认值,如果未找到配置项,返回该默认值
 * @return bool 配置项的布尔值或默认值
 */
bool config::get_bool(const char *key, bool def_val)
{
 // 获取配置项的值
 std::string *val = get_value(key);
 // 如果未找到该配置项
 if (!val)
 {
 return def_val;
 }
 // 将字符串转换为布尔值
 return str_to_bool(val->c_str(), def_val);
}

/**
 * @brief 使用 std::string 获取配置项的布尔值
 *
 * @param key 配置项的键
 * @param def_val 默认值,如果未找到配置项,返回该默认值
 * @return bool 配置项的布尔值或默认值
 */
bool config::get_bool(const std::string &key, bool def_val)
{
 // 获取配置项的值
 std::string *val = get_value(key);
 // 如果未找到该配置项
 if (!val)
 {
 return def_val;
 }
 // 将字符串转换为布尔值
 return str_to_bool(val->c_str(), def_val);
}

/**
 * @brief 使用 C 风格字符串获取配置项的整数值
 *
 * @param key 配置项的键
 * @param def_val 默认值,如果未找到配置项,返回该默认值
 * @return int 配置项的整数值或默认值
 */
int config::get_int(const char *key, int def_val)
{
 // 获取配置项的值
 std::string *val = get_value(key);
 // 如果未找到该配置项
 if (!val)
 {
 return def_val;
 }
 // 将字符串转换为整数
 return std::atoi(val->c_str());
}

/**
 * @brief 使用 std::string 获取配置项的整数值
 *
 * @param key 配置项的键
 * @param def_val 默认值,如果未找到配置项,返回该默认值
 * @return int 配置项的整数值或默认值
 */
int config::get_int(const std::string &key, int def_val)
{
 // 获取配置项的值
 std::string *val = get_value(key);
 // 如果未找到该配置项
 if (!val)
 {
 return def_val;
 }
 // 将字符串转换为整数
 return std::atoi(val->c_str());
}

/**
 * @brief 使用 C 风格字符串获取配置项的长整数值
 *
 * @param key 配置项的键
 * @param def_val 默认值,如果未找到配置项,返回该默认值
 * @return int64_t 配置项的长整数值或默认值
 */
int64_t config::get_long(const char *key, int64_t def_val)
{
 // 获取配置项的值
 std::string *val = get_value(key);
 // 如果未找到该配置项
 if (!val)
 {
 return def_val;
 }
 // 将字符串转换为长整数
 return atol(val->c_str());
}

/**
 * @brief 使用 std::string 获取配置项的长整数值
 *
 * @param key 配置项的键
 * @param def_val 默认值,如果未找到配置项,返回该默认值
 * @return int64_t 配置项的长整数值或默认值
 */
int64_t config::get_long(const std::string &key, int64_t def_val)
{
 // 获取配置项的值
 std::string *val = get_value(key);
 // 如果未找到该配置项
 if (!val)
 {
 return def_val;
 }
 // 将字符串转换为长整数
 return atol(val->c_str());
}

/**
 * @brief 使用 C 风格字符串获取配置项的秒数
 *
 * @param key 配置项的键
 * @param def_val 默认值,如果未找到配置项,返回该默认值
 * @return int64_t 配置项的秒数或默认值
 */
int64_t config::get_second(const char *key, int64_t def_val)
{
 // 获取配置项的值
 std::string *val = get_value(key);
 // 如果未找到该配置项
 if (!val)
 {
 return def_val;
 }
 // 将字符串转换为秒数
 return str_to_second(val->c_str(), def_val);
}

/**
 * @brief 使用 std::string 获取配置项的秒数
 *
 * @param key 配置项的键
 * @param def_val 默认值,如果未找到配置项,返回该默认值
 * @return int64_t 配置项的秒数或默认值
 */
int64_t config::get_second(const std::string &key, int64_t def_val)
{
 // 获取配置项的值
 std::string *val = get_value(key);
 // 如果未找到该配置项
 if (!val)
 {
 return def_val;
 }
 // 将字符串转换为秒数
 return str_to_second(val->c_str(), def_val);
}

/**
 * @brief 使用 C 风格字符串获取配置项的大小值
 *
 * @param key 配置项的键
 * @param def_val 默认值,如果未找到配置项,返回该默认值
 * @return int64_t 配置项的大小值或默认值
 */
int64_t config::get_size(const char *key, int64_t def_val)
{
 // 获取配置项的值
 std::string *val = get_value(key);
 // 如果未找到该配置项
 if (!val)
 {
 return def_val;
 }
 // 将字符串转换为大小值
 return str_to_size(val->c_str(), def_val);
}

/**
 * @brief 使用 std::string 获取配置项的大小值
 *
 * @param key 配置项的键
 * @param def_val 默认值,如果未找到配置项,返回该默认值
 * @return int64_t 配置项的大小值或默认值
 */
int64_t config::get_size(const std::string &key, int64_t def_val)
{
 // 获取配置项的值
 std::string *val = get_value(key);
 // 如果未找到该配置项
 if (!val)
 {
 return def_val;
 }
 // 将字符串转换为大小值
 return str_to_size(val->c_str(), def_val);
}

std::list<int64_t> config::get_int64_list(const char *key, const char *sep)
{
 std::list<int64_t> ret;
 std::string tmp = get_string(key, "");
 if (!tmp.empty())
 {
 auto tmpids = zcc::split(tmp, sep);
 for (auto &tmpid : tmpids)
 {
 auto id = std::atoi(tmpid.c_str());
 if (id < 0)
 {
 continue;
 }
 ret.push_back(id);
 }
 }
 return ret;
}

std::vector<int64_t> config::get_int64_vector(const char *key, const char *sep)
{
 std::vector<int64_t> ret;
 std::string tmp = get_string(key, "");
 if (!tmp.empty())
 {
 auto tmpids = zcc::split(tmp, sep);
 for (auto &tmpid : tmpids)
 {
 auto id = std::atoi(tmpid.c_str());
 if (id < 0)
 {
 continue;
 }
 ret.push_back(id);
 }
 }
 return ret;
}

zcc_namespace_end;