use std::sync::Arc;
use tokio::sync::RwLock;

use crate::target::{ScrapeTarget, load_targets_from_file};

pub async fn watch_targets_file(
    path: String,
    targets: Arc<RwLock<Vec<ScrapeTarget>>>,
    mut shutdown: tokio::sync::broadcast::Receiver<()>,
) {
    let mtime_path = path;
    let mut last_mtime: Option<std::time::SystemTime> = None;

    loop {
        tokio::select! {
            _ = shutdown.recv() => break,
            _ = tokio::time::sleep(std::time::Duration::from_secs(10)) => {
                let metadata = match tokio::fs::metadata(&mtime_path).await {
                    Ok(m) => m,
                    Err(_) => continue,
                };

                let current_mtime = metadata.modified().ok();
                if current_mtime != last_mtime {
                    last_mtime = current_mtime;
                    match load_targets_from_file(&mtime_path).await {
                        Ok(new_targets) => {
                            let mut guard = targets.write().await;
                            *guard = new_targets;
                            tracing::info!(path = %mtime_path, "targets file reloaded");
                        }
                        Err(e) => {
                            tracing::warn!(error = %e, "failed to reload targets file");
                        }
                    }
                }
            }
        }
    }
}