sevenx_engine 0.2.11

use std::collections::HashMap;

/// Sistema de áudio para música e efeitos sonoros.
pub struct AudioSystem {
    music_volume: f32,
    sfx_volume: f32,
    current_music: Option<String>,
    sounds: HashMap<String, Vec<u8>>,
}

impl AudioSystem {
    pub fn new() -> Self {
        Self {
            music_volume: 1.0,
            sfx_volume: 1.0,
            current_music: None,
            sounds: HashMap::new(),
        }
    }

    /// Define o volume da música (0.0 a 1.0).
    pub fn set_music_volume(&mut self, volume: f32) {
        self.music_volume = volume.clamp(0.0, 1.0);
    }

    /// Define o volume dos efeitos sonoros (0.0 a 1.0).
    pub fn set_sfx_volume(&mut self, volume: f32) {
        self.sfx_volume = volume.clamp(0.0, 1.0);
    }

    /// Carrega um som na memória.
    pub fn load_sound(&mut self, key: &str, path: &str) -> Result<(), String> {
        match std::fs::read(path) {
            Ok(data) => {
                self.sounds.insert(key.to_string(), data);
                Ok(())
            }
            Err(e) => Err(format!("Falha ao carregar som {}: {}", path, e)),
        }
    }

    /// Toca um efeito sonoro.
    pub fn play_sfx(&self, key: &str) {
        if let Some(_data) = self.sounds.get(key) {
            // Implementação real requer uma biblioteca de áudio como rodio
            println!("🔊 Tocando SFX: {} (volume: {})", key, self.sfx_volume);
        }
    }

    /// Toca música de fundo.
    pub fn play_music(&mut self, key: &str, looping: bool) {
        if self.sounds.contains_key(key) {
            self.current_music = Some(key.to_string());
            println!("🎵 Tocando música: {} (loop: {}, volume: {})", key, looping, self.music_volume);
        }
    }

    /// Para a música atual.
    pub fn stop_music(&mut self) {
        if let Some(music) = &self.current_music {
            println!("⏹️ Parando música: {}", music);
            self.current_music = None;
        }
    }

    /// Pausa a música.
    pub fn pause_music(&self) {
        if let Some(music) = &self.current_music {
            println!("⏸️ Pausando música: {}", music);
        }
    }

    /// Retoma a música.
    pub fn resume_music(&self) {
        if let Some(music) = &self.current_music {
            println!("▶️ Retomando música: {}", music);
        }
    }

    /// Remove um som da memória.
    pub fn unload_sound(&mut self, key: &str) -> bool {
        self.sounds.remove(key).is_some()
    }

    /// Limpa todos os sons.
    pub fn clear(&mut self) {
        self.sounds.clear();
        self.current_music = None;
    }
}

impl Default for AudioSystem {
    fn default() -> Self {
        Self::new()
    }
}

// Nota: Para implementação completa com áudio real, adicione ao Cargo.toml:
// rodio = "0.17" (para áudio multiplataforma)
// ou kira = "0.8" (para áudio de jogos)