use std::collections::HashMap;
use std::sync::{Arc, Mutex};

#[derive(Clone)]
pub struct AudioFenceHandle {
    gui_to_audio: Arc<Mutex<Vec<(String, f32)>>>,
    audio_to_gui: Arc<Mutex<HashMap<String, f32>>>,
}

impl AudioFenceHandle {
    pub fn new() -> Self {
        Self {
            gui_to_audio: Arc::new(Mutex::new(Vec::new())),
            audio_to_gui: Arc::new(Mutex::new(HashMap::new())),
        }
    }

    pub fn drain_changes(&mut self) -> Vec<(String, f32)> {
        let mut lock = self.gui_to_audio.lock().unwrap();
        lock.drain(..).collect()
    }

    pub fn write_readback(&self, key: &str, value: f32) {
        let mut lock = self.audio_to_gui.lock().unwrap();
        lock.insert(key.to_string(), value);
    }

    pub fn push_change(&self, key: String, value: f32) {
        let mut lock = self.gui_to_audio.lock().unwrap();
        lock.push((key, value));
    }

    pub fn read_current(&self) -> HashMap<String, f32> {
        let lock = self.audio_to_gui.lock().unwrap();
        lock.clone()
    }
}

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