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

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

pub(crate) fn spawn_cors_tasks(
    config: &Config,
    pool: &sqlx::SqlitePool,
    cancel: &tokio_util::sync::CancellationToken,
    alerter: &Option<Alerter>,
) -> Vec<JoinHandle<()>> {
    let interval_secs = config.serve.cors_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.cors.is_empty() {
            continue;
        }
        let cors_checks = target_config.cors.clone();
        let label = target_config.label.clone();
        let pool = pool.clone();
        let alerter = alerter.clone();
        let cancel = cancel.clone();
        let n = cors_checks.len();

        info!("{name}: CORS check every {interval_secs}s ({n} endpoints)");

        handles.push(tokio::spawn(async move {
            let mut interval = tokio::time::interval(
                std::time::Duration::from_secs(interval_secs),
            );
            interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
            let mut prev_failed: std::collections::HashSet<String> = std::collections::HashSet::new();

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

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

                let current_failed: std::collections::HashSet<String> = results
                    .iter()
                    .filter(|r| !r.passes)
                    .map(|r| r.url.clone())
                    .collect();

                let ok_count = results.iter().filter(|r| r.passes).count();
                info!("{name}: CORS {ok_count}/{n} pass");

                if let Some(ref alerter) = alerter {
                    // New failures
                    let new_failures: Vec<&pom::types::CorsCheckResult> = results
                        .iter()
                        .filter(|r| !r.passes && !prev_failed.contains(&r.url))
                        .collect();
                    if !new_failures.is_empty() {
                        let owned: Vec<pom::types::CorsCheckResult> = new_failures.into_iter().cloned().collect();
                        alerter.send_cors_failure_alert(&name, &label, &owned).await;
                    }

                    // All recovered
                    if !prev_failed.is_empty() && current_failed.is_empty() {
                        alerter.send_cors_recovery_alert(&name, &label).await;
                    }
                }

                prev_failed = current_failed;
            }
        }));
    }

    handles
}