//! Tests for CDN URL detection and streaming URL filtering

use sunocore::models::generation::ClipStatus;

#[test]
fn test_cdn_url_detection_logic() {
    // Test the logic we use in PollGeneration and BatchPoll services

    // Case 1: Empty URL
    let url = "";
    let has_cdn = url.contains("cdn") && !url.is_empty();
    assert!(!has_cdn, "Empty URL should not be treated as CDN");

    // Case 2: Streaming URL (should be filtered out)
    let url = "https://audiopipe-dev.suno.ai/?item_id=abc123";
    let has_cdn = url.contains("cdn") && !url.is_empty();
    assert!(!has_cdn, "Streaming URL should not be treated as CDN");

    // Case 3: CDN URL (should be accepted)
    let url = "https://cdn1.suno.ai/abc123.mp3";
    let has_cdn = url.contains("cdn") && !url.is_empty();
    assert!(has_cdn, "CDN URL should be detected");

    // Case 4: Different CDN domains
    let url = "https://cdn2.suno.ai/abc123.mp3";
    let has_cdn = url.contains("cdn") && !url.is_empty();
    assert!(has_cdn, "cdn2 should also be detected");

    println!("✓ CDN URL detection logic verified");
}

#[test]
fn test_status_mapping_logic() {
    // Test the status mapping we use

    // Submitted state
    let status_str = "submitted";
    let audio_url = "";
    let has_cdn = audio_url.contains("cdn") && !audio_url.is_empty();

    let mapped = if has_cdn && status_str == "complete" {
        ClipStatus::Complete
    } else {
        match status_str {
            "complete" => ClipStatus::Complete,
            "error" => ClipStatus::Error,
            "submitted" => ClipStatus::Submitted,
            "streaming" => ClipStatus::Pending,
            "queued" => ClipStatus::Pending,
            _ => ClipStatus::Pending,
        }
    };

    assert_eq!(mapped, ClipStatus::Submitted);

    // Queued state
    let status_str = "queued";
    let mapped = match status_str {
        "queued" => ClipStatus::Pending,
        _ => ClipStatus::Complete,
    };
    assert_eq!(mapped, ClipStatus::Pending);

    // Streaming state with streaming URL (should be Pending)
    let status_str = "streaming";
    let audio_url = "https://audiopipe-dev.suno.ai/?item_id=abc";
    let has_cdn = audio_url.contains("cdn") && !audio_url.is_empty();

    let mapped = if has_cdn && status_str == "complete" {
        ClipStatus::Complete
    } else {
        match status_str {
            "streaming" => ClipStatus::Pending,
            _ => ClipStatus::Complete,
        }
    };

    assert_eq!(mapped, ClipStatus::Pending);

    // Complete state with CDN URL (should be Complete)
    let status_str = "complete";
    let audio_url = "https://cdn1.suno.ai/abc.mp3";
    let has_cdn = audio_url.contains("cdn") && !audio_url.is_empty();

    let mapped = if has_cdn && status_str == "complete" {
        ClipStatus::Complete
    } else {
        ClipStatus::Pending
    };

    assert_eq!(mapped, ClipStatus::Complete);

    println!("✓ Status mapping logic verified");
}

#[test]
fn test_audio_url_should_be_returned() {
    // Test: Only CDN URLs should be returned, not streaming URLs

    let test_cases = vec![
        ("", false, "Empty URL"),
        ("https://audiopipe-dev.suno.ai/?item_id=x", false, "Streaming URL"),
        ("https://cdn1.suno.ai/x.mp3", true, "CDN URL"),
        ("https://cdn2.suno.ai/x.mp3", true, "CDN2 URL"),
    ];

    for (url, should_return, description) in test_cases {
        let has_cdn = url.contains("cdn") && !url.is_empty();
        let should_return_url = has_cdn;

        assert_eq!(
            should_return_url, should_return,
            "Failed for: {} (url={})",
            description, url
        );

        println!("✓ {}: {}", description, if should_return { "return" } else { "filter out" });
    }
}