use crate::*;

pub struct SequencerAppAudio<'a>(&'a mut Transport, &'a mut MIDIPlayer);

/// JACK process callback for sequencer app
impl<'a> Audio for SequencerAppAudio<'a> {
    fn process (&mut self, client: &Client, scope: &ProcessScope) -> Control {
        if TransportAudio::from(&mut*self.0).process(client, scope) == Control::Quit {
            return Control::Quit
        }
        if MIDIPlayerAudio::from(&mut*self.1).process(client, scope) == Control::Quit {
            return Control::Quit
        }
        Control::Continue
    }
}

pub struct MIDIPlayerAudio<'a>(&'a mut MIDIPlayer);

impl<'a> From<&'a mut MIDIPlayer> for MIDIPlayerAudio<'a> {
    fn from (model: &'a mut MIDIPlayer) -> Self {
        Self(model)
    }
}

/// JACK process callback for a sequencer's phrase player/recorder.
impl<'a> Audio for MIDIPlayerAudio<'a> {
    fn process (&mut self, _: &Client, scope: &ProcessScope) -> Control {
        let has_midi_outputs = self.0.has_midi_outputs();
        let has_midi_inputs  = self.0.has_midi_inputs();
        // Clear output buffer(s)
        self.0.clear(scope, false);
        // Write chunk of phrase to output, handle switchover
        if self.0.play(scope) {
            self.0.switchover(scope);
        }
        if has_midi_inputs {
            if self.0.recording || self.0.monitoring {
                // Record and/or monitor input
                self.0.record(scope)
            } else if has_midi_outputs && self.0.monitoring {
                // Monitor input to output
                self.0.monitor(scope)
            }
        }
        // Write to output port(s)
        self.0.write(scope);
        Control::Continue
    }
}