oximedia-cli 0.1.6

//! Audio loudness metering, normalization, spectrum analysis, and beat detection.
//!
//! Provides audio-related commands using `oximedia-metering`, `oximedia-normalize`,
//! and `oximedia-audio-analysis` crates.

use anyhow::{Context, Result};
use clap::Subcommand;
use colored::Colorize;
use std::path::PathBuf;

/// Audio command subcommands.
#[derive(Subcommand, Debug)]
pub enum AudioCommand {
    /// Measure audio loudness (ITU-R BS.1770-4)
    Loudness {
        /// Input audio/video file
        #[arg(short, long)]
        input: PathBuf,

        /// Loudness standard: ebu-r128, atsc-a85, spotify, youtube, apple-music, netflix
        #[arg(long, default_value = "ebu-r128")]
        standard: String,

        /// Sample rate override (Hz)
        #[arg(long)]
        sample_rate: Option<f64>,

        /// Number of channels override
        #[arg(long)]
        channels: Option<usize>,

        /// Output format: text, json
        #[arg(long, default_value = "text")]
        output_format: String,
    },

    /// Normalize audio loudness to a target standard
    Normalize {
        /// Input audio/video file
        #[arg(short, long)]
        input: PathBuf,

        /// Output file path
        #[arg(short, long)]
        output: PathBuf,

        /// Target loudness in LUFS (overrides standard default)
        #[arg(long)]
        target: Option<f64>,

        /// Loudness standard: ebu-r128, atsc-a85, spotify, youtube, apple-music
        #[arg(long, default_value = "spotify")]
        standard: String,

        /// Enable true peak limiter
        #[arg(long)]
        limiter: bool,

        /// Enable dynamic range compression
        #[arg(long)]
        drc: bool,
    },

    /// Analyze audio frequency spectrum
    Spectrum {
        /// Input audio/video file
        #[arg(short, long)]
        input: PathBuf,

        /// FFT size (power of 2)
        #[arg(long, default_value = "2048")]
        fft_size: usize,

        /// Output format: text, json
        #[arg(long, default_value = "text")]
        output_format: String,
    },

    /// Detect beats and tempo in audio
    Beats {
        /// Input audio/video file
        #[arg(short, long)]
        input: PathBuf,

        /// Output format: text, json
        #[arg(long, default_value = "text")]
        output_format: String,
    },
}

/// Handle audio command dispatch.
pub async fn handle_audio_command(command: AudioCommand, json_output: bool) -> Result<()> {
    match command {
        AudioCommand::Loudness {
            input,
            standard,
            sample_rate,
            channels,
            output_format,
        } => {
            measure_loudness(
                &input,
                &standard,
                sample_rate,
                channels,
                if json_output { "json" } else { &output_format },
            )
            .await
        }
        AudioCommand::Normalize {
            input,
            output,
            target,
            standard,
            limiter,
            drc,
        } => normalize_audio(&input, &output, target, &standard, limiter, drc).await,
        AudioCommand::Spectrum {
            input,
            fft_size,
            output_format,
        } => {
            analyze_spectrum(
                &input,
                fft_size,
                if json_output { "json" } else { &output_format },
            )
            .await
        }
        AudioCommand::Beats {
            input,
            output_format,
        } => detect_beats(&input, if json_output { "json" } else { &output_format }).await,
    }
}

/// Parse a standard name string into `oximedia_metering::Standard`.
fn parse_standard(name: &str) -> Result<oximedia_metering::Standard> {
    match name.trim().to_lowercase().as_str() {
        "ebu-r128" | "ebu_r128" | "ebur128" | "r128" => Ok(oximedia_metering::Standard::EbuR128),
        "atsc-a85" | "atsc_a85" | "atsca85" | "a85" => Ok(oximedia_metering::Standard::AtscA85),
        "spotify" => Ok(oximedia_metering::Standard::Spotify),
        "youtube" => Ok(oximedia_metering::Standard::YouTube),
        "apple-music" | "apple_music" | "applemusic" => {
            Ok(oximedia_metering::Standard::AppleMusic)
        }
        "netflix" => Ok(oximedia_metering::Standard::Netflix),
        "amazon" | "amazon-prime" | "prime" => Ok(oximedia_metering::Standard::AmazonPrime),
        other => Err(anyhow::anyhow!(
            "Unknown standard '{}'. Available: ebu-r128, atsc-a85, spotify, youtube, apple-music, netflix, amazon-prime",
            other
        )),
    }
}

/// Measure audio loudness.
async fn measure_loudness(
    input: &PathBuf,
    standard_name: &str,
    sample_rate: Option<f64>,
    channels: Option<usize>,
    output_format: &str,
) -> Result<()> {
    if !input.exists() {
        return Err(anyhow::anyhow!("Input file not found: {}", input.display()));
    }

    let standard = parse_standard(standard_name)?;
    let sr = sample_rate.unwrap_or(48000.0);
    let ch = channels.unwrap_or(2);

    let config = oximedia_metering::MeterConfig::new(standard, sr, ch);
    let _meter = oximedia_metering::LoudnessMeter::new(config)
        .map_err(|e| anyhow::anyhow!("Failed to create loudness meter: {}", e))?;

    match output_format {
        "json" => {
            let result = serde_json::json!({
                "input": input.display().to_string(),
                "standard": standard.name(),
                "target_lufs": standard.target_lufs(),
                "max_true_peak_dbtp": standard.max_true_peak_dbtp(),
                "tolerance_lu": standard.tolerance_lu(),
                "sample_rate": sr,
                "channels": ch,
                "status": "pending_audio_decoding",
                "metrics": {
                    "integrated_lufs": null,
                    "momentary_lufs": null,
                    "short_term_lufs": null,
                    "loudness_range": null,
                    "true_peak_dbtp": null,
                },
                "compliance": null,
                "message": "Loudness meter initialized; awaiting audio decoding pipeline integration",
            });
            let json_str =
                serde_json::to_string_pretty(&result).context("Failed to serialize result")?;
            println!("{}", json_str);
        }
        _ => {
            println!("{}", "Audio Loudness Metering".green().bold());
            println!("{}", "=".repeat(60));
            println!("{:20} {}", "Input:", input.display());
            println!("{:20} {}", "Standard:", standard.name());
            println!("{:20} {:.1} LUFS", "Target:", standard.target_lufs());
            println!(
                "{:20} {:.1} dBTP",
                "Max True Peak:",
                standard.max_true_peak_dbtp()
            );
            println!("{:20} {:.1} LU", "Tolerance:", standard.tolerance_lu());
            println!("{:20} {} Hz", "Sample rate:", sr);
            println!("{:20} {}", "Channels:", ch);
            println!();

            println!("{}", "Measurements".cyan().bold());
            println!("{}", "-".repeat(60));
            println!("  Integrated LUFS:  (pending audio decoding)");
            println!("  Momentary LUFS:   (pending audio decoding)");
            println!("  Short-term LUFS:  (pending audio decoding)");
            println!("  Loudness Range:   (pending audio decoding)");
            println!("  True Peak:        (pending audio decoding)");
            println!();

            println!(
                "{}",
                "Note: Audio decoding pipeline not yet integrated.".yellow()
            );
            println!(
                "{}",
                "Loudness meter is ready; audio decoding will enable end-to-end metering.".dimmed()
            );
        }
    }

    Ok(())
}

/// Normalize audio loudness.
async fn normalize_audio(
    input: &PathBuf,
    output: &PathBuf,
    target: Option<f64>,
    standard_name: &str,
    limiter: bool,
    drc: bool,
) -> Result<()> {
    if !input.exists() {
        return Err(anyhow::anyhow!("Input file not found: {}", input.display()));
    }

    let standard = if let Some(target_lufs) = target {
        oximedia_metering::Standard::Custom {
            target_lufs,
            max_peak_dbtp: -1.0,
            tolerance_lu: 1.0,
        }
    } else {
        parse_standard(standard_name)?
    };

    let mut config = oximedia_normalize::NormalizerConfig::new(standard, 48000.0, 2);
    config.enable_limiter = limiter;
    config.enable_drc = drc;

    let _normalizer = oximedia_normalize::Normalizer::new(config)
        .map_err(|e| anyhow::anyhow!("Failed to create normalizer: {}", e))?;

    println!("{}", "Audio Normalization".green().bold());
    println!("{}", "=".repeat(60));
    println!("{:20} {}", "Input:", input.display());
    println!("{:20} {}", "Output:", output.display());
    println!("{:20} {:.1} LUFS", "Target:", standard.target_lufs());
    println!(
        "{:20} {}",
        "Limiter:",
        if limiter { "enabled" } else { "disabled" }
    );
    println!("{:20} {}", "DRC:", if drc { "enabled" } else { "disabled" });
    println!();

    println!(
        "{}",
        "Note: Audio decoding/encoding pipeline not yet integrated.".yellow()
    );
    println!(
        "{}",
        "Normalizer is ready; audio pipeline will enable end-to-end processing.".dimmed()
    );

    Ok(())
}

/// Analyze audio frequency spectrum.
async fn analyze_spectrum(input: &PathBuf, fft_size: usize, output_format: &str) -> Result<()> {
    if !input.exists() {
        return Err(anyhow::anyhow!("Input file not found: {}", input.display()));
    }

    // Validate FFT size is a power of 2
    if fft_size == 0 || (fft_size & (fft_size - 1)) != 0 {
        return Err(anyhow::anyhow!(
            "FFT size must be a power of 2, got {}",
            fft_size
        ));
    }

    let config = oximedia_audio_analysis::AnalysisConfig {
        fft_size,
        ..oximedia_audio_analysis::AnalysisConfig::default()
    };
    let _analyzer = oximedia_audio_analysis::AudioAnalyzer::new(config);

    match output_format {
        "json" => {
            let result = serde_json::json!({
                "input": input.display().to_string(),
                "fft_size": fft_size,
                "frequency_resolution": 48000.0 / fft_size as f64,
                "status": "pending_audio_decoding",
                "spectral_features": {
                    "centroid": null,
                    "flatness": null,
                    "rolloff": null,
                    "bandwidth": null,
                },
                "message": "Audio analyzer initialized; awaiting audio decoding pipeline integration",
            });
            let json_str =
                serde_json::to_string_pretty(&result).context("Failed to serialize result")?;
            println!("{}", json_str);
        }
        _ => {
            println!("{}", "Spectrum Analysis".green().bold());
            println!("{}", "=".repeat(60));
            println!("{:20} {}", "Input:", input.display());
            println!("{:20} {}", "FFT size:", fft_size);
            println!(
                "{:20} {:.2} Hz",
                "Freq resolution:",
                48000.0 / fft_size as f64
            );
            println!();

            println!("{}", "Spectral Features".cyan().bold());
            println!("{}", "-".repeat(60));
            println!("  Centroid:   (pending audio decoding)");
            println!("  Flatness:   (pending audio decoding)");
            println!("  Rolloff:    (pending audio decoding)");
            println!("  Bandwidth:  (pending audio decoding)");
            println!();

            println!(
                "{}",
                "Note: Audio decoding pipeline not yet integrated.".yellow()
            );
        }
    }

    Ok(())
}

/// Detect beats and tempo in audio.
async fn detect_beats(input: &PathBuf, output_format: &str) -> Result<()> {
    if !input.exists() {
        return Err(anyhow::anyhow!("Input file not found: {}", input.display()));
    }

    let config = oximedia_audio_analysis::AnalysisConfig::default();
    let _analyzer = oximedia_audio_analysis::AudioAnalyzer::new(config);

    match output_format {
        "json" => {
            let result = serde_json::json!({
                "input": input.display().to_string(),
                "status": "pending_audio_decoding",
                "tempo": {
                    "bpm": null,
                    "confidence": null,
                },
                "beats": [],
                "message": "Beat detector initialized; awaiting audio decoding pipeline integration",
            });
            let json_str =
                serde_json::to_string_pretty(&result).context("Failed to serialize result")?;
            println!("{}", json_str);
        }
        _ => {
            println!("{}", "Beat Detection".green().bold());
            println!("{}", "=".repeat(60));
            println!("{:20} {}", "Input:", input.display());
            println!();

            println!("{}", "Tempo Analysis".cyan().bold());
            println!("{}", "-".repeat(60));
            println!("  BPM:        (pending audio decoding)");
            println!("  Confidence: (pending audio decoding)");
            println!("  Beats:      (pending audio decoding)");
            println!();

            println!(
                "{}",
                "Note: Audio decoding pipeline not yet integrated.".yellow()
            );
        }
    }

    Ok(())
}