use crate::*;

pub struct TransportAudio {
    model: Transport
}

impl From<&Arc<RwLock<Transport>>> for TransportAudio {
    fn from (model: &Arc<RwLock<Transport>>) -> Self {
        Self { model: model.clone() }
    }
}

impl Audio for Transport {
    fn process (&mut self, _: &Client, scope: &ProcessScope) -> Control {
        let times       = scope.cycle_times().unwrap();
        let CycleTimes { current_frames, current_usecs, next_usecs: _, period_usecs: _ } = times;
        let _chunk_size = scope.n_frames() as usize;
        let transport   = self.transport.query().unwrap();
        self.clock.current.sample.set(transport.pos.frame() as f64);
        let mut playing = self.clock.playing.write().unwrap();
        let mut started = self.clock.started.write().unwrap();
        if *playing != Some(transport.state) {
            match transport.state {
                TransportState::Rolling => {
                    *started = Some((current_frames as usize, current_usecs as usize))
                },
                TransportState::Stopped => {
                    *started = None
                },
                _ => {}
            }
        };
        *playing = Some(transport.state);
        if *playing == Some(TransportState::Stopped) {
            *started = None;
        }
        self.clock.current.update_from_usec(match *started {
            Some((_, usecs)) => current_usecs as f64 - usecs as f64,
            None => 0.
        });
        Control::Continue
    }
}