//! Download recent songs from your feed
//!
//! This example demonstrates:
//! 1. Fetching your feed (using the feed service/middleware)
//! 2. Downloading audio files to disk
//!
//! Run with: cargo run --example download_from_feed

use std::fs;
use std::path::PathBuf;
use std::time::Duration;

use dotenvy::dotenv;
use reqwest::blocking::Client;
use reqwest::header::{HeaderMap, HeaderValue, AUTHORIZATION, CONTENT_TYPE};
use sunocore::models::feed::{FeedFilters, FeedRequest, PresenceFilter, WorkspaceFilter};
use sunocore::validation::env::{suno_api_key_unwrap, suno_base_url_unwrap, workspace_id_unwrap};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let _ = dotenv();

    let base_url = suno_base_url_unwrap();
    let api_key = suno_api_key_unwrap().ok_or("SUNO_API_KEY required")?;
    let workspace_id = workspace_id_unwrap();

    println!("=== Download Songs from Feed ===\n");

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

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

    // Fetch feed
    let feed_url = format!("{}/api/feed/v3", base_url.trim_end_matches('/'));
    let feed_request = FeedRequest {
        cursor: None,
        limit: 10,
        filters: FeedFilters {
            disliked: "False".to_string(),
            trashed: "False".to_string(),
            from_studio_project: PresenceFilter {
                presence: "any".to_string(),
            },
            stem: PresenceFilter {
                presence: "any".to_string(),
            },
            workspace: WorkspaceFilter {
                presence: "True".to_string(),
                workspace_id,
            },
        },
    };

    println!("Fetching feed from workspace {}...", workspace_id);
    let resp = client.post(&feed_url).json(&feed_request).send()?;

    if !resp.status().is_success() {
        println!("✗ Feed request failed: {}", resp.status());
        return Ok(());
    }

    let feed_response: sunocore::models::feed::FeedResponse = resp.json()?;
    println!("✓ Feed contains {} clips\n", feed_response.clips.len());

    // Create output directory
    let output_dir = PathBuf::from("/Users/neil/suno/oxide/target/generated_songs");
    fs::create_dir_all(&output_dir)?;

    let download_client = Client::builder()
        .timeout(Duration::from_secs(60))
        .build()?;

    let mut downloaded = 0;

    for (idx, clip) in feed_response.clips.iter().take(5).enumerate() {
        let title_display = if clip.title.is_empty() {
            format!("Untitled ({}...)", &clip.id.to_string()[..8])
        } else {
            clip.title[..clip.title.len().min(40)].to_string()
        };

        println!("{}. {}", idx + 1, title_display);
        println!("   ID: {}", clip.id);
        println!("   Status: {}", clip.status);

        if !clip.audio_url.is_empty() {
            let safe_title = if clip.title.is_empty() {
                format!("clip_{}", clip.id)
            } else {
                clip.title.replace(" ", "_").replace("/", "_")
            };

            let filename = format!("{:02}_{}.mp3", idx + 1, safe_title);
            let output_path = output_dir.join(filename);

            print!("   Downloading... ");
            match download_client.get(&clip.audio_url).send() {
                Ok(resp) if resp.status().is_success() => {
                    let bytes = resp.bytes()?;
                    fs::write(&output_path, &bytes)?;
                    println!("✓ {} bytes", bytes.len());
                    downloaded += 1;
                }
                Ok(resp) => {
                    println!("✗ HTTP {}", resp.status());
                }
                Err(e) => {
                    println!("✗ {}", e);
                }
            }
        } else {
            println!("   (No audio URL available)");
        }
        println!();
    }

    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    println!("✓ Downloaded {} files to {:?}", downloaded, output_dir);
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");

    Ok(())
}