use futures_util::stream::TryStreamExt;
use std::collections::HashMap;
use zbus::{message::Body, Connection, Result};
use zvariant::OwnedValue;

struct Notification {
    app_name: String,
    replace_id: u32,
    icon: String,
    summary: String,
    body: String,
    actions: Vec<String>,
    hints: HashMap<String, OwnedValue>,
    expir_timeout: i32,
}

fn to_notif(msg_body: Body) -> Result<Notification> {
    let (app_name, replace_id, icon, summary, body, actions, hints, expir_timeout) =
        msg_body.deserialize()?;
    Ok(Notification {
        app_name,
        replace_id,
        icon,
        summary,
        body,
        actions,
        hints,
        expir_timeout,
    })
}

fn print_notif(notif: Notification) {
    println!("App Name: {0}", notif.app_name);
    println!("Replace ID: {0}", notif.replace_id);
    println!("Icon: {0}", notif.icon);
    println!("Summary: {0}", notif.summary);
    println!("Body: {0}", notif.body);
    println!("Actions: {0:?}", notif.actions);
    println!("Hints:");
    for (key, value) in notif.hints {
        println!("  {key}: {value:?}");
    }
    println!("Expiration Timeout: {0} seconds\n", notif.expir_timeout);
}

#[tokio::main]
async fn main() -> Result<()> {
    let connection = Connection::session().await?;
    connection
        .request_name("org.freedesktop.Notifications") // Requesting dbus for this service name. Any other services using this name should be stopped/disabled before this
        .await?;

    let mut stream = zbus::MessageStream::from(&connection); // Convert connection to a MessageStream, yields Message items

    while let Some(msg) = stream.try_next().await? {
        // Check if the message is a method call to the "Notify" method
        if let Some(member) = msg.header().member().map(|m| m.as_str()) {
            match member {
                "GetServerInformation" => {
                    // Respond with server information
                    let response = ("SNot", "candifloss.cc", "0.1.0", "0.1.0"); // (name, vendor, version, spec_version)
                    connection.reply(&msg, &response).await?;
                    println!("Request received: {member}\n\tName: SNot\n\tVendor: candifloss.cc\n\tVersion: 0.1.0\n\tSpec_version: 0.1.0");
                }
                "Notify" => {
                    // Handle new received notif
                    println!("New notification:");
                    let msg_body = msg.body();
                    // get the app_name, summary, body, etc. from the msg_body
                    let notif = to_notif(msg_body);
                    // Print the notif
                    let _ = print_notif(notif.expect("Failed to parse notification"));
                    // Done. Respond to the client with a notification ID
                    let notification_id: u32 = 1; // This could be incremented or generated. Do it l8r
                    connection.reply(&msg, &notification_id).await?; // The client will stop when it gets the response
                }
                _ => {
                    println!("Unhandled method: {member}");
                }
            };
        }
    }

    Ok(())
}