use crate::git_helpers::create_local_repo;
use crate::harness::{SiteBuilder, TestServer};
use crate::runtime::{skip_without_git, skip_without_runtime};
use std::time::Duration;
use witryna::config::Config;

#[tokio::test]
async fn old_builds_cleaned_up() {
    skip_without_git!();
    skip_without_runtime!();

    let tempdir = tempfile::tempdir().unwrap();
    let base_dir = tempdir.path().to_path_buf();

    let repo_dir = tempdir.path().join("repos");
    tokio::fs::create_dir_all(&repo_dir).await.unwrap();
    let repo_url = create_local_repo(&repo_dir, "main").await;

    let site = SiteBuilder::new("cleanup-site", &repo_url, "test-token")
        .overrides(
            "alpine:latest",
            "mkdir -p out && echo '<h1>test</h1>' > out/index.html",
            "out",
        )
        .build();

    // Keep only 2 builds
    let config = Config {
        listen_address: "127.0.0.1:0".to_owned(),
        container_runtime: crate::harness::test_config(base_dir.clone()).container_runtime,
        base_dir: base_dir.clone(),
        log_dir: base_dir.join("logs"),
        log_level: "debug".to_owned(),
        max_builds_to_keep: 2,
        git_timeout: None,
        sites: vec![site],
    };

    let server = TestServer::start(config).await;
    let builds_dir = base_dir.join("builds/cleanup-site");

    // Run 3 builds sequentially
    for i in 0..3 {
        let resp = TestServer::client()
            .post(server.url("/cleanup-site"))
            .header("Authorization", "Bearer test-token")
            .send()
            .await
            .unwrap();
        assert_eq!(resp.status().as_u16(), 202, "build {i} should be accepted");

        // Wait for build to complete
        let max_wait = Duration::from_secs(120);
        let start = std::time::Instant::now();

        loop {
            assert!(start.elapsed() <= max_wait, "build {i} timed out");

            // Check that the site is no longer building
            if !server
                .state
                .build_scheduler
                .in_progress
                .lock()
                .unwrap()
                .contains("cleanup-site")
            {
                break;
            }
            tokio::time::sleep(Duration::from_millis(200)).await;
        }

        // Small delay between builds to ensure different timestamps
        tokio::time::sleep(Duration::from_millis(100)).await;
    }

    // Count timestamped build directories (excluding "current" symlink)
    let mut count = 0;
    if builds_dir.is_dir() {
        let mut entries = tokio::fs::read_dir(&builds_dir).await.unwrap();
        while let Some(entry) = entries.next_entry().await.unwrap() {
            let name = entry.file_name();
            if name != "current" && name != "current.tmp" {
                count += 1;
            }
        }
    }

    assert!(
        count <= 2,
        "should have at most 2 builds after cleanup, got {count}"
    );
}