extern crate gst;

use std::sync::mpsc;
use itertools::Itertools;

use config;

pub struct RecordingPipeline {
    pipeline : gst::Pipeline,
    mainloop : gst::MainLoop,
    bus_receiver : mpsc::Receiver<gst::Message>,
    appsink : gst::AppSink,
}


impl RecordingPipeline {
    pub fn new(record_config : &config::Config)  -> RecordingPipeline {
        let pipeline_str = format!("alsasrc device={} ! audio/x-raw,rate={},channels=2 ! \
            queue ! tee name=apptee ! audioconvert ! flacenc ! filesink location={}/{}.flac \
            apptee. ! queue ! audioconvert ! appsink name=appsink0 caps=\"audio/x-raw,format=F32LE,channels=2\"",
            record_config.audio.alsa_device,
            record_config.audio.rate,
            record_config.output.directory,
            record_config.output.prefix);

        println!("{}", pipeline_str);

        let pipeline = gst::Pipeline::new_from_str(&pipeline_str).unwrap();
        let mainloop = gst::MainLoop::new();
        let mut bus = pipeline.bus().expect("Couldn't get bus from pipeline");
        let bus_receiver = bus.receiver();
        let appsink_element = pipeline
            .get_by_name("appsink0")
            .expect("Couldn't get appsink from pipeline");
        let appsink = gst::AppSink::new_from_element(appsink_element);

        RecordingPipeline {
            pipeline : pipeline,
            mainloop : mainloop,
            bus_receiver : bus_receiver,
            appsink : appsink,
        }
    }


    pub fn start(&mut self) {
        self.mainloop.spawn();
        self.pipeline.play();
    }


    pub fn stop(&mut self) {
        self.pipeline.set_null_state();
        self.mainloop.quit();
    }


    pub fn handle_events(&mut self) -> bool {
        while let Ok(msg) = self.bus_receiver.try_recv() {
            match msg.parse() {
                gst::Message::StateChangedParsed { ref old, ref new, .. } => {
                    println!("element `{}` changed from {:?} to {:?}",
                                msg.src_name(), old, new);
                }
                gst::Message::ErrorParsed {ref error, ref debug, .. } => {
                    println!("error msg from element `{}`: {}, {}. Quitting",
                                msg.src_name(), error.message(), debug);
                    return false;
                }
                _ => {
                    println!("msg of type `{}` from element `{}`",
                                msg.type_name(), msg.src_name());
                }
            }
        }
        return true;
    }


    pub fn get_max_samples(&mut self) -> Result<(f32, f32), &str>{
        match self.appsink.try_recv() {
            Ok(gst::appsink::Message::NewSample(sample))
                | Ok(gst::appsink::Message::NewPreroll(sample)) => {
                if let Some(buffer) = sample.buffer() {
                    let (max0, max1) = buffer.map_read(|mapping| {
                        mapping.iter::<f32>().tuples().fold((0.0f32, 0.0f32), |(acc0, acc1), (sample0, sample1)| {
                            (acc0.max(sample0.abs()), acc1.max(sample1.abs()))
                        })
                    }).unwrap();
                    return Ok((max0, max1));
                }
                return Err("Unable to access samples");
            }
            Ok(gst::appsink::Message::Eos) => {
                return Err("Got no sample when polling. EOS");
            }
            Err(mpsc::TryRecvError::Empty) => {
                return Ok((0.0f32,0.0f32));
            }
            Err(mpsc::TryRecvError::Disconnected) => {
                return Err("Appsink got disconnected")
            }
        }
    }
}