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

use serde::Deserialize;

// use std::net::*;
use trust_dns_resolver::config::{ResolverConfig, ResolverOpts};
use trust_dns_resolver::Resolver;

// #[derive(Debug)]
pub struct DNS {
    config: DNSConfig,
    resolver: Resolver,
}
#[derive(Debug, Deserialize)]
struct DNSConfig {
    #[serde(default)]
    records: Vec<DNSConfigRecord>,
    #[serde(default)]
    period: Option<f64>,
}
#[derive(Debug, Deserialize)]
struct DNSConfigRecord {
    domain_name: String,
    #[serde(default)]
    resolver: Option<String>,
    #[serde(default)]
    entries: Vec<DNSConfigEntry>,
}
#[derive(Debug, Deserialize)]
struct DNSConfigEntry {
    record_type: String,
    #[serde(default)]
    record_value: Option<String>,
    #[serde(default)]
    resolver: Option<String>,
}

impl Monitor for DNS {
    fn new(config: serde_yaml::Value) -> Result<Self, Box<dyn std::error::Error>> {
        let config: DNSConfig = serde_yaml::from_value(config)?;

        let mut resolver =
            Resolver::new(ResolverConfig::default(), ResolverOpts::default()).unwrap();

        Ok(DNS {
            config: config,
            resolver: resolver,
        })
    }
    fn run(&mut self, sender: &mpsc::Sender<Message>) {
        for record in &self.config.records {
            //let mut response = match &record.record_type {
            //    "ipv4" => self.resolver.ipv4_lookup(&record.domain_name),
            //    // "ipv6" => self.resolver.ipv6_lookup(&record.domain_name),
            //    _ => self.resolver.ipv4_lookup(&record.domain_name),
            //};

            // let mut response = self.resolver.lookup_ip(&record.domain_name);
            // if let Err(e) = response {
            //     sender
            //         .send(Message {
            //             emitter: "dns".to_owned(),
            //             msg_type: "dns.resolve".to_owned(),
            //             level: Level::Issue,
            //             text: format!("Cannot resolve hostname {}", &record.domain_name),
            //         })
            //         .unwrap();
            //     continue;
            // }
            // let Ok(response) = response;
            // while let Some(res) = response.next() {
            //     println!("res={:?}", res);
            // }
        }

        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));
    }
}