# 列出所有总线上的服务
busctl list

# 列出会话总线上的服务
busctl --user list

# 查看某个服务的对象树
busctl tree org.freedesktop.login1

# 查看接口详情
busctl introspect org.freedesktop.login1 /org/freedesktop/login1

# 调用方法
busctl call org.freedesktop.login1 /org/freedesktop/login1 \
    org.freedesktop.login1.Manager GetSession s ""

# 监听信号
busctl monitor org.freedesktop.login1

# 安装 D-Feet
sudo apt install d-feet

# 启动
d-feet

void main () {
    try {
        // 连接到会话总线
        var connection = GLib.Bus.get_sync (GLib.BusType.SESSION, null);

        // 创建代理
        var proxy = new GLib.DBusProxy.sync (
            connection,
            GLib.DBusProxyFlags.NONE,
            null,                                    // InterfaceInfo
            "org.freedesktop.DBus",                  // Bus name
            "/org/freedesktop/DBus",                 // Object path
            "org.freedesktop.DBus",                  // Interface
            null                                     // Cancellable
        );

        // 调用方法
        var result = proxy.call_sync (
            "ListNames",                             // Method name
            null,                                    // Parameters
            GLib.DBusCallFlags.NONE,
            -1,                                      // Timeout
            null                                     // Cancellable
        );

        // 解析结果
        if (result != null) {
            var names = result.get_child_value (0);
            uint length = names.n_children ();
            print ("总线上有 %u 个服务:\n", length);
            for (uint i = 0; i < length && i < 20; i++) {
                string? name = names.get_child_value (i).get_string ();
                print ("  %s\n", name);
            }
        }

    } catch (GLib.Error e) {
        printerr ("D-Bus 错误: %s\n", e.message);
    }
}

void main () {
    // 获取总线连接
    var connection = GLib.Bus.get_sync (GLib.BusType.SESSION, null);

    // 检查服务是否存在
    try {
        var result = connection.call_sync (
            "org.freedesktop.DBus",
            "/org/freedesktop/DBus",
            "org.freedesktop.DBus",
            "NameHasOwner",
            new GLib.Variant ("(s)", "org.freedesktop.portal.Desktop"),
            new GLib.VariantType ("(b)"),
            GLib.DBusCallFlags.NONE,
            -1,
            null
        );

        bool has_owner = result.get_child_value (0).get_boolean ();
        print ("portal 服务存在: %s\n", has_owner.to_string ());

    } catch (GLib.Error e) {
        printerr ("错误: %s\n", e.message);
    }
}

// 定义 D-Bus 接口
[DBus (name = "com.example.Calculator")]
public class CalculatorService : Object {
    private int last_result = 0;

    // D-Bus 方法
    public int add (int a, int b) {
        last_result = a + b;
        print ("计算: %d + %d = %d\n", a, b, last_result);
        return last_result;
    }

    public int subtract (int a, int b) {
        last_result = a - b;
        return last_result;
    }

    public int multiply (int a, int b) {
        last_result = a * b;
        return last_result;
    }

    public double divide (int a, int b) throws GLib.Error {
        if (b == 0) {
            throw new GLib.IOError.FAILED ("除数不能为零");
        }
        last_result = a / b;
        return (double) a / b;
    }

    // D-Bus 属性
    public int last_result {
        get { return last_result; }
    }

    // D-Bus 信号
    public signal void calculation_done (int result);
}

void main () {
    var loop = new GLib.MainLoop ();

    // 注册 D-Bus 服务
    GLib.Bus.own_name (
        GLib.BusType.SESSION,
        "com.example.Calculator",
        GLib.BusNameOwnerFlags.NONE,
        (connection, name) => {
            // 总线名已获取
            try {
                connection.register_object (
                    "/com/example/Calculator",
                    new CalculatorService ()
                );
                print ("D-Bus 服务已注册: %s\n", name);
            } catch (GLib.Error e) {
                printerr ("注册失败: %s\n", e.message);
            }
        },
        () => {
            // 总线名获取成功
            print ("总线名已获取\n");
        },
        (connection, name) => {
            // 总线名丢失
            printerr ("总线名丢失: %s\n", name);
            loop.quit ();
        }
    );

    print ("计算器服务运行中...\n");
    print ("测试: busctl --user call com.example.Calculator /com/example/Calculator com.example.Calculator add ii 3 5\n");

    loop.run ();
}

[DBus (name = "com.example.FileService")]
public class FileService : Object {
    // 异步 D-Bus 方法
    public async string read_file (string path) throws GLib.Error {
        string content;
        size_t length;
        GLib.FileUtils.get_contents (path, out content, out length);
        return content;
    }

    public async void write_file (string path, string content)
        throws GLib.Error
    {
        GLib.FileUtils.set_contents (path, content);
    }

    // 同步方法
    public bool file_exists (string path) {
        return GLib.FileUtils.test (path, GLib.FileTest.EXISTS);
    }

    public signal void file_changed (string path, string event_type);
}

void main () {
    var loop = new GLib.MainLoop ();

    GLib.Bus.own_name (
        GLib.BusType.SESSION,
        "com.example.FileService",
        GLib.BusNameOwnerFlags.NONE,
        (connection, name) => {
            try {
                var service = new FileService ();
                connection.register_object (
                    "/com/example/FileService",
                    service
                );

                // 模拟文件变化信号
                GLib.Timeout.add (5000, () => {
                    service.file_changed ("/tmp/test.txt", "modified");
                    return GLib.Source.CONTINUE;
                });

                print ("文件服务已注册\n");
            } catch (GLib.Error e) {
                printerr ("注册失败: %s\n", e.message);
            }
        },
        () => {},
        (connection, name) => { loop.quit (); }
    );

    loop.run ();
}

void main () {
    try {
        // 创建代理
        var proxy = new GLib.DBusProxy.for_bus_sync (
            GLib.BusType.SESSION,
            GLib.DBusProxyFlags.NONE,
            null,
            "com.example.Calculator",
            "/com/example/Calculator",
            "com.example.Calculator",
            null
        );

        // 调用方法
        var result = proxy.call_sync (
            "Add",
            new GLib.Variant ("(ii)", 10, 20),
            GLib.DBusCallFlags.NONE,
            -1,
            null
        );

        int sum = result.get_child_value (0).get_int32 ();
        print ("10 + 20 = %d\n", sum);

        // 读取属性
        var props = new GLib.DBusProxy.for_bus_sync (
            GLib.BusType.SESSION,
            GLib.DBusProxyFlags.NONE,
            null,
            "com.example.Calculator",
            "/com/example/Calculator",
            "org.freedesktop.DBus.Properties",
            null
        );

        var prop_result = props.call_sync (
            "Get",
            new GLib.Variant ("(ss)",
                "com.example.Calculator",
                "LastResult"
            ),
            GLib.DBusCallFlags.NONE,
            -1,
            null
        );

        int last = (int) prop_result.get_child_value (0)
                         .get_variant ()
                         .get_int32 ();
        print ("上次结果: %d\n", last);

    } catch (GLib.Error e) {
        printerr ("调用失败: %s\n", e.message);
    }
}

void main () {
    var loop = new GLib.MainLoop ();

    try {
        var connection = GLib.Bus.get_sync (GLib.BusType.SESSION, null);

        // 订阅信号
        uint subscription_id = connection.signal_subscribe (
            "com.example.Calculator",        // sender
            "com.example.Calculator",        // interface
            "CalculationDone",               // signal name
            "/com/example/Calculator",       // object path
            null,                            // arg0
            GLib.DBusSignalFlags.NONE,
            (conn, sender, object_path, interface_name,
             signal_name, parameters) => {
                int result = parameters.get_child_value (0).get_int32 ();
                print ("收到信号: 计算完成，结果=%d\n", result);
            }
        );

        print ("正在监听 D-Bus 信号...\n");
        print ("按 Ctrl+C 退出\n");

        loop.run ();

    } catch (GLib.Error e) {
        printerr ("错误: %s\n", e.message);
    }
}

void main () {
    // 调用系统通知服务
    try {
        var proxy = new GLib.DBusProxy.for_bus_sync (
            GLib.BusType.SESSION,
            GLib.DBusProxyFlags.NONE,
            null,
            "org.freedesktop.Notifications",
            "/org/freedesktop/Notifications",
            "org.freedesktop.Notifications",
            null
        );

        // 发送通知
        var result = proxy.call_sync (
            "Notify",
            new GLib.Variant ("(susssasa{sv}i)",
                "ValaApp",           // app_name
                0,                   // replaces_id
                "dialog-information", // icon
                "Vala 通知",          // summary
                "这是一条来自 Vala 的通知！", // body
                new GLib.Variant ("as", new string[0]),  // actions
                new GLib.Variant ("a{sv}", new GLib.Variant[0]),  // hints
                5000                 // timeout (ms)
            ),
            GLib.DBusCallFlags.NONE,
            -1,
            null
        );

        uint32 notification_id = result.get_child_value (0).get_uint32 ();
        print ("通知已发送，ID: %u\n", notification_id);

    } catch (GLib.Error e) {
        printerr ("通知发送失败: %s\n", e.message);
    }
}

void main () {
    // 查询系统登录信息
    try {
        var proxy = new GLib.DBusProxy.for_bus_sync (
            GLib.BusType.SYSTEM,
            GLib.DBusProxyFlags.NONE,
            null,
            "org.freedesktop.login1",
            "/org/freedesktop/login1",
            "org.freedesktop.login1.Manager",
            null
        );

        // 获取当前会话
        var result = proxy.call_sync (
            "GetSession",
            new GLib.Variant ("(s)", ""),
            GLib.DBusCallFlags.NONE,
            -1,
            null
        );

        if (result != null) {
            string session_path = result.get_child_value (0)
                                        .get_obj_path ();
            print ("当前会话路径: %s\n", session_path);
        }

    } catch (GLib.Error e) {
        printerr ("查询失败: %s\n", e.message);
    }
}

// 定义接口 XML（可选，Vala 也可以自动推断）
/*
<node>
  <interface name="com.example.ConfigService">
    <method name="GetConfig">
      <arg name="key" direction="in" type="s"/>
      <arg name="value" direction="out" type="s"/>
    </method>
    <method name="SetConfig">
      <arg name="key" direction="in" type="s"/>
      <arg name="value" direction="in" type="s"/>
    </method>
    <property name="Version" type="s" access="read"/>
    <signal name="ConfigChanged">
      <arg name="key" type="s"/>
      <arg name="value" type="s"/>
    </signal>
  </interface>
</node>
*/

[DBus (name = "com.example.ConfigService")]
public class ConfigService : Object {
    private GLib.HashTable<string, string> config;

    construct {
        config = new GLib.HashTable<string, string> (str_hash, str_equal);
        config["app.name"] = "MyApp";
        config["app.version"] = "1.0.0";
        config["app.debug"] = "true";
    }

    // D-Bus 方法
    public string get_config (string key) throws GLib.Error {
        if (!config.contains (key)) {
            throw new GLib.IOError.NOT_FOUND (
                "配置键不存在: %s".printf (key)
            );
        }
        return config[key];
    }

    public void set_config (string key, string value) {
        config[key] = value;
        config_changed (key, value);
        print ("配置更新: %s = %s\n", key, value);
    }

    // D-Bus 属性
    public string version {
        owned get { return "1.0.0"; }
    }

    // D-Bus 信号
    public signal void config_changed (string key, string value);
}

void main () {
    var loop = new GLib.MainLoop ();

    GLib.Bus.own_name (
        GLib.BusType.SESSION,
        "com.example.ConfigService",
        GLib.BusNameOwnerFlags.NONE,
        (connection, name) => {
            try {
                connection.register_object (
                    "/com/example/ConfigService",
                    new ConfigService ()
                );
                print ("配置服务已启动\n");
            } catch (GLib.Error e) {
                printerr ("注册失败: %s\n", e.message);
            }
        },
        () => {},
        (connection, name) => { loop.quit (); }
    );

    loop.run ();
}

[DBus (name = "com.example.SystemService")]
public class SystemService : Object {
    public void shutdown () throws GLib.Error {
        // 在实际应用中，这里应该检查 PolicyKit 权限
        print ("系统关机请求\n");

        // 使用 systemd 关机
        try {
            var proxy = new GLib.DBusProxy.for_bus_sync (
                GLib.BusType.SYSTEM,
                GLib.DBusProxyFlags.NONE,
                null,
                "org.freedesktop.login1",
                "/org/freedesktop/login1",
                "org.freedesktop.login1.Manager",
                null
            );

            proxy.call_sync (
                "PowerOff",
                new GLib.Variant ("(b)", false),
                GLib.DBusCallFlags.NONE,
                -1,
                null
            );
        } catch (GLib.Error e) {
            throw new GLib.IOError.FAILED (
                "关机失败: %s".printf (e.message)
            );
        }
    }

    public string status {
        owned get { return "running"; }
    }
}

void main () {
    var loop = new GLib.MainLoop ();

    GLib.Bus.own_name (
        GLib.BusType.SYSTEM,
        "com.example.SystemService",
        GLib.BusNameOwnerFlags.NONE,
        (connection, name) => {
            try {
                connection.register_object (
                    "/com/example/SystemService",
                    new SystemService ()
                );
                print ("系统服务已注册\n");
            } catch (GLib.Error e) {
                printerr ("注册失败: %s\n", e.message);
            }
        },
        () => {},
        (connection, name) => { loop.quit (); }
    );

    loop.run ();
}

[DBus (name = "org.freedesktop.Notifications")]
public class NotificationService : Object {
    private uint32 next_id = 1;
    private GLib.HashTable<uint32, NotificationInfo> notifications;

    construct {
        notifications = new GLib.HashTable<uint32, NotificationInfo> (
            direct_hash, direct_equal
        );
    }

    public uint32 notify (
        string app_name,
        uint32 replaces_id,
        string app_icon,
        string summary,
        string body,
        string[] actions,
        GLib.HashTable<string, GLib.Variant> hints,
        int32 expire_timeout
    ) throws GLib.Error {
        uint32 id = replaces_id > 0 ? replaces_id : next_id++;
        if (replaces_id == 0) next_id++;

        var info = new NotificationInfo ();
        info.app_name = app_name;
        info.summary = summary;
        info.body = body;
        info.timestamp = new GLib.DateTime.now_local ().to_string ();

        notifications[id] = info;

        print ("┌─────────────────────────────────┐\n");
        print ("│ 📢 %s\n", summary);
        print ("│ %s\n", body);
        print ("│ 来自: %s | ID: %u\n", app_name, id);
        print ("└─────────────────────────────────┘\n");

        notification_received (id, app_name, summary, body);

        // 自动过期
        if (expire_timeout > 0) {
            GLib.Timeout.add_once ((uint) expire_timeout, () => {
                close_notification (id);
            });
        }

        return id;
    }

    public void close_notification (uint32 id) throws GLib.Error {
        if (notifications.contains (id)) {
            notifications.remove (id);
            notification_closed (id, 1);  // 1 = dismissed
            print ("通知已关闭: %u\n", id);
        }
    }

    public string[] get_capabilities () {
        return {
            "body",
            "body-markup",
            "body-hyperlinks",
            "persistence"
        };
    }

    public void get_server_information (
        out string name,
        out string vendor,
        out string version,
        out string spec_version
    ) {
        name = "ValaNotificationService";
        vendor = "Example";
        version = "1.0.0";
        spec_version = "1.2";
    }

    public signal void notification_received (
        uint32 id, string app_name,
        string summary, string body
    );
    public signal void notification_closed (uint32 id, uint32 reason);
}

public class NotificationInfo : Object {
    public string app_name;
    public string summary;
    public string body;
    public string timestamp;
}

void main () {
    var loop = new GLib.MainLoop ();

    GLib.Bus.own_name (
        GLib.BusType.SESSION,
        "org.freedesktop.Notifications",
        GLib.BusNameOwnerFlags.REPLACE,
        (connection, name) => {
            try {
                var service = new NotificationService ();
                connection.register_object (
                    "/org/freedesktop/Notifications",
                    service
                );
                print ("通知服务已启动\n");
                print ("测试: busctl --user call org.freedesktop.Notifications /org/freedesktop/Notifications org.freedesktop.Notifications Notify susssasa{sv}i \"Test\" 0 \"\" \"测试标题\" \"测试内容\" 0 0 5000\n");
            } catch (GLib.Error e) {
                printerr ("注册失败: %s\n", e.message);
            }
        },
        () => {},
        (connection, name) => { loop.quit (); }
    );

    loop.run ();
}