#[macro_use]
extern crate serde_derive; // 1.0.68
extern crate serde_json; // 1.0.22;
extern crate serde; // 1.0.68

use std::time::Duration;
use serde::*;

#[derive(Clone, Copy, Debug)]
pub struct Seconds(Duration);

impl Seconds {
    pub fn new(secs: u64) -> Self {
        Seconds(Duration::from_secs(secs))
    }

    pub fn value(&self) -> u64 {
        self.0.as_secs()
    }
}


impl Serialize for Seconds {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_u64(self.value())
    }
}

impl<'de> Deserialize<'de> for Seconds {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
	    let secs = u64::deserialize(deserializer)?;
	    Ok(Seconds::new(secs))
	}
}



#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "lowercase", tag = "mode")]
pub enum Mode {
	Active,
	Passive {
	    #[serde(rename = "mode.timeout")]
		timeout: Seconds,
		#[serde(rename = "mode.alarm")]
		alarm: Seconds,
	},
	Dark {
	    #[serde(rename = "mode.timeout")]
		timeout: Seconds,
	},
	Offline,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct UserDefaults {
 	pub tracing: bool,
    #[serde(flatten)]
    mode: Mode,
}

fn main() {
    let defaults = UserDefaults {
        tracing: true,
        mode: Mode::Dark { timeout: Seconds::new(10) },
    };
    let serialized = serde_json::to_string(&defaults).unwrap();
    println!("Serialized: {}", serialized);
    let deserialized: UserDefaults = serde_json::from_str(&serialized).unwrap();
    println!("Deserialized: {:#?}", deserialized);
}