//! Scan-pipeline health-check task. Polls the makenotwork health endpoint
//! on a per-target interval, applies thresholds (audit doc § 6), and fires
//! alerts on operational → degraded / unreachable transitions.

use tokio::task::JoinHandle;
use tracing::{info, warn};

use pom::alerts::Alerter;
use pom::checks::scan_pipeline;
use pom::config::Config;

pub(crate) fn spawn_scan_pipeline_tasks(
    config: &Config,
    cancel: &tokio_util::sync::CancellationToken,
    alerter: &Option<Alerter>,
) -> Vec<JoinHandle<()>> {
    let mut handles = Vec::new();

    for name in config.target_names() {
        let target_config = config.get_target(&name).unwrap().clone();
        let Some(sp_config) = target_config.scan_pipeline else { continue };

        let name = name.clone();
        let label = target_config.label.clone();
        let alerter = alerter.clone();
        let cancel = cancel.clone();

        info!(
            "{name}: scan-pipeline check every {}s against {}",
            sp_config.interval_secs, sp_config.base_url,
        );

        handles.push(tokio::spawn(async move {
            let mut interval = tokio::time::interval(
                std::time::Duration::from_secs(sp_config.interval_secs),
            );
            interval.tick().await; // consume immediate first tick

            // Track previous status so we only fire alerts on transitions.
            // None means we haven't observed yet.
            let mut previous_status: Option<String> = None;

            loop {
                tokio::select! {
                    _ = cancel.cancelled() => break,
                    _ = interval.tick() => {}
                }

                let result = scan_pipeline::check_scan_pipeline(
                    &name, &sp_config.base_url, sp_config.timeout_secs,
                ).await;

                if result.issues.is_empty() && result.error.is_none() {
                    info!("{name}: scan pipeline operational (queue p={}/r={}, held={})",
                        result.queue_pending, result.queue_running, result.held_total);
                } else {
                    warn!(
                        target = %name,
                        status = %result.status,
                        issues = ?result.issues,
                        "scan pipeline non-operational"
                    );
                }

                // Fire alerts on status transitions only.
                if let Some(ref alerter) = alerter {
                    let prev_ok = previous_status.as_deref().is_none_or(|s| s == "operational");
                    let now_ok = result.status == "operational";

                    if prev_ok && !now_ok {
                        alerter.send_scan_pipeline_alert(
                            &name, &label, &result.status, &result.issues,
                        ).await;
                    } else if !prev_ok && now_ok {
                        alerter.send_scan_pipeline_recovery(&name, &label).await;
                    }
                }

                previous_status = Some(result.status);
            }
        }));
    }

    handles
}