use crate::formats::serde::serialize_actions;
use serde::Serialize;
use std::collections::HashMap;
use zbus::{message::Body, Result};
use zvariant::OwnedValue;

// A notificaion object
#[derive(Serialize)] // To help with json, rson
pub struct Notification {
    // The application that sent the notification
    app_name: String,
    // (Optional) ID of an existing notification to be updated, replaced by this
    replace_id: u32,
    // See icon specifications: https://specifications.freedesktop.org/notification-spec/latest/icons-and-images.html
    icon: String,
    // Notification title
    summary: String,
    // Notification content/body
    body: String,
    // Action requests that can be sent back to the client - "Reply," "Mark as Read," "Play/Pause/Next," "Snooze/Dismiss," etc.
    #[serde(serialize_with = "serialize_actions")]
    actions: Vec<String>,
    // Useful extra data - notif type, urgency, notif sound, icon data, etc.
    //#[serde(serialize_with = "serialize_hints")]
    hints: HashMap<String, OwnedValue>,
    // Seconds till this notif expires. Optional
    expir_timeout: i32,
}

impl Notification {
    // App name
    pub fn app_name(&self) -> String {
        self.app_name.clone()
    }
    // Replace ID
    pub fn replace_id(&self) -> u32 {
        self.replace_id
    }
    // Icon
    pub fn icon(&self) -> String {
        self.icon.clone()
    }
    // Summary
    pub fn summary(&self) -> String {
        self.summary.clone()
    }
    // Body
    pub fn body(&self) -> String {
        self.body.clone()
    }

    // Key:Val pairs of actions
    pub fn actions(&self) -> Vec<(String, String)> {
        let mut actions: Vec<(String, String)> = vec![];
        let acts = &self.actions;
        let act_len = acts.len();
        let mut i = 0;
        while i < act_len {
            // Action ID, used by the sender to id the clicked action
            let action_id = &acts[i];
            // Localised human-readable string that describes the action
            let action_label = &acts[i + 1];
            // Pair of (id, label)
            let action_pair = (action_id.to_owned(), action_label.to_owned());
            // Add it to the Vec
            actions.push(action_pair);
            i += 2;
        }
        actions
    }
    /*
    pub fn actions(&self) -> Vec<(String, String)> {
    self.actions
        .chunks(2)
        .map(|chunk| (chunk[0].clone(), chunk[1].clone()))
        .collect()
    } */

    // Hints
    pub fn hints(&self) -> &HashMap<String, OwnedValue> {
        &self.hints
    }

    // Expiry timeout
    pub fn expir_timeout(&self) -> i32 {
        self.expir_timeout
    }

    // Default action
    pub fn default_action(&self) -> Option<(String, String)> {
        if self.actions().is_empty() {
            None
        } else {
            Some(self.actions()[0].clone())
        }
    }

    // Urgency
    pub fn urgency(&self) -> String {
        match self.hints.get("urgency") {
            Some(value) => {
                // Attempt to convert OwnedValue to u8
                match u8::try_from(value) {
                    Ok(0) => "Low".to_string(),
                    Ok(1) => "Normal".to_string(),
                    Ok(2) => "Critical".to_string(),
                    _ => "Other".to_string(), // There are no accepted values other that these 3
                }
            }
            None => "Unknown".to_string(), // This possibly never occurs, or something might be wrong
        }
    }
}

// Convert the DBus message body into Notification
pub fn to_notif(msg_body: &Body) -> Result<Notification> {
    // Deserialize body into a tuple
    let (app_name, replace_id, icon, summary, body, actions, hints, expir_timeout) =
        msg_body.deserialize()?;
    // Form a Notification object from the obtained tuple's fields
    Ok(Notification {
        app_name,
        replace_id,
        icon,
        summary,
        body,
        actions,
        hints,
        expir_timeout,
    })
}