extern crate rodio;

use rodio::{Source, Sink};
use std::io::BufReader;
use std::time::Duration;
use std::sync::Arc;

struct ArcSource {
    data: Arc<Vec<i16>>,
    index: usize,
    channels: u16,
    samples_rate: u32,
    total_duration: Option<Duration>
}

impl ArcSource {
    pub fn from_decoder<T>(d: rodio::Decoder<T>) -> ArcSource where T: ::std::io::Read + ::std::io::Seek {
        let ch = d.channels();
        let sr = d.samples_rate();
        let td = d.total_duration();
        ArcSource::from_vec(d.collect(), ch, sr, td)
    }
    pub fn from_vec(vec: Vec<i16>, channels: u16, samples_rate: u32, total_duration: Option<Duration>) -> ArcSource {
        ArcSource {
            data: Arc::new(vec), index: 0, channels: channels, samples_rate: samples_rate, total_duration: total_duration
        }
    }
}
impl Clone for ArcSource {
    fn clone(&self) -> ArcSource {
        ArcSource {
            data: self.data.clone(), // <-- this is cheap since it's an Arc
            index: 0,
            channels: self.channels,
            samples_rate: self.samples_rate,
            total_duration: self.total_duration.clone()
        }
    }
}
impl Iterator for ArcSource {
    type Item = i16;
    fn next(&mut self) -> Option<i16> {
        let i = self.index;
        if i >= self.data.len() {
            None
        } else {
            self.index += 1;
            Some(self.data[i])
        }
    }
}
impl Source for ArcSource {
    fn current_frame_len(&self) -> Option<usize> {
        None
    }
    fn channels(&self) -> u16 {
        return self.channels;
    }
    fn samples_rate(&self) -> u32 {
        return self.samples_rate;
    }
    fn total_duration(&self) -> Option<Duration> {
        return self.total_duration;
    }
}

fn main() {
    let endpoint = rodio::get_default_endpoint().unwrap();
    let sink = Sink::new(&endpoint);

    let file = std::fs::File::open("private-wars.wav").unwrap();
    let decoder = rodio::Decoder::new(BufReader::new(file)).unwrap();

    let source = ArcSource::from_decoder(decoder);
    sink.append(source.clone());
    sink.append(source.clone());
    sink.append(source.clone());
    sink.append(source.clone());
    sink.sleep_until_end();
}