voirs-cli 0.1.0-rc.1

//! Singing voice synthesis commands for the VoiRS CLI

use crate::{error::CliError, output::OutputFormatter};
use clap::{Args, Subcommand};
use std::path::{Path, PathBuf};
#[cfg(feature = "singing")]
use voirs_singing::{
    score::{
        ChordInfo, DynamicMarking, ExpressionMarking, KeySignature, Lyrics, Marker, Mode, Note,
        Ornament, Section, TimeSignature, Tuplet,
    },
    synthesis::{QualityMetrics, SynthesisStats},
    techniques::{
        ArticulationSettings, ConnectionType, DynamicsSettings, ExpressionSettings,
        FormantSettings, LegatoSettings, PortamentoSettings, ResonanceSettings, VibratoSettings,
        VocalFry,
    },
    types::{Articulation, BreathInfo, Dynamics, PitchBend},
    BreathControl, Expression, MusicalNote, MusicalScore, NoteEvent, SingingConfig, SingingStats,
    SingingTechnique, SynthesisResult, VibratoProcessor, VoiceCharacteristics, VoiceController,
    VoiceType,
};

use hound;

/// Singing voice synthesis commands
#[cfg(feature = "singing")]
#[derive(Debug, Clone, Subcommand)]
pub enum SingingCommand {
    /// Synthesize singing from musical score
    Score(ScoreArgs),
    /// Synthesize singing from MIDI file
    Midi(MidiArgs),
    /// Create a singing voice model from training samples
    CreateVoice(CreateVoiceArgs),
    /// Validate score and voice compatibility
    Validate(ValidateArgs),
    /// Apply singing effects to existing audio
    Effects(EffectsArgs),
    /// Analyze singing audio for quality metrics
    Analyze(AnalyzeArgs),
    /// List available singing presets
    ListPresets(ListPresetsArgs),
}

#[derive(Debug, Clone, Args)]
pub struct ScoreArgs {
    /// Musical score file (MusicXML format)
    #[arg(long)]
    pub score: PathBuf,
    /// Singing voice model to use
    #[arg(long)]
    pub voice: String,
    /// Output audio file
    pub output: PathBuf,
    /// Tempo in BPM (overrides score tempo)
    #[arg(long)]
    pub tempo: Option<f32>,
    /// Key signature (C, D, E, F, G, A, B with optional #/b)
    #[arg(long)]
    pub key: Option<String>,
    /// Singing technique preset
    #[arg(long, default_value = "classical")]
    pub technique: String,
    /// Voice type (soprano, alto, tenor, bass)
    #[arg(long, default_value = "soprano")]
    pub voice_type: String,
    /// Sample rate for output audio
    #[arg(long, default_value = "44100")]
    pub sample_rate: u32,
}

#[derive(Debug, Clone, Args)]
pub struct MidiArgs {
    /// MIDI file input
    pub midi: PathBuf,
    /// Lyrics file (plain text, one line per note)
    #[arg(long)]
    pub lyrics: PathBuf,
    /// Singing voice model to use
    #[arg(long)]
    pub voice: String,
    /// Output audio file
    pub output: PathBuf,
    /// Tempo in BPM (overrides MIDI tempo)
    #[arg(long)]
    pub tempo: Option<f32>,
    /// Singing technique preset
    #[arg(long, default_value = "classical")]
    pub technique: String,
    /// Voice type (soprano, alto, tenor, bass)
    #[arg(long, default_value = "soprano")]
    pub voice_type: String,
}

#[derive(Debug, Clone, Args)]
pub struct CreateVoiceArgs {
    /// Directory containing singing samples
    pub samples: PathBuf,
    /// Output singing voice model file
    #[arg(long)]
    pub output: PathBuf,
    /// Voice name/identifier
    #[arg(long)]
    pub name: String,
    /// Voice type (soprano, alto, tenor, bass)
    #[arg(long, default_value = "soprano")]
    pub voice_type: String,
    /// Training quality threshold (0.0-1.0)
    #[arg(long, default_value = "0.8")]
    pub quality_threshold: f32,
    /// Number of training epochs
    #[arg(long, default_value = "100")]
    pub epochs: u32,
}

#[derive(Debug, Clone, Args)]
pub struct ValidateArgs {
    /// Musical score file to validate
    pub score: PathBuf,
    /// Singing voice model to validate against
    #[arg(long)]
    pub voice: String,
    /// Generate detailed validation report
    #[arg(long)]
    pub detailed: bool,
}

#[derive(Debug, Clone, Args)]
pub struct EffectsArgs {
    /// Input audio file
    pub input: PathBuf,
    /// Output audio file
    pub output: PathBuf,
    /// Vibrato intensity (0.0-2.0)
    #[arg(long, default_value = "1.0")]
    pub vibrato: f32,
    /// Expression style (happy, sad, passionate, calm)
    #[arg(long, default_value = "neutral")]
    pub expression: String,
    /// Breath control intensity (0.0-1.0)
    #[arg(long, default_value = "0.5")]
    pub breath_control: f32,
    /// Pitch bend sensitivity (0.0-1.0)
    #[arg(long, default_value = "0.3")]
    pub pitch_bend: f32,
}

#[derive(Debug, Clone, Args)]
pub struct AnalyzeArgs {
    /// Singing audio file to analyze
    pub input: PathBuf,
    /// Output analysis report file (JSON format)
    #[arg(long)]
    pub report: PathBuf,
    /// Include detailed pitch analysis
    #[arg(long)]
    pub pitch_analysis: bool,
    /// Include vibrato analysis
    #[arg(long)]
    pub vibrato_analysis: bool,
    /// Include breath pattern analysis
    #[arg(long)]
    pub breath_analysis: bool,
}

#[derive(Debug, Clone, Args)]
pub struct ListPresetsArgs {
    /// Show detailed preset information
    #[arg(long)]
    pub detailed: bool,
    /// Filter by voice type
    #[arg(long)]
    pub voice_type: Option<String>,
}

/// Execute singing command
#[cfg(feature = "singing")]
pub async fn execute_singing_command(
    command: SingingCommand,
    output_formatter: &OutputFormatter,
) -> Result<(), CliError> {
    match command {
        SingingCommand::Score(args) => execute_score_command(args, output_formatter).await,
        SingingCommand::Midi(args) => execute_midi_command(args, output_formatter).await,
        SingingCommand::CreateVoice(args) => {
            execute_create_voice_command(args, output_formatter).await
        }
        SingingCommand::Validate(args) => execute_validate_command(args, output_formatter).await,
        SingingCommand::Effects(args) => execute_effects_command(args, output_formatter).await,
        SingingCommand::Analyze(args) => execute_analyze_command(args, output_formatter).await,
        SingingCommand::ListPresets(args) => {
            execute_list_presets_command(args, output_formatter).await
        }
    }
}

#[cfg(feature = "singing")]
async fn execute_score_command(
    args: ScoreArgs,
    output_formatter: &OutputFormatter,
) -> Result<(), CliError> {
    output_formatter.info(&format!(
        "Synthesizing singing from score: {:?}",
        args.score
    ));

    // Create singing controller
    let voice_characteristics = VoiceCharacteristics {
        voice_type: VoiceType::Soprano,
        range: (200.0, 800.0),
        f0_mean: 400.0,
        f0_std: 50.0,
        vibrato_frequency: 5.0,
        vibrato_depth: 0.3,
        breath_capacity: 10.0,
        vocal_power: 0.8,
        resonance: std::collections::HashMap::new(),
        timbre: std::collections::HashMap::new(),
    };
    let mut controller = VoiceController::new(voice_characteristics);

    // Parse voice type
    let voice_type = parse_voice_type(&args.voice_type)?;
    let mut updated_voice = controller.get_voice().clone();
    updated_voice.voice_type = voice_type;
    controller.set_voice(updated_voice);

    // Apply singing technique
    let _technique = create_singing_technique(&args.technique)?;

    // Load and parse musical score
    let score = load_musical_score(&args.score)?;

    // Mock synthesis result
    let result = SynthesisResult {
        audio: vec![0.0; 44100], // 1 second of silence at 44.1kHz
        sample_rate: 44100.0,
        duration: std::time::Duration::from_secs(1),
        stats: SynthesisStats::default(),
        quality_metrics: QualityMetrics {
            pitch_accuracy: 0.95,
            spectral_quality: 0.90,
            harmonic_quality: 0.88,
            noise_level: 0.05,
            formant_quality: 0.92,
            overall_quality: 0.90,
        },
    };

    // Save output audio
    save_audio(&result.audio, &args.output, args.sample_rate)?;

    output_formatter.success(&format!("Singing synthesis completed: {:?}", args.output));
    output_formatter.info(&format!("Frames processed: {}", result.stats.frame_count));
    output_formatter.info(&format!(
        "Synthesis quality: {:.1}%",
        result.stats.quality * 100.0
    ));
    output_formatter.info(&format!(
        "Processing time: {:.2}s",
        result.stats.processing_time.as_secs_f32()
    ));

    Ok(())
}

#[cfg(feature = "singing")]
async fn execute_midi_command(
    args: MidiArgs,
    output_formatter: &OutputFormatter,
) -> Result<(), CliError> {
    output_formatter.info(&format!("Synthesizing singing from MIDI: {:?}", args.midi));

    // Create singing controller
    let voice_characteristics = VoiceCharacteristics {
        voice_type: VoiceType::Soprano,
        range: (200.0, 800.0),
        f0_mean: 400.0,
        f0_std: 50.0,
        vibrato_frequency: 5.0,
        vibrato_depth: 0.3,
        breath_capacity: 10.0,
        vocal_power: 0.8,
        resonance: std::collections::HashMap::new(),
        timbre: std::collections::HashMap::new(),
    };
    let mut controller = VoiceController::new(voice_characteristics);

    // Parse voice type
    let voice_type = parse_voice_type(&args.voice_type)?;
    let mut updated_voice = controller.get_voice().clone();
    updated_voice.voice_type = voice_type;
    controller.set_voice(updated_voice);

    // Apply singing technique
    let _technique = create_singing_technique(&args.technique)?;

    // Load MIDI file and lyrics
    let (score, lyrics) = load_midi_with_lyrics(&args.midi, &args.lyrics)?;

    // Mock synthesis result with lyrics
    let result = SynthesisResult {
        audio: vec![0.0; 44100], // 1 second of silence at 44.1kHz
        sample_rate: 44100.0,
        duration: std::time::Duration::from_secs(1),
        stats: SynthesisStats::default(),
        quality_metrics: QualityMetrics {
            pitch_accuracy: 0.95,
            spectral_quality: 0.90,
            harmonic_quality: 0.88,
            noise_level: 0.05,
            formant_quality: 0.92,
            overall_quality: 0.90,
        },
    };

    // Save output audio
    save_audio(&result.audio, &args.output, 44100)?;

    output_formatter.success(&format!(
        "MIDI singing synthesis completed: {:?}",
        args.output
    ));
    output_formatter.info(&format!("Frames processed: {}", result.stats.frame_count));

    Ok(())
}

#[cfg(feature = "singing")]
async fn execute_create_voice_command(
    args: CreateVoiceArgs,
    output_formatter: &OutputFormatter,
) -> Result<(), CliError> {
    output_formatter.info(&format!(
        "Creating singing voice model from: {:?}",
        args.samples
    ));

    // Validate samples directory
    if !args.samples.exists() || !args.samples.is_dir() {
        return Err(CliError::InvalidArgument(format!(
            "Samples directory not found: {:?}",
            args.samples
        )));
    }

    // Mock implementation - in reality would train a singing voice model
    output_formatter.info("Analyzing singing samples...");
    output_formatter.info("Extracting vocal characteristics...");
    output_formatter.info("Training singing voice model...");

    // Simulate training progress
    for epoch in 1..=args.epochs {
        if epoch % 10 == 0 {
            output_formatter.info(&format!("Training epoch {}/{}", epoch, args.epochs));
        }
    }

    // Save model (mock)
    std::fs::write(&args.output, format!("VOIRS_SINGING_MODEL:{}", args.name))
        .map_err(|e| CliError::IoError(e.to_string()))?;

    output_formatter.success(&format!("Singing voice model created: {:?}", args.output));
    output_formatter.info(&format!("Voice name: {}", args.name));
    output_formatter.info(&format!("Voice type: {}", args.voice_type));
    output_formatter.info(&format!(
        "Quality threshold: {:.1}%",
        args.quality_threshold * 100.0
    ));

    Ok(())
}

#[cfg(feature = "singing")]
async fn execute_validate_command(
    args: ValidateArgs,
    output_formatter: &OutputFormatter,
) -> Result<(), CliError> {
    output_formatter.info(&format!("Validating score: {:?}", args.score));

    // Load and validate musical score
    let score = load_musical_score(&args.score)?;

    // Validate voice compatibility
    let voice_compatible = validate_voice_compatibility(&args.voice, &score)?;

    if voice_compatible {
        output_formatter.success("Score and voice are compatible");
    } else {
        output_formatter.warning("Score and voice may have compatibility issues");
    }

    if args.detailed {
        output_formatter.info(&format!("Total notes: {}", score.notes.len()));
        output_formatter.info(&format!("Tempo: {} BPM", score.tempo));
        output_formatter.info(&format!("Key signature: {:?}", score.key_signature));
        output_formatter.info(&format!("Time signature: {:?}", score.time_signature));

        // Analyze note range
        let (min_freq, max_freq) = analyze_note_range(&score.notes);
        output_formatter.info(&format!(
            "Note range: {:.1} Hz - {:.1} Hz",
            min_freq, max_freq
        ));
    }

    Ok(())
}

#[cfg(feature = "singing")]
async fn execute_effects_command(
    args: EffectsArgs,
    output_formatter: &OutputFormatter,
) -> Result<(), CliError> {
    output_formatter.info(&format!("Applying singing effects to: {:?}", args.input));

    // Load input audio
    let audio = load_audio(&args.input)?;

    // Apply singing effects
    let processed_audio = apply_singing_effects(audio, &args)?;

    // Save output audio
    save_audio(&processed_audio, &args.output, 44100)?;

    output_formatter.success(&format!("Singing effects applied: {:?}", args.output));
    output_formatter.info(&format!("Vibrato intensity: {:.1}", args.vibrato));
    output_formatter.info(&format!("Expression: {}", args.expression));
    output_formatter.info(&format!("Breath control: {:.1}", args.breath_control));

    Ok(())
}

#[cfg(feature = "singing")]
async fn execute_analyze_command(
    args: AnalyzeArgs,
    output_formatter: &OutputFormatter,
) -> Result<(), CliError> {
    output_formatter.info(&format!("Analyzing singing audio: {:?}", args.input));

    // Load audio for analysis
    let audio = load_audio(&args.input)?;

    // Perform singing analysis
    let analysis = analyze_singing_audio(&audio, &args)?;

    // Save analysis report
    let report_json = serde_json::to_string_pretty(&analysis)
        .map_err(|e| CliError::InvalidArgument(format!("Failed to serialize analysis: {}", e)))?;

    std::fs::write(&args.report, report_json).map_err(|e| CliError::IoError(e.to_string()))?;

    output_formatter.success(&format!("Analysis completed: {:?}", args.report));
    output_formatter.info(&format!(
        "Pitch accuracy: {:.1}%",
        analysis.pitch_accuracy * 100.0
    ));
    output_formatter.info(&format!(
        "Vibrato consistency: {:.1}%",
        analysis.vibrato_consistency * 100.0
    ));
    output_formatter.info(&format!(
        "Breath quality: {:.1}%",
        analysis.breath_quality * 100.0
    ));

    Ok(())
}

#[cfg(feature = "singing")]
async fn execute_list_presets_command(
    args: ListPresetsArgs,
    output_formatter: &OutputFormatter,
) -> Result<(), CliError> {
    output_formatter.info("Available singing presets:");

    let presets = get_singing_presets(args.voice_type.as_deref())?;

    for preset in presets {
        if args.detailed {
            output_formatter.info(&format!("  {}: {}", preset.name, preset.description));
            output_formatter.info(&format!("    Voice type: {}", preset.voice_type));
            output_formatter.info(&format!("    Technique: {}", preset.technique_description));
        } else {
            output_formatter.info(&format!("  {}", preset.name));
        }
    }

    Ok(())
}

// Helper functions

fn parse_voice_type(voice_type: &str) -> Result<VoiceType, CliError> {
    match voice_type.to_lowercase().as_str() {
        "soprano" => Ok(VoiceType::Soprano),
        "alto" => Ok(VoiceType::Alto),
        "tenor" => Ok(VoiceType::Tenor),
        "bass" => Ok(VoiceType::Bass),
        _ => Err(CliError::InvalidArgument(format!(
            "Invalid voice type: {}. Must be one of: soprano, alto, tenor, bass",
            voice_type
        ))),
    }
}

fn create_singing_technique(technique: &str) -> Result<SingingTechnique, CliError> {
    match technique.to_lowercase().as_str() {
        "classical" => Ok(SingingTechnique {
            breath_control: BreathControl::default(),
            vibrato: VibratoSettings::default(),
            vocal_fry: VocalFry::default(),
            legato: LegatoSettings::default(),
            portamento: PortamentoSettings::default(),
            dynamics: DynamicsSettings::default(),
            articulation: ArticulationSettings::default(),
            expression: ExpressionSettings::default(),
            formant: FormantSettings::default(),
            resonance: ResonanceSettings::default(),
        }),
        "pop" => Ok(SingingTechnique {
            breath_control: BreathControl::default(),
            vibrato: VibratoSettings::default(),
            vocal_fry: VocalFry::default(),
            legato: LegatoSettings::default(),
            portamento: PortamentoSettings::default(),
            dynamics: DynamicsSettings::default(),
            articulation: ArticulationSettings::default(),
            expression: ExpressionSettings::default(),
            formant: FormantSettings::default(),
            resonance: ResonanceSettings::default(),
        }),
        "jazz" => Ok(SingingTechnique {
            breath_control: BreathControl::default(),
            vibrato: VibratoSettings::default(),
            vocal_fry: VocalFry::default(),
            legato: LegatoSettings::default(),
            portamento: PortamentoSettings::default(),
            dynamics: DynamicsSettings::default(),
            articulation: ArticulationSettings::default(),
            expression: ExpressionSettings::default(),
            formant: FormantSettings::default(),
            resonance: ResonanceSettings::default(),
        }),
        "folk" => Ok(SingingTechnique {
            breath_control: BreathControl::default(),
            vibrato: VibratoSettings::default(),
            vocal_fry: VocalFry::default(),
            legato: LegatoSettings::default(),
            portamento: PortamentoSettings::default(),
            dynamics: DynamicsSettings::default(),
            articulation: ArticulationSettings::default(),
            expression: ExpressionSettings::default(),
            formant: FormantSettings::default(),
            resonance: ResonanceSettings::default(),
        }),
        _ => Err(CliError::InvalidArgument(format!(
            "Invalid singing technique: {}. Must be one of: classical, pop, jazz, folk",
            technique
        ))),
    }
}

fn load_musical_score(path: &Path) -> Result<MusicalScore, CliError> {
    // Mock implementation - in reality would parse MusicXML
    let notes = vec![
        MusicalNote {
            event: NoteEvent {
                note: "C".to_string(),
                octave: 4,
                frequency: 261.63,
                duration: 1.0,
                velocity: 0.8,
                vibrato: 0.3,
                lyric: Some("Do".to_string()),
                phonemes: vec!["d".to_string(), "o".to_string()],
                expression: Expression::Neutral,
                timing_offset: 0.0,
                breath_before: 0.0,
                legato: false,
                articulation: Articulation::Normal,
            },
            start_time: 0.0,
            duration: 1.0,
            pitch_bend: None,
            articulation: Articulation::Normal,
            dynamics: Dynamics::MezzoForte,
            tie_next: false,
            tie_prev: false,
            tuplet: None,
            ornaments: vec![],
            chord: None,
        },
        MusicalNote {
            event: NoteEvent {
                note: "D".to_string(),
                octave: 4,
                frequency: 293.66,
                duration: 1.0,
                velocity: 0.8,
                vibrato: 0.3,
                lyric: Some("Re".to_string()),
                phonemes: vec!["r", "e"].iter().map(|s| s.to_string()).collect(),
                expression: Expression::Neutral,
                timing_offset: 0.0,
                breath_before: 0.0,
                legato: false,
                articulation: Articulation::Normal,
            },
            start_time: 1.0,
            duration: 1.0,
            pitch_bend: None,
            articulation: Articulation::Normal,
            dynamics: Dynamics::MezzoForte,
            tie_next: false,
            tie_prev: false,
            tuplet: None,
            ornaments: vec![],
            chord: None,
        },
        MusicalNote {
            event: NoteEvent {
                note: "E".to_string(),
                octave: 4,
                frequency: 329.63,
                duration: 1.0,
                velocity: 0.8,
                vibrato: 0.3,
                lyric: Some("Mi".to_string()),
                phonemes: vec!["m", "i"].iter().map(|s| s.to_string()).collect(),
                expression: Expression::Neutral,
                timing_offset: 0.0,
                breath_before: 0.0,
                legato: false,
                articulation: Articulation::Normal,
            },
            start_time: 2.0,
            duration: 1.0,
            pitch_bend: None,
            articulation: Articulation::Normal,
            dynamics: Dynamics::MezzoForte,
            tie_next: false,
            tie_prev: false,
            tuplet: None,
            ornaments: vec![],
            chord: None,
        },
    ];

    Ok(MusicalScore {
        title: "Mock Score".to_string(),
        composer: "VoiRS CLI".to_string(),
        key_signature: KeySignature {
            root: Note::C,
            mode: Mode::Major,
            accidentals: 0,
        },
        time_signature: TimeSignature {
            numerator: 4,
            denominator: 4,
        },
        tempo: 120.0,
        notes,
        lyrics: None,
        metadata: std::collections::HashMap::new(),
        duration: std::time::Duration::from_secs(3),
        sections: vec![],
        markers: vec![],
        breath_marks: vec![],
        dynamics: vec![],
        expressions: vec![],
    })
}

fn load_midi_with_lyrics(
    midi_path: &Path,
    lyrics_path: &Path,
) -> Result<(MusicalScore, String), CliError> {
    // Mock implementation - in reality would parse MIDI and lyrics
    let lyrics =
        std::fs::read_to_string(lyrics_path).map_err(|e| CliError::IoError(e.to_string()))?;

    let score = load_musical_score(midi_path)?;

    Ok((score, lyrics))
}

fn validate_voice_compatibility(voice: &str, score: &MusicalScore) -> Result<bool, CliError> {
    // Mock implementation - in reality would validate voice range against score
    Ok(true)
}

fn analyze_note_range(notes: &[MusicalNote]) -> (f32, f32) {
    let frequencies: Vec<f32> = notes.iter().map(|n| n.event.frequency).collect();
    let min_freq = frequencies.iter().fold(f32::INFINITY, |a, &b| a.min(b));
    let max_freq = frequencies.iter().fold(f32::NEG_INFINITY, |a, &b| a.max(b));
    (min_freq, max_freq)
}

fn load_audio(path: &Path) -> Result<Vec<f32>, CliError> {
    // Mock implementation - in reality would load audio file
    Ok(vec![0.0; 44100]) // 1 second of silence
}

fn apply_singing_effects(audio: Vec<f32>, args: &EffectsArgs) -> Result<Vec<f32>, CliError> {
    // Mock implementation - in reality would apply actual singing effects
    Ok(audio)
}

fn save_audio(audio: &[f32], path: &Path, sample_rate: u32) -> Result<(), CliError> {
    let spec = hound::WavSpec {
        channels: 1,
        sample_rate,
        bits_per_sample: 16,
        sample_format: hound::SampleFormat::Int,
    };

    let mut writer = hound::WavWriter::create(path, spec)
        .map_err(|e| CliError::IoError(format!("Failed to create audio writer: {}", e)))?;

    for &sample in audio {
        let sample_i16 = (sample * 32767.0) as i16;
        writer
            .write_sample(sample_i16)
            .map_err(|e| CliError::IoError(format!("Failed to write audio sample: {}", e)))?;
    }

    writer
        .finalize()
        .map_err(|e| CliError::IoError(format!("Failed to finalize audio file: {}", e)))?;

    Ok(())
}

#[derive(Debug, serde::Serialize)]
struct SingingAnalysis {
    pitch_accuracy: f32,
    vibrato_consistency: f32,
    breath_quality: f32,
    note_count: usize,
    average_frequency: f32,
}

fn analyze_singing_audio(audio: &[f32], args: &AnalyzeArgs) -> Result<SingingAnalysis, CliError> {
    // Mock implementation - in reality would perform actual audio analysis
    Ok(SingingAnalysis {
        pitch_accuracy: 0.92,
        vibrato_consistency: 0.85,
        breath_quality: 0.88,
        note_count: 50,
        average_frequency: 440.0,
    })
}

#[derive(Debug)]
struct SingingPreset {
    name: String,
    description: String,
    voice_type: String,
    technique_description: String,
}

fn get_singing_presets(voice_type_filter: Option<&str>) -> Result<Vec<SingingPreset>, CliError> {
    let mut presets = vec![
        SingingPreset {
            name: "classical".to_string(),
            description: "Classical operatic style with controlled vibrato".to_string(),
            voice_type: "soprano".to_string(),
            technique_description: "High breath control, moderate vibrato".to_string(),
        },
        SingingPreset {
            name: "pop".to_string(),
            description: "Modern pop style with expressive dynamics".to_string(),
            voice_type: "alto".to_string(),
            technique_description: "Flexible breath control, strong pitch bending".to_string(),
        },
        SingingPreset {
            name: "jazz".to_string(),
            description: "Jazz style with smooth legato and rich vibrato".to_string(),
            voice_type: "tenor".to_string(),
            technique_description: "Smooth legato, rich vibrato, strong pitch bending".to_string(),
        },
        SingingPreset {
            name: "folk".to_string(),
            description: "Traditional folk style with natural expression".to_string(),
            voice_type: "bass".to_string(),
            technique_description: "Natural breath control, minimal vibrato".to_string(),
        },
    ];

    if let Some(filter) = voice_type_filter {
        presets.retain(|p| p.voice_type == filter);
    }

    Ok(presets)
}