class Thread: public Noncopyable{
public:
    using ptr = std::shared_ptr<Thread>;

    Thread(std::function<void()> cb, const std::string& name);

    ~Thread();

    pid_t getId() const { return m_id; }

    std::string getName() const { return m_name; }

    // 线程的join操作：阻塞等待线程执行完成
    void join();

    // 获取当前线程的指针
    static Thread* GetThis();

    // 获取当前线程的名称
    static std::string GetName();

    // 设置当前线程的名称
    static void SetName(const std::string& name);

    // 初始化线程属性并执行线程的任务函数
    static void* run(void* arg);

private:
    // 全局的线程id（内核态id），主要用于日志等操作
    pid_t m_id = -1;
    // pthread返回的线程id标识（用户态id）
    pthread_t m_thread = 0;
    // 线程需要执行的任务函数
    std::function<void()> m_cb;
    // 线程名称
    std::string m_name;
    // 信号量
    Semaphore m_semaphore;
};

class Noncopyable{
public:
    Noncopyable() = default;

    ~Noncopyable() = default;

    Noncopyable(const Noncopyable&) = delete;

    Noncopyable& operator=(const Noncopyable&) = delete;
};

Thread::Thread(std::function<void()> cb, const std::string& name)
    : m_cb(cb)
    , m_name(name){
    if(name.empty()){
        m_name = "UNKNOW";
    }
    // pthread_create：创建线程，创建成功返回0
    //  通过传递 this 指针，可以在新线程的上下文中访问调用 Thread 的当前实例对象，
    //  从而允许线程函数 run() 操作该对象的成员变量和成员函数
    int rt = pthread_create(&m_thread, nullptr, &Thread::run, this);
    if(rt){
        SYLAR_LOG_ERROR(g_logger) << "pthread_create fail, errnum=" << rt
                                  << " name=" << name;
        throw std::logic_error("pthread_create error");
    }
    // 阻塞信号量，等待run()中线程初始化完成
    m_semaphore.wait();
}

void* Thread::run(void* arg){
    // pthread_create中，run接收一个this，即Thread*参数
    Thread* thread = (Thread*)arg;

    // 初始化当前线程的属性并绑定到线程局部存储
    t_thread = thread;
    t_thread_name = thread->m_name;
    thread->m_id = sylar::GetThreadId();

    // pthread_setname_np：设置线程名称，只取m_name的前15个字符（Linux 限制线程名称最长为 16 字符，包括末尾'\0'）
    pthread_setname_np(pthread_self(), thread->m_name.substr(0, 15).c_str());

    // 将线程的任务回调函数移动到局部变量 cb，避免线程对象中的 m_cb 被多线程并发访问
    std::function<void()> cb;
    cb.swap(thread->m_cb);

    // 线程初始化完成后对信号量解锁
    thread->m_semaphore.notify();

    // 执行任务函数
    cb();

    return 0;
}

static thread_local Thread* t_thread = nullptr;
static thread_local std::string t_thread_name = "UNKNOW";

Thread* Thread::GetThis(){
    return t_thread;
}
std::string Thread::GetName(){
    return t_thread_name;
}

void Thread::SetName(const std::string& name){
    if(name.empty()){
        return;
    }
    // 如果当前线程已经创建成功，就设置其name
    if(t_thread){
        t_thread->m_name = name;
    }
    // 设置全局的线程name值
    t_thread_name = name;
}

void Thread::join(){
    if(m_thread){
        // 对当前线程执行join
        int rt = pthread_join(m_thread, nullptr);
        if(rt){
            SYLAR_LOG_ERROR(g_logger) << "pthread_joib fail, errnum=" << rt
                                    << " name=" << m_name;
            throw std::logic_error("pthread_join error");            
        }
        // 重置m_thread
        m_thread = 0;        
    }
}

Thread::~Thread(){
    // 对当前线程进行detach
    if(m_thread){
        pthread_detach(m_thread);
    }
}

class Semaphore: public Noncopyable{
public:
    explicit Semaphore(uint32_t count = 0);

    ~Semaphore();

    // 信号量P操作：获取/等待信号量
    void wait();

    // 信号量V操作：释放信号量
    void notify();

private:
    // 信号量变量
    sem_t m_semaphore;
};

Semaphore::Semaphore(uint32_t count){
    if(sem_init(&m_semaphore, 0, count)){
        SYLAR_LOG_ERROR(g_logger) << "sem_init error";
        throw std::logic_error("sem_init error");
    }
}

Semaphore::~Semaphore(){
    sem_destroy(&m_semaphore);
}

void Semaphore::wait(){
    // sem_t不需要注意虚假唤醒问题
    if(sem_wait(&m_semaphore)){
        SYLAR_LOG_ERROR(g_logger) << "sem_wait error";
        throw std::logic_error("sem_wait error");
    }
}

void Semaphore::notify(){
    if(sem_post(&m_semaphore)){
        SYLAR_LOG_ERROR(g_logger) << "sem_post error";
        throw std::logic_error("sem_post error");
    }
}

using Lock = ScopedLockImpl<Mutex>

template<typename T>
struct ScopedLockImpl{
public:
    ScopedLockImpl(T& mutex)
        : m_mutex(mutex)
        , m_locked(false){
        lock();
    }

    ~ScopedLockImpl(){
        unlock();
    }

    // 上锁操作
    void lock(){
        if(!m_locked){
            m_mutex.lock();
            m_locked = true;
        }
    }

    // 解锁操作
    void unlock(){
        if(m_locked){
            m_mutex.unlock();
            m_locked = false;
        }
    }

private:
    T& m_mutex;
    // 当前锁的状态
    bool m_locked;
};

class RWMutex: public Noncopyable{
public:
    using ReadLock = ReadScopedLockImpl<RWMutex>;
    using WriteLock = WriteScopedLockImpl<RWMutex>;

    RWMutex(){
        pthread_rwlock_init(&m_mutex, nullptr);
    }

    ~RWMutex(){
        pthread_rwlock_destroy(&m_mutex);
    }

    void rdlock(){
        pthread_rwlock_rdlock(&m_mutex);
    }

    void wrlock(){
        pthread_rwlock_wrlock(&m_mutex);
    }

    void unlock(){
        pthread_rwlock_unlock(&m_mutex);
    }

private:
    pthread_rwlock_t m_mutex;
};

// RAII类封装局部写锁
template<typename T>
struct ReadScopedLockImpl{
public:
    ReadScopedLockImpl(T& mutex)
        : m_mutex(mutex)
        , m_locked(false){
        lock();
    }

    ~ReadScopedLockImpl(){
        unlock();
    }

    // 上锁操作
    void lock(){
        if(!m_locked){
            m_mutex.rdlock();
            m_locked = true;
        }
    }

    // 解锁操作
    void unlock(){
        if(m_locked){
            m_mutex.unlock();
            m_locked = false;
        }
    }

private:
    T& m_mutex;
    // 使用atomic变量来保证m_locked的多线程安全性
    std::atomic<bool> m_locked;
};


// RAII类封装范围锁
// 接收一个锁，构造时自动加锁，析构时自动解锁
template<typename T>
struct WriteScopedLockImpl{
public:
    WriteScopedLockImpl(T& mutex)
        : m_mutex(mutex)
        , m_locked(false){
        lock();
    }

    ~WriteScopedLockImpl(){
        unlock();
    }

    // 上锁操作
    void lock(){
        if(!m_locked){
            m_mutex.wrlock();
            m_locked = true;
        }
    }

    // 解锁操作
    void unlock(){
        if(m_locked){
            m_mutex.unlock();
            m_locked = false;
        }
    }

private:
    T& m_mutex;
    // 使用atomic变量来保证m_locked的多线程安全性
    std::atomic<bool> m_locked;
};

class Mutex{
public:
    using Lock = ScopedLockImpl<Mutex>;

    Mutex(){
        pthread_mutex_init(&m_mutex, 0);
    }

    ~Mutex(){
        pthread_mutex_destroy(&m_mutex);
    }

    void lock(){
        pthread_mutex_lock(&m_mutex);
    }

    void unlock(){
        pthread_mutex_unlock(&m_mutex);
    }

private:
    pthread_mutex_t m_mutex;
};

class SpinLock{
public:
    using Lock = ScopedLockImpl<SpinLock>;

    SpinLock(){
        pthread_spin_init(&m_mutex, 0);
    }

    ~SpinLock(){
        pthread_spin_destroy(&m_mutex);
    }

    void lock(){
        pthread_spin_lock(&m_mutex);
    }

    void unlock(){
        pthread_spin_unlock(&m_mutex);
    }

private:
    pthread_spinlock_t m_mutex;
};

static sylar::ConfigVar<int>::ptr g_tcp_connect_timeout = \
sylar::Config::Lookup("tcp.connect.timeout", 5000, "tcp connect timeout");

class ConfigVarBase{
public:
    using ptr = std::shared_ptr<ConfigVarBase>;

    ConfigVarBase(const std::string& name, const std::string& description = "")
        :m_name(name)
        ,m_description(description){
    }

    virtual ~ConfigVarBase(){}

    std::string getName() const { return m_name; }

    std::string getDescription() const { return m_description; }

    virtual std::string getTypename() const = 0;

    // 将配置参数的值转换为字符串
    virtual std::string toString() = 0;

    // 从字符串中获取配置参数初始值
    virtual bool fromString(const std::string& val) = 0;

private:
    // 配置参数的名称
    std::string m_name;
    // 配置参数的描述
    std::string m_description;
};

// FromStr和ToStr：两个仿函数，用于将字符串转换为数值类型 / 将数值转换为字符串
// FromStr: T operator(const std::string&)
// ToStr: std::string operator(const T&)
template<typename T, typename FromStr = Lexical_cast<std::string, T>
                   , typename ToStr = Lexical_cast<T, std::string>>
class ConfigVar: public ConfigVarBase{
public:
    using ptr = std::shared_ptr<ConfigVar>;
    using on_change_cb = std::function<void(const T& oldVal, const T& newVal)>;
    using RWMutexType = RWMutex;

    ConfigVar(const std::string& name
            , const T& val
            , const std::string& description = "")
        : ConfigVarBase(name, description)
        , m_val(val){
    }

    // 调用ToStr()将配置值转换为Yaml字符串返回
    std::string toString() override {
        try{
            RWMutexType::ReadLock lock(m_mutex);
            // return boost::lexical_cast<std::string>(m_val);
            return ToStr()(m_val);
        } catch(std::exception& e) {
            SYLAR_LOG_ERROR(SYLAR_LOG_ROOT()) << "ConfigVar::toString exception: "
                << e.what() << " convert: " << typeid(m_val).name() << " to string";
        }
        return "";
    }

    // 调用FromStr()将Yaml字符串解析为配置值
    bool fromString(const std::string& val) override {
        try{
            // setValue 中进行了加锁操作，这里不需要额外加锁
            // m_val = boost::lexical_cast<T>(val);
            setValue(FromStr()(val));
            return true;
        } catch(std::exception& e) {
            SYLAR_LOG_ERROR(SYLAR_LOG_ROOT()) << "ConfiVar::fromString exception: "
                << e.what() << " convert string to " << typeid(m_val).name(); 
        }
        return false;
    }

    // 获取配置项的值
    const T getValue() const {
        RWMutexType::ReadLock lock(m_mutex);
        return m_val;
    }
    // 设置配置项的值
    void setValue(const T& val){
        // 先读后写
        {
            // 使用{}来控制RAII类的作用范围
            RWMutexType::ReadLock lock(m_mutex);
            if(val == m_val){
                return;
            }
            // 如果配置项的值发生了变化，通知所有回调函数
            for(auto cb : m_cbs){
                cb.second(m_val, val);
            }
        }
        RWMutexType::WriteLock lock(m_mutex);
        m_val = val;
    }

    std::string getTypename() const override { return typeid(T).name(); }

    // 添加回调函数，返回该回调函数的唯一id
    uint64_t addListener(on_change_cb cb){
        // 自动创建回调函数对应的key
        static uint64_t s_cbfun_id = 0;

        RWMutexType::WriteLock lock(m_mutex);
        ++s_cbfun_id;
        m_cbs[s_cbfun_id] = cb;
        return s_cbfun_id;
    };

    void delListener(uint64_t key){
        RWMutexType::WriteLock lock(m_mutex);
        m_cbs.erase(key);
    };

    on_change_cb getListener(uint64_t key){
        RWMutexType::ReadLock lock(m_mutex);
        auto it = m_cbs.find(key);
        return it == m_cbs.end() ? nullptr : it->second;
    };

    void clearListener(){
        RWMutexType::WriteLock lock(m_mutex);
        m_cbs.clear();
    };


private:
    // 配置项的值
    T m_val;
    // 管理回调函数的map
    std::map<uint64_t, on_change_cb> m_cbs;
    // 读写锁
    mutable RWMutexType m_mutex;
};

// 调用ToStr()将配置值转换为Yaml字符串返回
  std::string toString() override {
      try{
          RWMutexType::ReadLock lock(m_mutex);
          // return boost::lexical_cast<std::string>(m_val);
          return ToStr()(m_val);
      } catch(std::exception& e) {
          SYLAR_LOG_ERROR(SYLAR_LOG_ROOT()) << "ConfigVar::toString exception: "
              << e.what() << " convert: " << typeid(m_val).name() << " to string";
      }
      return "";
  }

  // 调用FromStr()将Yaml字符串解析为配置值
  bool fromString(const std::string& val) override {
      try{
          // setValue 中进行了加锁操作，这里不需要额外加锁
          // m_val = boost::lexical_cast<T>(val);
          setValue(FromStr()(val));
          return true;
      } catch(std::exception& e) {
          SYLAR_LOG_ERROR(SYLAR_LOG_ROOT()) << "ConfiVar::fromString exception: "
              << e.what() << " convert string to " << typeid(m_val).name(); 
      }
      return false;
  }

// 添加回调函数，返回该回调函数的唯一id
  uint64_t addListener(on_change_cb cb){
      // 自动创建回调函数对应的key
      static uint64_t s_cbfun_id = 0;

      RWMutexType::WriteLock lock(m_mutex);
      ++s_cbfun_id;
      m_cbs[s_cbfun_id] = cb;
      return s_cbfun_id;
  };

// 设置配置项的值
  void setValue(const T& val){
      // 先读后写
      {
          // 使用{}来控制RAII类的作用范围
          RWMutexType::ReadLock lock(m_mutex);
          if(val == m_val){
              return;
          }
          // 如果配置项的值发生了变化，通知所有回调函数
          for(auto cb : m_cbs){
              cb.second(m_val, val);
          }
      }
      RWMutexType::WriteLock lock(m_mutex);
      m_val = val;
  }

class Config{
public:
    using ConfigVarMap = std::unordered_map<std::string, ConfigVarBase::ptr>;
    using RWMutexType = RWMutex;

    // 根据name在容器中查找配置项
    template<typename T>
    static typename ConfigVar<T>::ptr Lookup(const std::string& name){
        // 这个Lookup版本只进行读操作，所以上读锁
        RWMutexType::ReadLock lock(GetMutex());

        auto it = GetDatas().find(name);
        if(it != GetDatas().end()){
            // dynamic_pointer_cast可以理解为作用于shared_ptr上的dynamic_cast
            return std::dynamic_pointer_cast<ConfigVar<T>>(it->second);
        }
        return nullptr;
    }    
    
    // 在容器中查找配置项，如果找不到就尝试新增配置项
    template<typename T>
    static typename ConfigVar<T>::ptr Lookup(const std::string& name, 
            const T& default_value, const std::string& description = ""){
        auto& mp = GetDatas();
        // 先上一个读锁，进行查询操作
        {
            RWMutexType::ReadLock lock(GetMutex());
            auto it = mp.find(name);
            if(it != GetDatas().end()){
                return Config::pointer_cast<T>(name, it->second);
            }
        }

        // 检查name中是否所有字符都合法
        if(name.find_first_not_of("1234567890._abcdefghijklmnopqrstuvwxyz")
            != std::string::npos){
            // name中存在非法字符，写入错误log并抛出invalid_argument异常
            SYLAR_LOG_ERROR(SYLAR_LOG_ROOT()) << "Lookup name invalid: " << name;
            throw std::invalid_argument(name);
        }

        // 如果查询失败，就尝试在容器中新增一个配置参数项
        // 上写锁，进行插入操作
        RWMutexType::WriteLock lock(GetMutex());
        // 再次检查 name 是否存在，避免多线程重复插入的问题
        auto it = mp.find(name);
        if(it != mp.end()){
            return Config::pointer_cast<T>(name, it->second);
        }
        typename ConfigVar<T>::ptr newConfigVar = std::make_shared<ConfigVar<T>>(name, default_value, description);
        mp[name] = newConfigVar;
        // SYLAR_LOG_DEBUG(SYLAR_LOG_ROOT()) << "Add config name: " << name << ", type: "<< typeid(T).name();
        // SYLAR_LOG_DEBUG(SYLAR_LOG_ROOT()) << " -Add config: " << name;
        return newConfigVar;
    }

    // 查找name，并返回其父类指针（利用多态性）
    static ConfigVarBase::ptr LookupBase(const std::string& name);

    // 从Yaml中加载配置
    static void LoadFromYaml(const YAML::Node& root);

    // Visit接收一个回调函数cb，对Config管理的所有配置项应用该回调函数
    static void Visit(std::function<void(ConfigVarBase::ptr)> cb);

private:
    // 封装 dynamic_pointer_cast 和类型检查逻辑操作
    template<typename T>
    static typename ConfigVar<T>::ptr pointer_cast(const std::string& name, ConfigVarBase::ptr val){
        typename ConfigVar<T>::ptr tmp = std::dynamic_pointer_cast<ConfigVar<T>>(val);;
        if(tmp){
            SYLAR_LOG_INFO(SYLAR_LOG_ROOT()) << "Lookup name=" << name << "exists.";
            return tmp;
        } else {
            SYLAR_LOG_ERROR(SYLAR_LOG_ROOT()) << "Lookup name=" << name << ", but type not <"
                << typeid(T).name() << ">, real type=<" << val->getTypename() << ">";
        }
        return nullptr;
    }

    // 使用静态成员函数获取数据，避免静态变量的初始化顺序问题（见Effective C++条款4）
    static ConfigVarMap& GetDatas(){
        static ConfigVarMap s_datas;
        return s_datas;
    }

    // 因为读写锁应用的对象为静态变量，所以也需要使用静态成员函数获得读写锁
    static RWMutexType& GetMutex(){
        static RWMutexType s_mutex;
        return s_mutex;
    }
};

// 使用静态成员函数获取数据，避免静态变量的初始化顺序问题
  static ConfigVarMap& GetDatas(){
      static ConfigVarMap s_datas;
      return s_datas;
  }
  
  // 因为读写锁应用的对象为静态变量，所以也需要使用静态成员函数获得读写锁
  static RWMutexType& GetMutex(){
      static RWMutexType s_mutex;
      return s_mutex;
  }

void Config::Visit(std::function<void(ConfigVarBase::ptr)> cb){
    RWMutexType::ReadLock lock(GetMutex());
    auto& mp = GetDatas();
    for(auto& i : mp){
        cb(i.second);
    }
}

// 从Yaml中导入配置
void Config::LoadFromYaml(const YAML::Node& root){
    // 将Yaml的树状结构拍平为list（方便遍历）
    // <name, yaml_node>
    std::list<std::pair<std::string, const YAML::Node>> all_nodes;
    ListAllMember("", root, all_nodes);

    // 遍历Yaml，逐个解析配置项
    for(auto& item : all_nodes){
        std::string key = item.first;
        if(key.empty()){
            continue;
        }

        // 将键转换为全小写
        std::transform(key.begin(), key.end(), key.begin(), ::tolower);
        // std::cout << key << std::endl;

        // 在Config容器中查找一项配置项var（只查找注册过的配置项，如果没有找到不会自动添加配置项）
        ConfigVarBase::ptr var = LookupBase(item.first);
        // 从字符串获取配置项var的值
        if(var){
            if(item.second.IsScalar()){
                var->fromString(item.second.Scalar());
            } else {
                std::stringstream ss;
                ss << item.second;
                // ss.str()为Yaml格式的字符串，交给fromString来解析
                var->fromString(ss.str());
            }
        }
    }
}

// vector -> Yaml格式字符串
template<typename T>
class Lexical_cast<std::vector<T>, std::string>{
public:
    std::string operator()(const std::vector<T> vec){
        YAML::Node node(YAML::NodeType::Sequence);
        for(auto& i : vec){
            // 递归地将vec的元素转换为Yaml字符串格式
            node.push_back(YAML::Load(Lexical_cast<T, std::string>()(i)));
        }
        // 使用stringstream来接收Yaml格式字符串
        std::stringstream ss;
        ss << node;
        return ss.str();
    }
};

// Yaml格式字符串 -> vector
template<typename T>
class Lexical_cast<std::string, std::vector<T>>{
public:
    std::vector<T> operator()(const std::string str){
        // 使用YAML::Load解析Yaml格式字符串
        YAML::Node nodes = YAML::Load(str);
        std::vector<T> vec;
        std::stringstream ss;
        for(const auto& node : nodes){
            // 使用使用stringstream来接收Yaml格式字符串
            ss.str("");
            ss << node;
            // 递归地将Yaml格式字符串转换为vec的元素
            vec.push_back(Lexical_cast<std::string, T>()(ss.str()));
        }
        return vec;
    }
};

// map，只支持key类型为std::string
// map -> Yaml格式字符串
template<typename T>
class Lexical_cast<std::map<std::string, T>, std::string>{
public:
    std::string operator()(const std::map<std::string, T> mp){
        YAML::Node node(YAML::NodeType::Map);
        for(auto& i : mp){
            node[i.first] = YAML::Load(Lexical_cast<T, std::string>()(i.second));
        }
        std::stringstream ss;
        ss << node;
        return ss.str();
    }
};

// Yaml格式字符串 -> map
template<typename T>
class Lexical_cast<std::string, std::map<std::string, T>>{
public:
    std::map<std::string, T> operator()(const std::string str){
        YAML::Node nodes = YAML::Load(str);
        std::map<std::string, T> mp;
        std::stringstream ss;
        for(const auto& node : nodes){
            ss.str("");
            ss << node.second;
            mp.insert(std::make_pair(node.first.Scalar(),
                                     Lexical_cast<std::string, T>()(ss.str())));
        }
        return mp;
    }
};

// YAML文件载入为YAML::Node
YAML::Node root = YAML::LoadFile("/conf/test.yml");
// 从YAML::Node中载入配置项
sylar::Config::LoadFromYaml(root);

sylar::ConfigVar<int>::ptr g_int_value_config = 
    sylar::Config::Lookup<int>("system.port", 8080, "system port");

sylar::ConfigVar<std::vector<int> >::ptr g_int_vec_value_config =
    sylar::Config::Lookup("system.int_vec", std::vector<int>{1, 2}, "system int vector");

sylar::ConfigVar<std::list<int> >::ptr g_int_list_value_config =
    sylar::Config::Lookup("system.int_list", std::list<int>{1, 2}, "system int list");

sylar::ConfigVar<std::set<int> >::ptr g_int_set_value_config =
    sylar::Config::Lookup("system.int_set", std::set<int>{1, 2}, "system int set");

sylar::ConfigVar<std::unordered_set<int> >::ptr g_int_uset_value_config =
    sylar::Config::Lookup("system.int_uset", std::unordered_set<int>{1, 2}, "system int unordered_set");

sylar::ConfigVar<std::map<std::string, int> >::ptr g_str_int_map_value_config =
    sylar::Config::Lookup("system.str_int_map", std::map<std::string, int>{{"k",2}}, "system str int map");

sylar::ConfigVar<std::unordered_map<std::string, int> >::ptr g_str_int_umap_value_config =
    sylar::Config::Lookup("system.str_int_umap", std::unordered_map<std::string, int>{{"k",2}}, "system str int map");

struct LogAppenderDefine{
    int type = 0;   // 1: File, 2: Stdout
    std::string pattern;
    std::string file;

    bool operator==(const LogAppenderDefine& oth) const {
        return type == oth.type
            && pattern == oth.pattern
            && file == oth.file;
    }
};

// 记录Logger相关信息的结构体
struct LoggerDefine{
    std::string name;
    LogLevel::Level level = LogLevel::UNKNOW;
    std::vector<LogAppenderDefine> appenders;

    bool operator==(const LoggerDefine& oth) const {
        return name == oth.name
            && level == oth.level
            && appenders == oth.appenders;
    }

    bool operator!=(const LoggerDefine& oth) const {
        return !(*this == oth);
    }

    bool operator<(const LoggerDefine& oth) const {
        return name < oth.name;
    }
};

// 偏特化Lexical_cast
// Yaml字符串 -> LoggerDefine
template<>
class Lexical_cast<std::string, LoggerDefine>{
public:
    LoggerDefine operator()(const std::string& val){
        YAML::Node node = YAML::Load(val);
        LoggerDefine ld;
        if(!node["name"].IsDefined()){
            std::cerr << "log config error: name is null" << node << std::endl;
            throw std::logic_error("log config name is null");
        }
        // 处理name和level
        ld.name = node["name"].as<std::string>();
        ld.level = LogLevel::FromString(node["level"].IsDefined() ? node["level"].as<std::string>() : "");
        // 处理appenders
        if(node["appenders"].IsDefined()){
            for(auto a : node["appenders"]){
                if(!a["type"].IsDefined()){
                    std::cerr << "log config error: appender type is null" << a << std::endl;
                    continue;
                }
                LogAppenderDefine lad;

                // 不同的appender类型设置不同的type，FileLogAppender还需要获取输出的文件路径
                std::string type = a["type"].as<std::string>();
                if(type == "FileLogAppender"){
                    lad.type = 1;
                    if(!a["file"].IsDefined()){
                        std::cerr << "log config error: FileLogAppender filename is null" << a << std::endl;
                        continue;
                    }
                    lad.file = a["file"].as<std::string>();
                } else if(type == "StdoutLogAppender"){
                    lad.type = 2;
                } else {
                    std::cerr << "log config error: appender type is invalid" << a << std::endl;
                    continue;
                }
                // 以上appender都需要检测是否配置了formatter的pattern
                if(a["pattern"].IsDefined()){
                    lad.pattern = a["pattern"].as<std::string>();
                }
                // 将处理完成的LogAppenderDefine加入appenders中
                ld.appenders.push_back(lad);
            }
        }
        return ld;
    }
};

// LoggerDefine -> Yaml字符串
template<>
class Lexical_cast<LoggerDefine, std::string>{
public:
    std::string operator()(const LoggerDefine& ld){
        YAML::Node node(YAML::NodeType::Map);
        node["name"] = ld.name;
        node["level"] = LogLevel::ToString(ld.level);
        std::stringstream ss_appenders;
        for(const auto& lad : ld.appenders){
            YAML::Node nlad(YAML::NodeType::Map);
            if(lad.type == 1){
                nlad["type"] = "FileLogAppender";
                nlad["file"] = lad.file;
            } else if (lad.type == 2){
                nlad["type"] = "StdoutLogAppender";
            }
            if(!lad.pattern.empty()){
                nlad["pattern"] = lad.pattern;
            }
            node["appenders"].push_back(nlad);
        }
        std::stringstream ss;
        ss << node;
        return ss.str();
    }
};

// 注册 logs 配置项
ConfigVar<std::set<LoggerDefine>>::ptr g_log_config = 
        Config::Lookup("logs", std::set<LoggerDefine>(), "logs config");

struct LogIniter{
    LogIniter(){
        // SYLAR_LOG_INFO(SYLAR_LOG_ROOT()) << "g_log_config add callback";
        g_log_config->addListener([](const std::set<LoggerDefine>& oldVal,
                                     const std::set<LoggerDefine>& newVal){
            // 监测以下三种情况：新增 / 修改 / 删除
            for(auto& i : newVal){
                auto it = oldVal.find(i);
                Logger::ptr logger;
                if(it == oldVal.end()){
                    // <新增>
                    logger = SYLAR_LOG_NAME(i.name);
                } else {
                    if(i != *it){
                        // <修改>
                        logger = SYLAR_LOG_NAME(i.name);
                    } else {
                        continue;
                    }
                }
                // 根据newVal中的数据成员修改logger配置
                // 设置level
                logger->setLevel(i.level);
                // 设置appenders
                logger->clearAppenders();
                for(auto &a : i.appenders){
                    LogAppender::ptr ap;
                    if(a.type == 1){
                        ap.reset(new FileLogAppender(a.file));
                    } else if(a.type == 2){
                        ap.reset(new StdoutLogAppender());
                    }
                    // pattern非空时设置自定义formatter，否则使用默认formatter
                    if(!a.pattern.empty()){
                        ap->setFormatter(LogFormatter::ptr(new LogFormatter(a.pattern)));
                    }
                    logger->addAppender(ap);
                }
            }

            // <删除>
            for(auto& i : oldVal){
                auto it = newVal.find(i);
                if(it == newVal.end()){
                    // 对配置文件中被删除的logger执行逻辑删除
                    Logger::ptr logger = SYLAR_LOG_NAME(i.name);
                    // 逻辑删除：将Level设置为访问不到的级别，并清空所有appender
                    logger->setLevel(LogLevel::NOTSET);
                    logger->clearAppenders();
                }
            }
        });
    }
};
// 全局对象在main函数前构造
static LogIniter __log_init;