//! Test to verify streaming vs complete audio URL detection

use dotenvy::dotenv;
use reqwest::blocking::Client;
use reqwest::header::{HeaderMap, HeaderValue, AUTHORIZATION, CONTENT_TYPE};
use sunocore::models::generation::GenerateParams;
use sunocore::validation::env::{suno_api_key_unwrap, suno_base_url_unwrap};
use std::time::Duration;

#[test]
fn test_audio_url_progression() {
    let _ = dotenv();

    let base_url = suno_base_url_unwrap();
    let api_key = suno_api_key_unwrap().expect("SUNO_API_KEY required");

    let mut headers = HeaderMap::new();
    headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
    headers.insert(
        AUTHORIZATION,
        HeaderValue::from_str(&format!("Bearer {}", api_key)).unwrap(),
    );
    headers.insert("X-Api-Key", HeaderValue::from_str(&api_key).unwrap());

    let client = Client::builder()
        .default_headers(headers)
        .timeout(Duration::from_secs(60))
        .build()
        .unwrap();

    // Submit generation
    let params = GenerateParams::new("test audio url progression");
    let gen_url = format!("{}/api/generate/v2", base_url.trim_end_matches('/'));
    let resp = client.post(&gen_url).json(&params).send().unwrap();

    assert!(resp.status().is_success());

    let gen_response: sunocore::models::generation::GenerationResponse = resp.json().unwrap();
    let clip_id = &gen_response.clips[0].id;

    println!("Testing clip: {}", clip_id);

    // Poll and track audio URL changes
    let poll_url = format!("{}/api/feed/v2?ids={}", base_url.trim_end_matches('/'), clip_id);

    let mut seen_streaming = false;
    let mut seen_cdn = false;

    for attempt in 1..=20 {
        std::thread::sleep(Duration::from_secs(2));

        let resp = client.get(&poll_url).send().unwrap();
        if !resp.status().is_success() {
            continue;
        }

        let feed_resp: sunocore::models::feed::FeedResponse = resp.json().unwrap();
        if let Some(clip) = feed_resp.clips.first() {
            let audio_url = &clip.audio_url;

            println!("Attempt {}: status='{}', audio_url='{}'",
                attempt,
                clip.status,
                if audio_url.is_empty() { "(empty)" } else { &audio_url[..audio_url.len().min(80)] }
            );

            // Check for different URL patterns
            if audio_url.contains("audiopipe") || audio_url.contains("streaming") {
                seen_streaming = true;
                println!("  → STREAMING URL detected");
            }

            if audio_url.contains("cdn") && !audio_url.is_empty() {
                seen_cdn = true;
                println!("  → CDN URL detected");
            }

            // Stop when we have a CDN URL and status is complete
            if clip.status == "complete" && audio_url.contains("cdn") {
                println!("\n✓ Reached complete state with CDN URL");
                break;
            }
        }
    }

    if seen_streaming {
        println!("\n✓ Test confirmed: Streaming URLs exist during generation");
    }
    if seen_cdn {
        println!("✓ Test confirmed: CDN URLs appear when complete");
    }

    if !seen_streaming && !seen_cdn {
        println!("\n! Clips may have completed too fast to observe streaming state");
    }
}