use std::time::Duration;

use anyhow::{Result, bail};
use audioadapter_buffers::direct::InterleavedSlice;
use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};
use rubato::Resampler;
use tracing::error;

pub struct Audio {
    #[allow(unused)]
    stream: cpal::Stream,
    sampler: rubato::Async<f32>,
    input_buffer: Vec<f32>,
    output_buffer: Vec<f32>,
    sample_sink: rtrb::Producer<f32>,
}

const VB_FREQUENCY: usize = 41700;

impl Audio {
    pub fn init() -> Result<Self> {
        let host = cpal::default_host();
        let Some(device) = host.default_output_device() else {
            bail!("No output device available");
        };
        let Some(config) = device
            .supported_output_configs()?
            .find(|c| c.channels() == 2 && c.sample_format().is_float())
        else {
            bail!("No suitable output config available");
        };
        let mut config = config.with_max_sample_rate().config();
        let resample_ratio = config.sample_rate.0 as f64 / VB_FREQUENCY as f64;
        let chunk_size = (834.0 * resample_ratio) as usize;
        let sampler = rubato::Async::new_poly(
            resample_ratio,
            64.0,
            rubato::PolynomialDegree::Cubic,
            chunk_size,
            2,
            rubato::FixedAsync::Output,
        )?;
        config.buffer_size = cpal::BufferSize::Fixed(sampler.output_frames_max() as u32);

        let input_buffer = Vec::with_capacity(sampler.nbr_channels() * sampler.input_frames_max());
        let output_buffer = vec![0.0; sampler.nbr_channels() * sampler.output_frames_max()];
        let (sample_sink, mut sample_source) =
            rtrb::RingBuffer::new(sampler.output_frames_max() * 4);

        let stream = device.build_output_stream(
            &config,
            move |data: &mut [f32], _| {
                let requested = data.len();
                let chunk = match sample_source.read_chunk(data.len()) {
                    Ok(c) => c,
                    Err(rtrb::chunks::ChunkError::TooFewSlots(n)) => {
                        sample_source.read_chunk(n).unwrap()
                    }
                };
                let len = chunk.len();
                let (first, second) = chunk.as_slices();
                data[0..first.len()].copy_from_slice(first);
                data[first.len()..len].copy_from_slice(second);
                for rest in &mut data[len..requested] {
                    *rest = 0.0;
                }
                chunk.commit_all();
            },
            move |error| error!(%error, "stream error"),
            None,
        )?;
        stream.play()?;
        Ok(Self {
            stream,
            sampler,
            input_buffer,
            output_buffer,
            sample_sink,
        })
    }

    pub fn update(&mut self, mut samples: &[f32]) {
        while self.input_buffer.len() + samples.len() >= self.sampler.input_frames_next() * 2 {
            let samples_needed =
                (self.sampler.input_frames_next() * 2).saturating_sub(self.input_buffer.len());
            let (current_samples, future_samples) = samples.split_at(samples_needed);
            self.input_buffer.extend_from_slice(current_samples);
            samples = future_samples;

            let buffer_in =
                InterleavedSlice::new(&self.input_buffer, 2, self.sampler.input_frames_next())
                    .unwrap();
            let mut buffer_out = InterleavedSlice::new_mut(
                &mut self.output_buffer,
                2,
                self.sampler.output_frames_next(),
            )
            .unwrap();
            let (_, output_samples) = self
                .sampler
                .process_into_buffer(&buffer_in, &mut buffer_out, None)
                .unwrap();
            let chunk = match self.sample_sink.write_chunk_uninit(output_samples * 2) {
                Ok(c) => c,
                Err(rtrb::chunks::ChunkError::TooFewSlots(n)) => {
                    self.sample_sink.write_chunk_uninit(n).unwrap()
                }
            };
            chunk.fill_from_iter(self.output_buffer[..output_samples * 2].iter().copied());

            self.input_buffer.clear();
        }
        self.input_buffer.extend_from_slice(samples);

        while self.sample_sink.slots() < self.sampler.output_frames_max() * 2 {
            std::thread::sleep(Duration::from_micros(500));
        }
    }

    pub fn set_speed(&mut self, speed: f64) -> Result<()> {
        self.sampler
            .set_resample_ratio_relative(1.0 / speed, false)?;
        Ok(())
    }
}