use std::{
    collections::VecDeque,
    sync::mpsc::{Receiver, SyncSender, sync_channel},
};

use anyhow::{Result, anyhow};
use audiopus::{
    Application, Channels, SampleRate,
    coder::{Decoder, Encoder},
};
use cpal::{
    Stream,
    traits::{DeviceTrait, HostTrait},
};
use log::warn;

pub struct Audio {
    _instream: Stream,
    _outstream: Stream,
    rx: Receiver<Vec<u8>>,
    tx: SyncSender<Vec<u8>>,
}
impl Audio {
    pub fn new() -> Result<Self> {
        let host = cpal::default_host();

        let indev = host
            .default_input_device()
            .ok_or(anyhow!("no input device"))?;
        let outdev = host
            .default_output_device()
            .ok_or(anyhow!("no output device"))?;

        let mut inconf = indev.default_input_config()?.config();
        inconf.channels = 1;
        inconf.sample_rate = cpal::SampleRate(48_000);
        inconf.buffer_size = cpal::BufferSize::Fixed(480);

        let mut outconf = outdev.default_input_config()?.config();
        outconf.channels = 1;
        outconf.sample_rate = cpal::SampleRate(48_000);
        outconf.buffer_size = cpal::BufferSize::Fixed(480);

        let (mut aenc, rx) = AEncoder::new()?;
        let (mut adec, tx) = ADecoder::new()?;

        let instream = indev.build_input_stream(
            &inconf,
            move |samples: &[f32], _| {
                if let Err(e) = aenc.data(samples) {
                    warn!("encoder error: {e}");
                }
            },
            |err| warn!("audio input error: {err}"),
            None,
        )?;
        let outstream = outdev.build_output_stream(
            &outconf,
            move |samples: &mut [f32], _| {
                if let Err(e) = adec.data(samples) {
                    warn!("decoder error: {e}");
                }
            },
            |err| warn!("audio output error: {err}"),
            None,
        )?;

        Ok(Self {
            _instream: instream,
            _outstream: outstream,
            rx,
            tx,
        })
    }
    pub fn update(&mut self) {
        for e in self.rx.try_iter() {
            let _ = self.tx.try_send(e);
        }
    }
}

pub struct AEncoder {
    encoder: Encoder,
    sender: SyncSender<Vec<u8>>,
    buffer: VecDeque<f32>,
}
impl AEncoder {
    pub fn new() -> Result<(Self, Receiver<Vec<u8>>)> {
        let (sender, rx) = sync_channel(1024);
        Ok((
            Self {
                encoder: Encoder::new(SampleRate::Hz48000, Channels::Mono, Application::Voip)?,
                sender,
                buffer: VecDeque::new(),
            },
            rx,
        ))
    }
    pub fn data(&mut self, samples: &[f32]) -> Result<()> {
        self.buffer.extend(samples);
        while self.buffer.len() >= 120 {
            let mut out = [0u8; 120];
            let mut inp = [0f32; 120];
            for i in 0..120 {
                inp[i] = self.buffer.pop_front().unwrap();
            }
            let size = self.encoder.encode_float(&inp, &mut out)?;
            eprintln!("enc {size}");
            let _ = self.sender.try_send(out[..size].to_vec());
        }
        Ok(())
    }
}

pub struct ADecoder {
    decoder: Decoder,
    receiver: Receiver<Vec<u8>>,
    buffer: VecDeque<f32>,
}
impl ADecoder {
    pub fn new() -> Result<(Self, SyncSender<Vec<u8>>)> {
        let (tx, receiver) = sync_channel(1024);
        Ok((
            Self {
                decoder: Decoder::new(SampleRate::Hz48000, Channels::Mono)?,
                receiver,
                buffer: VecDeque::new(),
            },
            tx,
        ))
    }
    pub fn data(&mut self, samples: &mut [f32]) -> Result<()> {
        while self.buffer.len() < samples.len() {
            if let Ok(buf) = self.receiver.try_recv() {
                let mut output = [0f32; 120];
                let size = self.decoder.decode_float(
                    Some(buf.as_slice()),
                    output.as_mut_slice(),
                    false,
                )?;
                eprintln!("dec {size}");
                self.buffer.extend(&output[..size]);
            } else {
                break;
            }
        }

        for x in samples {
            *x = self.buffer.pop_front().unwrap_or(0.);
        }
        Ok(())
    }
}