use tokio::task::JoinHandle;
use tracing::info;

use pom::alerts::Alerter;
use pom::checks::dns;
use pom::config::Config;
use pom::db;

pub(crate) fn spawn_dns_tasks(
    config: &Config,
    pool: &sqlx::SqlitePool,
    cancel: &tokio_util::sync::CancellationToken,
    alerter: &Option<Alerter>,
) -> Vec<JoinHandle<()>> {
    let dns_interval_secs = config.serve.dns_check_interval_secs;
    let mut handles = Vec::new();

    for name in config.target_names() {
        let target_config = config.get_target(&name).unwrap().clone();
        if target_config.dns.is_empty() {
            continue;
        }
        let dns_records = target_config.dns.clone();
        let label = target_config.label.clone();
        let pool = pool.clone();
        let alerter = alerter.clone();
        let cancel = cancel.clone();
        let n = dns_records.len();

        info!("{name}: DNS check every {dns_interval_secs}s ({n} records)");

        handles.push(tokio::spawn(async move {
            // Prune stale DNS data from DB (records removed from config)
            let expected_dns_keys: Vec<(String, String)> = dns_records
                .iter()
                .map(|d| (d.name.clone(), d.record_type.to_string()))
                .collect();
            match db::prune_stale_dns(&pool, &name, &expected_dns_keys).await {
                Ok(0) => {}
                Ok(n) => info!("{name}: pruned {n} stale DNS check rows"),
                Err(e) => tracing::error!("{name}: failed to prune stale DNS: {e}"),
            }

            let mut interval = tokio::time::interval(
                std::time::Duration::from_secs(dns_interval_secs),
            );
            interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
            let mut prev_mismatched: std::collections::HashSet<(String, pom::types::DnsRecordType)> = std::collections::HashSet::new();

            interval.tick().await; // consume immediate first tick
            loop {
                tokio::select! {
                    _ = cancel.cancelled() => break,
                    _ = interval.tick() => {}
                }
                let results = dns::check_dns(&name, &dns_records).await;

                for result in &results {
                    if let Err(e) = db::insert_dns_check(&pool, result).await {
                        tracing::error!("{}: failed to store DNS check for {} {}: {e}", name, result.name, result.record_type);
                    }
                }

                let current_mismatched: std::collections::HashSet<(String, pom::types::DnsRecordType)> = results
                    .iter()
                    .filter(|r| !r.matches)
                    .map(|r| (r.name.clone(), r.record_type))
                    .collect();

                let ok_count = results.iter().filter(|r| r.matches).count();
                info!("{name}: DNS {ok_count}/{n} match");

                if let Some(ref alerter) = alerter {
                    // New mismatches
                    let new_mismatches: Vec<&pom::types::DnsCheckResult> = results
                        .iter()
                        .filter(|r| !r.matches && !prev_mismatched.contains(&(r.name.clone(), r.record_type)))
                        .collect();
                    if !new_mismatches.is_empty() {
                        let owned: Vec<pom::types::DnsCheckResult> = new_mismatches.into_iter().cloned().collect();
                        alerter.send_dns_mismatch_alert(&name, &label, &owned).await;
                    }

                    // All recovered
                    if !prev_mismatched.is_empty() && current_mismatched.is_empty() {
                        alerter.send_dns_recovery_alert(&name, &label).await;
                    }
                }

                prev_mismatched = current_mismatched;
            }
        }));
    }

    handles
}