pub use crate::message::{Level, Message};
pub use crate::monitor::*;

use serde::Deserialize;

#[derive(Debug)]
pub struct DummySender {
    cnt: i64,
    config: DummySenderConfig,
}
#[derive(Debug, Deserialize)]
struct DummySenderConfig {
    #[serde(default)]
    message: Option<String>,
    #[serde(default)]
    level: Option<Level>,
    #[serde(default)]
    msg_type: Option<String>,
    #[serde(default)]
    period: Option<f64>,
}

impl Monitor for DummySender {
    fn new(config: serde_yaml::Value) -> Result<Self, Box<dyn std::error::Error>> {
        let config: DummySenderConfig =
            serde_yaml::from_value(config).expect("Invalid config for dummy_sender");

        Ok(DummySender {
            cnt: 0,
            config: config,
        })
    }
    fn run(&mut self, sender: &mpsc::Sender<Message>) {
        log::info!(
            "Sending message {} from {:?}",
            self.cnt,
            std::thread::current().id()
        );
        sender
            .send(Message {
                emitter: "dummy_sender".to_owned(),
                level: match &self.config.level {
                    Some(l) => l.clone(),
                    None => Level::Notice,
                },
                msg_type: match &self.config.msg_type {
                    Some(s) => s.to_owned(),
                    None => "dummy_sender.message".to_owned(),
                },
                text: match &self.config.message {
                    Some(s) => s.to_owned(),
                    None => format!(
                        "This is message {} from {:?}",
                        self.cnt,
                        std::thread::current().id()
                    ),
                },
            })
            .unwrap();

        self.cnt += 1;

        let delay_ms = match self.config.period {
            Some(sec) => (sec * 1000.0) as u64,
            None => 2000,
        };
        std::thread::sleep(std::time::Duration::from_millis(delay_ms));
    }
}