use std::{collections::VecDeque, sync::{Arc, Mutex, RwLock, mpsc::{Sender, channel}}, thread};

use opus::{Channels, Decoder};

use crate::{MONO_20MS, SAMPLE_RATE};

pub struct VoiceChatDecoder{
  stream_in: Sender<Vec<u8>>,
  last_rms: Arc<RwLock<f32>>
}

impl VoiceChatDecoder{
  pub fn new( queue: Arc<Mutex<VecDeque<f32>>> ) -> Self{
    let mut decoder = Decoder::new(SAMPLE_RATE as u32, Channels::Mono).unwrap();
    let ( stream_in, stream_out ) = channel();

    let set_rms = Arc::new(RwLock::new(0.0));
    let set_rms_1 = set_rms.clone();

    thread::spawn(move || {
      let mut buffer = [0.0; MONO_20MS];

      loop {
        let packet: Vec<u8> = stream_out.recv().unwrap();
        decoder.decode_float(&packet, &mut buffer, false).unwrap();

        let mut total = 0.0;
        for sample in buffer{ total += sample.powi(2) }
        *set_rms.write().unwrap() = 20.0 * ( total / buffer.len() as f32 ).sqrt().log10();

        let mut voice = queue.lock().unwrap();
        for sample in buffer{ voice.push_back(sample); }
      }
    });

    Self {
      stream_in,
      last_rms: set_rms_1
    }
  }

  pub fn decode( &self, packet: Vec<u8> ){
    self.stream_in.send(packet).unwrap();
  }

  pub fn get_last_rms( &self ) -> f32{
    *self.last_rms.read().unwrap()
  }
}