/********************************************************************************
 *   Prometheus exporter for monitoring network connectivity using icmp pings   *
 *                                                                              *
 *   Copyright (C) 2019-2020 Jan Christian Grünhage                             *
 *   Copyright (C) 2020 Famedly GmbH                                            *
 *   Copyright (C) 2021-2022 Faelix Limited                                     *
 *                                                                              *
 *   This program is free software: you can redistribute it and/or modify       *
 *   it under the terms of the GNU Affero General Public License as             *
 *   published by the Free Software Foundation, either version 3 of the         *
 *   License, or (at your option) any later version.                            *
 *                                                                              *
 *   This program is distributed in the hope that it will be useful,            *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of             *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the               *
 *   GNU Affero General Public License for more details.                        *
 *                                                                              *
 *   You should have received a copy of the GNU Affero General Public License   *
 *   along with this program.  If not, see <https://www.gnu.org/licenses/>.     *
 ********************************************************************************/
use crate::config::Config;
use anyhow::{Context, Result};
use async_anyhow_logger::catch;
use lazy_static::lazy_static;
use log::{trace};
use prometheus::*;
use std::net::IpAddr;
use std::time::Duration;
use tokio_icmp_echo::{PingFuture, Pinger};
use std::collections::HashMap;

lazy_static! {
    static ref PING_HISTOGRAM: HistogramVec = register_histogram_vec!(
        "ping_rtt_milliseconds",
        "The ping round trip time in milliseconds",
        &["target", "device", "interface", "expected", "team", "priority"],
        vec![
            0.125, 0.25, 0.5, 1.0, 1.5, 2.0, 2.5, 5.0, 7.5, 10.0, 15.0, 20.0, 25.0, 30.0,
            35.0, 40.0, 45.0, 50.0, 55.0, 60.0, 65.0, 70.0, 75.0, 80.0, 90.0, 100.0,
            125.0, 150.0, 175.0, 200.0, 250.0, 300.0, 400.0, 500.0, 750.0, 1000.0, 2000.0, 4000.0
        ]
    )
    .unwrap();
}

lazy_static! {
    static ref PING_COUNTER: IntCounterVec =
        register_int_counter_vec!("ping_replies", "Number of ICMP ping responses received", &["target"]).unwrap();
}

pub(crate) async fn start_pinging_hosts(config: &Config) -> Result<()> {
    let pinger = Pinger::new().await.context("Couldn't create pinger")?;
    let mut handles = vec![];
    let mut interval;

    for (target, hostdata) in config.hosts.clone() {
        let hd_interval = hostdata.get("interval");
        match hd_interval {
            Some(ival) => {
                interval = ival.parse()?;
            },
            _ => interval = 1000,
        }

        handles.push(tokio::spawn(ping_host(pinger.clone(), target, interval, hostdata)));
    }
    let (result, _, _) = futures::future::select_all(handles).await;
    result??;
    Ok(())
}

async fn ping_host(pinger: Pinger, host: IpAddr, interval: u64, hostdata: HashMap<String, String>) -> Result<()> {
    let mut pingchain = pinger.chain(host).timeout(Duration::from_secs(3));
    let mut interval = tokio::time::interval(Duration::from_millis(interval));
    let host_string = host.to_string();
    loop {
        interval.tick().await;
        tokio::spawn(catch(handle_ping_result(
            pingchain.send(),
            host_string.clone(),
            hostdata.clone(),
        )));
    }
}

async fn handle_ping_result(result: PingFuture, host: String, hostdata: HashMap<String, String>) -> Result<()> {
    let pong = result.await.context(format!("Couldn't ping {}", &host))?;

    let empty = "".to_string();
    let device = hostdata.get("device").unwrap_or(&empty);
    let interface = hostdata.get("interface").unwrap_or(&empty);
    let team = hostdata.get("team").unwrap_or(&empty);

    let up = "up".to_string();
    let expected = hostdata.get("expected").unwrap_or(&up);

    let notice = "notice".to_string();
    let severity = hostdata.get("severity").unwrap_or(&notice);

    match pong {
        Some(time) => {
            let ms = time.as_millis();
            trace!("Received pong from {} after {} ms", &host, &ms);
            PING_HISTOGRAM
                .with_label_values(&[&host, device, interface, expected, team, severity])
                .observe(ms as f64);
            //PING_COUNTER
            //    .with_label_values(&[&host])
            //    .collect();
        }
        None => {
            trace!("Received no response from {} within timeout", &host);
            PING_HISTOGRAM
                .with_label_values(&[&host, device, interface, expected, team, severity])
                .observe(4000.0);
        }
    };

    Ok(())
}