#include <mc/reflect.h>

class User {
public:
    std::string name;
    int id;
    std::vector<std::string> tags;
};
MC_REFLECT(User, (name)(id)(tags))

// 序列化对象
User user{"admin", 1001, {"staff", "devops"}};
mc::variant var = user;
std::cout << "JSON: " << mc::json::to_string(var);

// 反序列化对象
std::string json = "{\"name\":\"guest\",\"id\":1002,\"tags\":[\"visitor\"]}";
User new_user = mc::json::from_string(json).as<User>();

#include <mc/log.h>

// 注册日志后端
MC_LOG_REGISTER_APPENDER(console, mc::log::ConsoleAppender);

int main() {
    // 配置日志系统
    mc::log::Logger::getInstance()
        .setAppender<mc::log::RollingFileAppender>("app.log", 10*1024*1024, 5)
        .setLevel(mc::log::Level::Debug);

    // 记录简单日志
    MC_LOG_INFO("系统初始化完成");

    // 记录结构化日志
    MC_LOG_INFO("用户活动")
        << "user_id=" << 42
        << "action=" << "login";

    // 使用全局日志宏
    ilog("系统初始化完成");
    ilog("用户 ${user} 从 ${ip} 登录成功", ("user", "admin")("ip", "192.168.1.100"));
    elog("连接数据库失败: ${error}", ("error", "Connection timeout"));

    return 0;
}

#include <mc/core/application.h>

// 定义服务
class my_service : public mc::service_base<my_service> {
public:
    static const char* service_type() { return "example.my_service"; }

    static void register_options(mc::po::options_description& cfg_opts) {
        cfg_opts.add_options()
            ("my_service.timeout", mc::po::value<int>()->default_value(30), "超时时间(秒)");
    }

    static const std::vector<std::string>& dependencies() {
        static std::vector<std::string> deps = {"logger"};
        return deps;
    }

    bool init(mc::dict args) override {
        m_timeout = args.get("my_service.timeout").as<int>();
        return true;
    }

    bool start() override {
        set_state(mc::service_state::running);
        return true;
    }

    bool stop() override {
        set_state(mc::service_state::stopped);
        return true;
    }

private:
    int m_timeout;
};

// 定义插件
class my_plugin : public mc::plugin_base<my_plugin> {
public:
    static const char* plugin_name() { return "my_plugin"; }
    bool initialize() override { return true; }
    void startup() override {}
    void shutdown() override {}
};

// 应用程序入口
int main(int argc, char** argv) {
    try {
        mc::application& app = mc::application::instance();
        app.set_version("1.0.0");
        app.register_plugin<my_plugin>();
        app.initialize(argc, argv);
        app.startup();
        app.exec();
        return 0;
    } catch (const std::exception& e) {
        std::cerr << "错误: " << e.what() << std::endl;
        return 1;
    }
}

#include <mc/exception.h>

void database_operation() {
    try {
        throw std::runtime_error("连接失败");
    } catch (const std::exception& e) {
        MC_THROW(mc::db_error, "数据库操作失败")
            << mc::error_info("operation", "query")
            << mc::error_info("sql", "SELECT * FROM users")
            << mc::error_cause(e);
    }
}

int main() {
    try {
        database_operation();
    } catch (const mc::exception& e) {
        std::cerr << "错误: " << e.what() << std::endl;
        std::cerr << "错误码: " << e.code() << std::endl;
    }
    return 0;
}

#include <mc/module.h>

// 内建模块定义
MC_MODULE(mc_devices)

namespace mc::devices {
class sensor {
public:
    void set_name(const std::string& name) { m_name = name; }
    const std::string& get_name() const { return m_name; }
private:
    std::string m_name{"default_sensor"};
};
}

MC_MODULE_REFLECT(mc_devices,
    (mc::devices::sensor, "Sensor"),
    ((set_name, "setName"))
    ((get_name, "getName")))

// 在 .cpp 中实现内建模块
MC_BUILTIN_MODULE_IMPL(mc_devices);

// 使用模块
int main() {
    auto devices_module = mc::load_module("mc.devices");
    if (!devices_module) {
        elog("无法加载设备模块");
        return -1;
    }
    auto factory = devices_module->get_factory();
    auto sensor_obj = factory->try_create_object("Sensor");
    sensor_obj->invoke_method("setName", {mc::variant("温度传感器")});
    return 0;
}

#include <mc/dbus/connection.h>
#include <mc/dbus/message.h>

mc::runtime::thread_pool executor(4);
executor.start();

auto conn = mc::dbus::connection::open_session_bus(executor);
conn.start();

// 请求服务名称
auto [success, err_opt] = conn.request_name("org.example.MyService");
if (!success) {
    std::cerr << "请求名称失败" << std::endl;
}

// 同步调用
auto msg = mc::dbus::message::new_method_call(
    "org.freedesktop.DBus", "/org/freedesktop/DBus",
    "org.freedesktop.DBus", "ListNames");
auto reply = conn.send_with_reply_and_block(msg, mc::seconds(5));

// 信号订阅
auto rule = mc::dbus::match_rule::new_signal("NameOwnerChanged", "org.freedesktop.DBus");
conn.add_match(rule, [](mc::dbus::message& msg) {
    std::cout << "收到信号: " << msg.get_member() << std::endl;
}, 1);

// 命令行调试 D-Bus
// busctl introspect org.example.MyService /org/example/MyService
// busctl call org.example.MyService /org/example/MyService org.example.MyService MethodName

class my_component_object : public mc::app::micro_component_object {
public:
    void init(mc::string_view service_name) {
        mc::app::micro_component_object::init(service_name);
        m_mc_iface.m_status = "Running";
    }
};

class my_service : public mc::engine::service {
public:
    int32_t on_health_check() const override {
        if (check_resources()) return 0;  // 健康
        return -1;  // 不健康
    }
};

mc::string on_export_config(mc::string type) override {
    mc::json config;
    config["my_setting"] = get_my_setting();
    return mc::string(config.dump(2));
}

void on_import_config(mc::string data, mc::string type) override {
    auto config = mc::json::parse(data);
    if (config.contains("my_setting")) {
        set_my_setting(config["my_setting"]);
    }
}

void on_dump(mc::string filepath) override {
    mc::string my_info = mc::string::concat(filepath, "/my_info.json");
    mc::json info;
    info["connections"] = get_connection_count();
    mc::filesystem::write_file(my_info, info.dump(2));
}

int32_t on_reboot_prepare() override {
    save_critical_data();
    flush_pending_operations();
    return 0;
}

void on_reboot_cancel() override {
    rollback_changes();
}

#include <mc/validate/validator.h>

void validate_request(std::string_view user, double age, std::string_view payload) {
    // 校验整数 + 范围：age 必须为 0-200 的整数
    mc::validate::validator::check_integer("Age", age, 0, 200, false);

    // 校验字符串长度：用户名 1-64 字符
    mc::validate::validator::lens("User", user, 1, 64, false);

    // 校验 JSON 格式
    mc::validate::validator::json(payload);

    // 校验正则：MAC 地址格式
    mc::validate::validator::regex("MAC", "AA:BB:CC:DD:EE:FF",
        "^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$", false);
}

// 异常处理
try {
    mc::validate::validator::check_integer("Prop1", 3.14, 0, 100, false);
} catch (const mc::validate::validation_exception& e) {
    // e.what() 的文案与 Lua lvalidate 报错保持一致
    elog("校验失败: ${error}", ("error", e.what()));
}

// 代理对象通过代理接口实现，示例如下
namespace mc::app::discovery {

class object_group_proxy : public mc::engine::interface_proxy<object_group_proxy> {
public:
MC_INTERFACE_PROXY("bmc.kepler.ObjectGroup");

MC_PROXY_METHOD(get_binary_objects_response, GetBinaryObjects, "a{ss}s",
                ((mc::dict, filters))((mc::string, owner)));

};

}

#include <mc/app/task/task_mgmt.h>

auto& mgmt = mc::app::task::TaskMgmt::instance();
mgmt.init(&service);  // 首次初始化

// 创建固件升级任务
auto [result, error, task_id] = mgmt.create_task(
    "FirmwareUpdate",                         // 任务名称
    "/bmc/kepler/UpdateService",              // 父路径（必须以'/'开头）
    60,                                        // 超时 60 分钟
    nullptr,                                   // 超时回调（可选）
    {{"EstimatedDuration", 10}, {"Description", "BMC固件升级"}}  // 初始属性
);

if (result == mc::app::task::CreateResult::Success) {
    // 启动任务
    mgmt.update_task(task_id, {{"State", "Running"}, {"Stage", "验证镜像"}});

    // 更新进度
    for (int i = 0; i <= 100; i += 10) {
        mgmt.update_task(task_id, {{"Progress", i}});
        // 执行实际升级工作...
    }

    // 完成
    mgmt.update_task(task_id, {{"State", "Completed"}});  // Progress 自动设为 100
}

// D-Bus 路径: /bmc/kepler/UpdateService/TaskService/Tasks/{task_id}

class sensor_iface : public mc::engine::interface<sensor_iface> {
public:
    MC_INTERFACE("bmc.example.Sensor")  // D-Bus 接口名称和版本
    double Value{0.0};
    mc::string Unit;
};
MC_REFLECT(sensor_iface, ((Value, "Value"))((Unit, "Unit")))

class sensor : public mc::app::object<sensor> {
public:
    MC_OBJECT(sensor, "Sensor",
              "/bmc/example/Sensors/${object_name}",
              (sensor_iface))

    sensor_iface iface;

    void on_init(const mc::dict& props) override {
        mc::engine::object_impl::on_init(props);  // 通过反射回填属性
    }
};
MC_REFLECT(sensor, ((iface, "iface")))

#include <mc/engine/object.h>
#include <mc/engine/service.h>

// 1. 定义接口
class my_iface : public mc::engine::interface<my_iface> {
public:
    MC_INTERFACE("bmc.example.MyInterface")
    mc::string Name;
    int Value{0};
};
MC_REFLECT(my_iface, ((Name, "Name"))((Value, "Value")))

// 2. 定义业务对象
class my_object : public mc::app::object<my_object> {
public:
    MC_OBJECT(my_object, "MyObject",
              "/bmc/example/MyObjects/${object_name}",
              (my_iface))

    explicit my_object(mc::engine::core_object* parent = nullptr)
        : mc::app::object<my_object>(parent) {}

    my_iface iface;

protected:
    void on_init(const mc::dict& props) override {
        // 信号抑制期：设置默认值、回填属性
        ensure_default("Name", mc::string("default"));
        ensure_default("Value", 0);
        mc::engine::object_impl::on_init(props);
    }

    void on_register() override {
        // 对象已上树，获取 D-Bus 路径
        ilog("对象已注册: ${path}", ("path", get_object_path()));
    }

    void on_ready() override {
        // 对象完全就绪，InterfacesAdded 已发出
        ilog("对象已就绪: ${path}", ("path", get_object_path()));
        // 可启动后台轮询、订阅事件等
    }

    void on_unregister() override {
        // 清理资源
        ilog("对象已移除: ${path}", ("path", get_object_path()));
    }
};
MC_REFLECT(my_object, ((iface, "iface")))

// 3. 注册对象
void register_objects(mc::engine::service& svc) {
    auto obj = mc::make_shared<my_object>(nullptr);
    obj->init(props);  // 触发 on_init → on_post_init
    obj->set_object_path("/bmc/example/MyObjects/obj_1");
    svc.register_object(*obj);  // 触发 on_register → on_ready
}

class my_service : public mc::service_base<my_service> {
public:
    static const char* service_type() { return "example.my_service"; }

    static void register_options(mc::po::options_description& cfg_opts) {
        cfg_opts.add_options()
            ("my_service.timeout", mc::po::value<int>()->default_value(30), "超时时间")
            ("my_service.retry_count", mc::po::value<int>()->default_value(3), "重试次数");
    }

    static const std::vector<std::string>& dependencies() {
        static std::vector<std::string> deps = {"logger", "database"};
        return deps;
    }

    bool init(mc::dict args) override {
        m_timeout = args.get("my_service.timeout").as<int>();
        return true;
    }

    bool start() override {
        set_state(mc::service_state::running);
        return true;
    }

    bool stop() override {
        set_state(mc::service_state::stopped);
        return true;
    }

    bool is_healthy() const override { return true; }

private:
    int m_timeout;
};

class example_plugin : public mc::plugin {
public:
    const mc::plugin_info& get_info() const override {
        static mc::plugin_info info = {
            .name = "example",
            .version = "1.0.0",
            .dependencies = {"core", "logger"}
        };
        return info;
    }

    bool init(mc::service_factory& factory) override {
        factory.register_service<my_service>();
        return true;
    }
};

MC_EXPORT_PLUGIN(example_plugin)

class network_adapter_iface : public mc::engine::interface<network_adapter_iface> {
public:
    MC_INTERFACE("bmc.kepler.Systems.NetworkAdapter")
    std::uint8_t SlotNumber{0};
    mc::string Name;
};
MC_REFLECT(network_adapter_iface, ((SlotNumber, "SlotNumber"))((Name, "Name")))

class network_adapter : public mc::app::object<network_adapter> {
public:
    MC_OBJECT(network_adapter, "NetworkAdapter",
              "/bmc/kepler/Systems/${SystemId}/NetworkAdapters/${object_name}",
              (network_adapter_iface))

    network_adapter_iface iface;

    void on_init(const mc::dict& props) override {
        mc::engine::object_impl::on_init(props);
    }

    void on_ready() override {
        // 对象就绪，可启动后台任务
    }

    void on_unregister() override {
        // 清理资源
    }
};
MC_REFLECT(network_adapter, ((iface, "iface")))

class my_discovery_service : public mc::app::discovery_service {
public:
    explicit my_discovery_service(mc::string name)
        : mc::app::discovery_service(std::move(name)) {}

protected:
    void register_object_types() override {
        (void)network_adapter::metadata();
    }

    mc::app::discovery::service_object_group_source::config
    make_service_source_config() const override {
        auto cfg = mc::app::discovery_service::make_service_source_config();
        cfg.get_binary_objects_owner = "network_adapter";
        return cfg;
    }
};

class my_exception : public mc::exception {
public:
    enum code_enum { code_value = MY_EXCEPTION_CODE };

    my_exception(mc::log_message&& msg = mc::log_message(
        mc::log::level::error, "我的异常"))
        : exception(std::move(msg), code_value, "my_exception", "我的异常描述") {}

    my_exception(const my_exception& e) : exception(e) {}
    my_exception(my_exception&& e) : exception(std::move(e)) {}
    explicit my_exception(const mc::exception& e) : exception(e) {}

    std::shared_ptr<mc::exception> dynamic_copy_exception() const override {
        return std::make_shared<my_exception>(*this);
    }

    void dynamic_rethrow_exception() const override { throw *this; }
};

// 注册异常类型
mc::exception_factory::instance().register_exception<my_exception>();

void on_init(const mc::dict& props) override {
    // required: 依赖未满足时不 register
    wait_for("#/External.RequiredService", mc::app::wait_kind::required);

    // optional: 不阻塞 register
    wait_for("#/External.OptionalService", mc::app::wait_kind::optional);

    mc::engine::object_impl::on_init(props);
}