use crate::{*, time::PerfModel};
pub use ::jack::{*, contrib::{*, ClosureProcessHandler}};
pub use ::midly::{Smf, TrackEventKind, MidiMessage, Error as MidiError, num::*, live::*};
use ConnectName::*;
use ConnectScope::*;
use ConnectStatus::*;
use JackState::*;

/// Wraps [JackState], and through it [jack::Client] when connected.
///
/// ```
/// let jack = tengri::Jack::default();
/// ```
#[derive(Clone, Debug, Default)] pub struct Jack<'j> (
    pub(crate) Arc<RwLock<JackState<'j>>>
);

/// This is a connection which may be [Inactive], [Activating], or [Active].
/// In the [Active] and [Inactive] states, [JackState::client] returns a
/// [jack::Client], which you can use to talk to the JACK API.
///
/// ```
/// let state = tengri::JackState::default();
/// ```
#[derive(Debug, Default)] pub enum JackState<'j> {
    /// Unused
    #[default] Inert,
    /// Before activation.
    Inactive(Client),
    /// During activation.
    Activating,
    /// After activation. Must not be dropped for JACK thread to persist.
    Active(DynamicAsyncClient<'j>),
}

/// Implement [Jack] constructor and methods
impl<'j> Jack<'j> {
    /// Register new [Client] and wrap it for shared use.
    pub fn new_run <T: HasJack<'j> + Audio + Send + Sync + 'static> (
        name: impl AsRef<str>,
        init: impl FnOnce(Jack<'j>)->Usually<T>
    ) -> Usually<Arc<RwLock<T>>> {
        Jack::new(name)?.run(init)
    }
    pub fn new (name: impl AsRef<str>) -> Usually<Self> {
        let client = Client::new(name.as_ref(), ClientOptions::NO_START_SERVER)?.0;
        Ok(Jack(Arc::new(RwLock::new(JackState::Inactive(client)))))
    }
    /// Run something with the client.
    pub fn with_client <T> (&self, op: impl FnOnce(&Client)->T) -> T {
        match &*self.0.read().unwrap() {
            Inert            => panic!("jack client not activated"),
            Inactive(client) => op(client),
            Activating       => panic!("jack client has not finished activation"),
            Active(client)   => op(client.as_client()),
        }
    }
    pub fn run <T: HasJack<'j> + Audio + Send + Sync + 'static>
        (self, init: impl FnOnce(Self)->Usually<T>) -> Usually<Arc<RwLock<T>>>
    {
        let client_state = self.0.clone();
        let app: Arc<RwLock<T>> = Arc::new(RwLock::new(init(self)?));
        let mut state = Activating;
        std::mem::swap(&mut*client_state.write().unwrap(), &mut state);
        if let Inactive(client) = state {
            // This is the misc notifications handler. It's a struct that wraps a [Box]
            // which performs type erasure on a callback that takes [JackEvent], which is
            // one of the available misc notifications.
            let notify = JackNotify(Box::new({
                let app = app.clone();
                move|event|(&mut*app.write().unwrap()).handle(event)
            }) as BoxedJackEventHandler);
            // This is the main processing handler. It's a struct that wraps a [Box]
            // which performs type erasure on a callback that takes [Client] and [ProcessScope]
            // and passes them down to the `app`'s `process` callback, which in turn
            // implements audio and MIDI input and output on a realtime basis.
            let process = ::jack::contrib::ClosureProcessHandler::new(Box::new({
                let app = app.clone();
                move|c: &_, s: &_|if let Ok(mut app) = app.write() {
                    app.process(c, s)
                } else {
                    Control::Quit
                }
            }) as BoxedAudioHandler);
            // Launch a client with the two handlers.
            *client_state.write().unwrap() = Active(
                client.activate_async(notify, process)?
            );
        } else {
            unreachable!();
        }
        Ok(app)
    }
}

impl<'j> HasJack<'j> for Jack<'j> {
    fn jack (&self) -> &Jack<'j> {
        self
    }
}

impl<'j> HasJack<'j> for &Jack<'j> {
    fn jack (&self) -> &Jack<'j> {
        self
    }
}

impl<'j, T: HasJack<'j>> HasJack<'j> for Arc<T> {
    fn jack (&self) -> &Jack<'j> {
        (&**self).jack()
    }
}

/// Event enum for JACK events.
///
/// ```
/// let event = tengri::JackEvent::XRun; // kerpop
/// ```
#[derive(Debug, Clone, PartialEq)] pub enum JackEvent {
    ThreadInit,
    Shutdown(ClientStatus, Arc<str>),
    Freewheel(bool),
    SampleRate(Frames),
    ClientRegistration(Arc<str>, bool),
    PortRegistration(PortId, bool),
    PortRename(PortId, Arc<str>, Arc<str>),
    PortsConnected(PortId, PortId, bool),
    GraphReorder,
    XRun,
}

/// Generic notification handler that emits [JackEvent]
///
/// ```
/// let notify = tengri::JackNotify(|_|{});
/// ```
pub struct JackNotify<T: Fn(JackEvent) + Send>(pub T);

/// Notification handler wrapper for [BoxedJackEventHandler].
pub type DynamicNotifications<'j> =
    JackNotify<BoxedJackEventHandler<'j>>;

/// Boxed [JackEvent] callback.
pub type BoxedJackEventHandler<'j> =
    Box<dyn Fn(JackEvent) + Send + Sync + 'j>;

impl<T: Fn(JackEvent) + Send> NotificationHandler for JackNotify<T> {
    fn thread_init(&self, _: &Client) {
        self.0(JackEvent::ThreadInit);
    }
    unsafe fn shutdown(&mut self, status: ClientStatus, reason: &str) {
        self.0(JackEvent::Shutdown(status, reason.into()));
    }
    fn freewheel(&mut self, _: &Client, enabled: bool) {
        self.0(JackEvent::Freewheel(enabled));
    }
    fn sample_rate(&mut self, _: &Client, frames: Frames) -> Control {
        self.0(JackEvent::SampleRate(frames));
        Control::Quit
    }
    fn client_registration(&mut self, _: &Client, name: &str, reg: bool) {
        self.0(JackEvent::ClientRegistration(name.into(), reg));
    }
    fn port_registration(&mut self, _: &Client, id: PortId, reg: bool) {
        self.0(JackEvent::PortRegistration(id, reg));
    }
    fn port_rename(&mut self, _: &Client, id: PortId, old: &str, new: &str) -> Control {
        self.0(JackEvent::PortRename(id, old.into(), new.into()));
        Control::Continue
    }
    fn ports_connected(&mut self, _: &Client, a: PortId, b: PortId, are: bool) {
        self.0(JackEvent::PortsConnected(a, b, are));
    }
    fn graph_reorder(&mut self, _: &Client) -> Control {
        self.0(JackEvent::GraphReorder);
        Control::Continue
    }
    fn xrun(&mut self, _: &Client) -> Control {
        self.0(JackEvent::XRun);
        Control::Continue
    }
}

pub trait JackPerfModel {
    fn update_from_jack_scope (&self, t0: Option<u64>, scope: &ProcessScope);
}

impl JackPerfModel for PerfModel {
    fn update_from_jack_scope (&self, t0: Option<u64>, scope: &ProcessScope) {
        if let Some(t0) = t0 {
            let t1 = self.clock.raw();
            self.used.store(
                self.clock.delta_as_nanos(t0, t1) as f64,
                Relaxed,
            );
            self.window.store(
                scope.cycle_times().unwrap().period_usecs as f64,
                Relaxed,
            );
        }
    }
}

/// Trait for thing that has a JACK process callback.
pub trait Audio {
    /// Handle a JACK event.
    fn handle (&mut self, _event: JackEvent) {}
    /// Projecss a JACK chunk.
    fn process (&mut self, _: &Client, _: &ProcessScope) -> Control {
        Control::Continue
    }
    /// The JACK process callback function passed to the server.
    fn callback (
        state: &Arc<RwLock<Self>>, client: &Client, scope: &ProcessScope
    ) -> Control where Self: Sized {
        if let Ok(mut state) = state.write() {
            state.process(client, scope)
        } else {
            Control::Quit
        }
    }
}

/// Running JACK [AsyncClient] with maximum type erasure.
///
/// One [Box] contains function that handles [JackEvent]s.
///
/// Another [Box] containing a function that handles realtime IO.
///
/// That's all it knows about them.
pub type DynamicAsyncClient<'j>
    = AsyncClient<DynamicNotifications<'j>, DynamicAudioHandler<'j>>;

/// Notification handler wrapper for [BoxedAudioHandler].
pub type DynamicAudioHandler<'j> =
    ::jack::contrib::ClosureProcessHandler<(), BoxedAudioHandler<'j>>;

/// Boxed realtime callback.
pub type BoxedAudioHandler<'j> =
    Box<dyn FnMut(&Client, &ProcessScope) -> Control + Send + Sync + 'j>;

/// Things that can provide a [jack::Client] reference.
///
/// ```
/// use tengri::*;
///
/// let jack: &Jack = Jacked::default().jack();
///
/// #[derive(Default)] struct Jacked<'j>(Jack<'j>);
///
/// impl<'j> HasJack<'j> for Jacked<'j> {
///     fn jack (&self) -> &Jack<'j> { &self.0 }
/// }
/// ```
pub trait HasJack<'j>: Send + Sync {
    /// Return the internal [jack::Client] handle
    /// that lets you call the JACK API.
    fn jack (&self) -> &Jack<'j>;
    fn with_client <T> (&self, op: impl FnOnce(&Client)->T) -> T {
        self.jack().with_client(op)
    }
    fn port_by_name (&self, name: &str) -> Option<Port<Unowned>> {
        self.with_client(|client|client.port_by_name(name))
    }
    fn port_by_id (&self, id: u32) -> Option<Port<Unowned>> {
        self.with_client(|c|c.port_by_id(id))
    }
    fn register_port <PS: PortSpec + Default> (&self, name: impl AsRef<str>) -> Usually<Port<PS>> {
        self.with_client(|client|Ok(client.register_port(name.as_ref(), PS::default())?))
    }
    fn sync_lead (&self, enable: bool, callback: impl Fn(TimebaseInfo)->jack::contrib::Position)
        -> Usually<()>
    {
        if enable {
            self.with_client(|client|match client.register_timebase_callback(false, callback) {
               Ok(_) => Ok(()),
                Err(e) => Err(e)
            })?
        }
        Ok(())
    }
    fn sync_follow (&self, _enable: bool) -> Usually<()> {
        // TODO: sync follow
        Ok(())
    }
}

/// Implement [Audio]: provide JACK callbacks.
#[macro_export] macro_rules! impl_audio {
    (|
        $self1:ident:
        $Struct:ident$(<$($L:lifetime),*$($T:ident$(:$U:path)?),*>)?,$c:ident,$s:ident
    |$cb:expr$(;|$self2:ident,$e:ident|$cb2:expr)?) => {
        impl $(<$($L),*$($T $(: $U)?),*>)? Audio for $Struct $(<$($L),*$($T),*>)? {
            #[inline] fn process (&mut $self1, $c: &Client, $s: &ProcessScope) -> Control { $cb }
            $(#[inline] fn handle (&mut $self2, $e: JackEvent) { $cb2 })?
        }
    };

    ($Struct:ident: $process:ident, $handle:ident) => {
        impl Audio for $Struct {
            #[inline] fn process (&mut self, c: &Client, s: &ProcessScope) -> Control {
                $process(self, c, s)
            }
            #[inline] fn handle (&mut self, e: JackEvent) {
                $handle(self, e)
            }
        }
    };

    ($Struct:ident: $process:ident) => {
        impl Audio for $Struct {
            #[inline] fn process (&mut self, c: &Client, s: &ProcessScope) -> Control {
                $process(self, c, s)
            }
        }
    };
}

pub trait JackPorts: HasJack<'static> {
    /// Register a MIDI input port.
    fn midi_in (&self, name: &impl AsRef<str>, connect: &[Connect]) -> Usually<MidiInput>;
    /// Register a MIDI output port.
    fn midi_out (&self, name: &impl AsRef<str>, connect: &[Connect]) -> Usually<MidiOutput>;
    /// Register an audio input port.
    fn audio_in (&self, name: &impl AsRef<str>, connect: &[Connect]) -> Usually<AudioInput>;
    /// Register an audio output port.
    fn audio_out (&self, name: &impl AsRef<str>, connect: &[Connect]) -> Usually<AudioOutput>;
}

impl<J: HasJack<'static>> JackPorts for J {
    fn midi_in (&self, name: &impl AsRef<str>, connect: &[Connect]) -> Usually<MidiInput> {
        MidiInput::new(self.jack(), name, connect)
    }
    fn midi_out (&self, name: &impl AsRef<str>, connect: &[Connect]) -> Usually<MidiOutput> {
        MidiOutput::new(self.jack(), name, connect)
    }
    fn audio_in (&self, name: &impl AsRef<str>, connect: &[Connect]) -> Usually<AudioInput> {
        AudioInput::new(self.jack(), name, connect)
    }
    fn audio_out (&self, name: &impl AsRef<str>, connect: &[Connect]) -> Usually<AudioOutput> {
        AudioOutput::new(self.jack(), name, connect)
    }
}

pub trait JackPort: HasJack<'static> {
    const KIND: &'static str = "Port";
    type Port: PortSpec + Default;
    type Pair: PortSpec + Default;

    fn new (jack: &Jack<'static>, name: &impl AsRef<str>, connect: &[Connect])
        -> Usually<Self> where Self: Sized;

    fn register (jack: &Jack<'static>, name: &impl AsRef<str>) -> Usually<Port<Self::Port>> {
        jack.with_client(|c|c.register_port::<Self::Port>(name.as_ref(), Default::default()))
            .map_err(|e|e.into())
    }

    fn close (self) -> Usually<()> where Self: Sized {
        let jack = self.jack().clone();
        Ok(jack.with_client(|c|c.unregister_port(self.into_port()))?)
    }

    fn into_port (self) -> Port<Self::Port> where Self: Sized;
    fn port_name (&self) -> &Arc<str>;
    fn port (&self) -> &Port<Self::Port>;
    fn port_mut (&mut self) -> &mut Port<Self::Port>;
    fn ports (&self, re_name: Option<&str>, re_type: Option<&str>, flags: PortFlags) -> Vec<String> {
        self.with_client(|c|c.ports(re_name, re_type, flags))
    }
    fn port_by_id (&self, id: u32) -> Option<Port<Unowned>> {
        self.with_client(|c|c.port_by_id(id))
    }
    fn port_by_name (&self, name: impl AsRef<str>) -> Option<Port<Unowned>> {
        self.with_client(|c|c.port_by_name(name.as_ref()))
    }

    fn connections (&self) -> &[Connect];
    fn connect_to_matching <'k> (&'k self) -> Usually<()> {
        for connect in self.connections().iter() {
            match &connect.name {
                Some(Exact(name)) => {
                    *connect.status.write().unwrap() = self.connect_exact(name)?;
                },
                Some(RegExp(re))  => {
                    *connect.status.write().unwrap() = self.connect_regexp(re, connect.scope)?;
                },
                _ => {},
            };
        }
        Ok(())
    }
    fn connect_exact <'k> (&'k self, name: &str) ->
        Usually<Vec<(Port<Unowned>, Arc<str>, ConnectStatus)>>
    {
        self.with_client(move|c|{
            let mut status = vec![];
            for port in c.ports(None, None, PortFlags::empty()).iter() {
                if port.as_str() == &*name {
                    if let Some(port) = c.port_by_name(port.as_str()) {
                        let port_status = self.connect_to_unowned(&port)?;
                        let name = port.name()?.into();
                        status.push((port, name, port_status));
                        if port_status == Connected {
                            break
                        }
                    }
                }
            }
            Ok(status)
        })
    }
    fn connect_regexp <'k> (
        &'k self, re: &str, scope: Option<ConnectScope>
    ) -> Usually<Vec<(Port<Unowned>, Arc<str>, ConnectStatus)>> {
        self.with_client(move|c|{
            let mut status = vec![];
            let ports = c.ports(Some(&re), None, PortFlags::empty());
            for port in ports.iter() {
                if let Some(port) = c.port_by_name(port.as_str()) {
                    let port_status = self.connect_to_unowned(&port)?;
                    let name = port.name()?.into();
                    status.push((port, name, port_status));
                    if port_status == Connected && scope == Some(One) {
                        break
                    }
                }
            }
            Ok(status)
        })
    }
    /** Connect to a matching port by name. */
    fn connect_to_name (&self, name: impl AsRef<str>) -> Usually<ConnectStatus> {
        self.with_client(|c|if let Some(ref port) = c.port_by_name(name.as_ref()) {
            self.connect_to_unowned(port)
        } else {
            Ok(Missing)
        })
    }
    /** Connect to a matching port by reference. */
    fn connect_to_unowned (&self, port: &Port<Unowned>) -> Usually<ConnectStatus> {
        self.with_client(|c|Ok(if let Ok(_) = c.connect_ports(self.port(), port) {
            Connected
        } else if let Ok(_) = c.connect_ports(port, self.port()) {
            Connected
        } else {
            Mismatch
        }))
    }
    /** Connect to an owned matching port by reference. */
    fn connect_to_owned (&self, port: &Port<Self::Pair>) -> Usually<ConnectStatus> {
        self.with_client(|c|Ok(if let Ok(_) = c.connect_ports(self.port(), port) {
            Connected
        } else if let Ok(_) = c.connect_ports(port, self.port()) {
            Connected
        } else {
            Mismatch
        }))
    }
}

/// Audio input port.
#[derive(Debug)] pub struct AudioInput {
    /// Handle to JACK client, for receiving reconnect events.
    pub jack: Jack<'static>,
    /// Port name
    pub name: Arc<str>,
    /// Port handle.
    pub port: Port<AudioIn>,
    /// List of ports to connect to.
    pub connections: Vec<Connect>,
}

/// Audio output port.
#[derive(Debug)] pub struct AudioOutput {
    /// Handle to JACK client, for receiving reconnect events.
    pub jack: Jack<'static>,
    /// Port name
    pub name: Arc<str>,
    /// Port handle.
    pub port: Port<AudioOut>,
    /// List of ports to connect to.
    pub connections: Vec<Connect>,
}

/// MIDI input port.
#[derive(Debug)] pub struct MidiInput {
    /// Handle to JACK client, for receiving reconnect events.
    pub jack: Jack<'static>,
    /// Port name
    pub name: Arc<str>,
    /// Port handle.
    pub port: Port<MidiIn>,
    /// List of currently held notes.
    pub held: Arc<RwLock<[bool;128]>>,
    /// List of ports to connect to.
    pub connections: Vec<Connect>,
}

/// MIDI output port.
#[derive(Debug)] pub struct MidiOutput {
    /// Handle to JACK client, for receiving reconnect events.
    pub jack: Jack<'static>,
    /// Port name
    pub name: Arc<str>,
    /// Port handle.
    pub port: Port<MidiOut>,
    /// List of currently held notes.
    pub held: Arc<RwLock<[bool;128]>>,
    /// List of ports to connect to.
    pub connections: Vec<Connect>,
    /// Buffer
    pub note_buffer: Vec<u8>,
    /// Buffer
    pub output_buffer: Vec<Vec<Vec<u8>>>,
}

macro_rules! jack_port {
    ($($Struct:ty = ($Port:ty => $Pair:ty) $({ $($tt:tt)* })?),*) => {
        $(
            impl HasJack<'static> for $Struct {
                fn jack (&self) -> &Jack<'static> { &self.jack }
            }
            impl JackPort for $Struct {
                type Port = $Port;
                type Pair = $Pair;
                fn port_name (&self) -> &Arc<str> {
                    &self.name
                }
                fn port (&self) -> &Port<Self::Port> {
                    &self.port
                }
                fn port_mut (&mut self) -> &mut Port<Self::Port> {
                    &mut self.port
                }
                fn into_port (self) -> Port<Self::Port> {
                    self.port
                }
                fn connections (&self) -> &[Connect] {
                    self.connections.as_slice()
                }
                $($($tt)*)?
            }
        )*
    };
}

jack_port!(
    AudioInput  = (AudioIn => AudioOut) {
        const KIND: &'static str = "Audio In";
        fn new (jack: &Jack<'static>, name: &impl AsRef<str>, connect: &[Connect])
            -> Usually<Self> where Self: Sized
        {
            let port = Self {
                port: Self::register(jack, name)?,
                jack: jack.clone(),
                name: name.as_ref().into(),
                connections: connect.to_vec(),
            };
            port.connect_to_matching()?;
            Ok(port)
        }
    },

    AudioOutput = (AudioOut => AudioIn) {
        const KIND: &'static str = "Audio Out";
        fn new (jack: &Jack<'static>, name: &impl AsRef<str>, connect: &[Connect])
            -> Usually<Self> where Self: Sized
        {
            let port = Self {
                port: Self::register(jack, name)?,
                jack: jack.clone(),
                name: name.as_ref().into(),
                connections: connect.to_vec(),
            };
            port.connect_to_matching()?;
            Ok(port)
        }
    },

    MidiInput   = (MidiIn => MidiOut) {
        const KIND: &'static str = "MIDI In";
        fn new (jack: &Jack<'static>, name: &impl AsRef<str>, connect: &[Connect])
            -> Usually<Self> where Self: Sized
        {
            let port = Self {
                port: Self::register(jack, name)?,
                jack: jack.clone(),
                name: name.as_ref().into(),
                connections: connect.to_vec(),
                held: Arc::new(RwLock::new([false;128]))
            };
            port.connect_to_matching()?;
            Ok(port)
        }
    },

    MidiOutput  = (MidiOut => MidiIn) {
        const KIND: &'static str = "MIDI Out";
        fn new (jack: &Jack<'static>, name: &impl AsRef<str>, connect: &[Connect])
            -> Usually<Self> where Self: Sized
        {
            let port = Self::register(jack, name)?;
            let jack = jack.clone();
            let name = name.as_ref().into();
            let connections = connect.to_vec();
            let port = Self {
                jack,
                port,
                name,
                connections,
                held: Arc::new([false;128].into()),
                note_buffer: vec![0;8],
                output_buffer: vec![vec![];65536],
            };
            port.connect_to_matching()?;
            Ok(port)
        }
    }
);

pub type CollectedMidiInput<'a> = Vec<Vec<(u32, Result<LiveEvent<'a>, MidiError>)>>;

/// Trait for thing that may receive MIDI.
pub trait HasMidiIns {
    fn midi_ins (&self) -> &Vec<MidiInput>;
    fn midi_ins_mut (&mut self) -> &mut Vec<MidiInput>;
    /// Collect MIDI input from app ports (TODO preallocate large buffers)
    fn midi_input_collect <'a> (&'a self, scope: &'a ProcessScope) -> CollectedMidiInput<'a> {
        self.midi_ins().iter()
            .map(|port|port.port().iter(scope)
                .map(|RawMidi { time, bytes }|(time, LiveEvent::parse(bytes)))
                .collect::<Vec<_>>())
            .collect::<Vec<_>>()
    }
    fn midi_ins_with_sizes <'a> (&'a self) ->
        impl Iterator<Item=(usize, &'a Arc<str>, &'a [Connect], usize, usize)> + Send + Sync + 'a
    {
        let mut y = 0;
        self.midi_ins().iter().enumerate().map(move|(i, input)|{
            let height = 1 + input.connections().len();
            let data   = (i, input.port_name(), input.connections(), y, y + height);
            y += height;
            data
        })
    }
}
/// Trait for thing that may output MIDI.
pub trait HasMidiOuts {
    fn midi_outs (&self) -> &Vec<MidiOutput>;
    fn midi_outs_mut (&mut self) -> &mut Vec<MidiOutput>;
    fn midi_outs_with_sizes <'a> (&'a self) ->
        impl Iterator<Item=(usize, &'a Arc<str>, &'a [Connect], usize, usize)> + Send + Sync + 'a
    {
        let mut y = 0;
        self.midi_outs().iter().enumerate().map(move|(i, output)|{
            let height = 1 + output.connections().len();
            let data   = (i, output.port_name(), output.connections(), y, y + height);
            y += height;
            data
        })
    }
    fn midi_outs_emit (&mut self, scope: &ProcessScope) {
        for port in self.midi_outs_mut().iter_mut() {
            port.buffer_emit(scope)
        }
    }
}

impl MidiOutput {
    /// Clear the section of the output buffer that we will be using,
    /// emitting "all notes off" at start of buffer if requested.
    pub fn buffer_clear (&mut self, scope: &ProcessScope, reset: bool) {
        let n_frames = (scope.n_frames() as usize).min(self.output_buffer.len());
        for frame in &mut self.output_buffer[0..n_frames] {
            frame.clear();
        }
        if reset {
            all_notes_off(&mut self.output_buffer);
        }
    }
    /// Write a note to the output buffer
    pub fn buffer_write <'a> (
        &'a mut self,
        sample: usize,
        event:  LiveEvent,
    ) {
        self.note_buffer.fill(0);
        event.write(&mut self.note_buffer).expect("failed to serialize MIDI event");
        self.output_buffer[sample].push(self.note_buffer.clone());
        // Update the list of currently held notes.
        if let LiveEvent::Midi { ref message, .. } = event {
            update_keys(&mut*self.held.write().unwrap(), message);
        }
    }
    /// Write a chunk of MIDI data from the output buffer to the output port.
    pub fn buffer_emit (&mut self, scope: &ProcessScope) {
        let samples = scope.n_frames() as usize;
        let mut writer = self.port.writer(scope);
        for (time, events) in self.output_buffer.iter().enumerate().take(samples) {
            for bytes in events.iter() {
                writer.write(&RawMidi { time: time as u32, bytes }).unwrap_or_else(|_|{
                    panic!("Failed to write MIDI data: {bytes:?}");
                });
            }
        }
    }
}

impl MidiInput {
    pub fn parsed <'a> (&'a self, scope: &'a ProcessScope) -> impl Iterator<Item=(usize, LiveEvent<'a>, &'a [u8])> {
        parse_midi_input(self.port().iter(scope))
    }
}

/// Return boxed iterator of MIDI events
pub fn parse_midi_input <'a> (input: ::jack::MidiIter<'a>)
    -> Box<dyn Iterator<Item=(usize, LiveEvent<'a>, &'a [u8])> + 'a>
{
    Box::new(input.map(|::jack::RawMidi { time, bytes }|(
        time as usize,
        LiveEvent::parse(bytes).unwrap(),
        bytes
    )))
}

/// Add "all notes off" to the start of a buffer.
pub fn all_notes_off (output: &mut [Vec<Vec<u8>>]) {
    let mut buf = vec![];
    let msg = MidiMessage::Controller { controller: 123.into(), value: 0.into() };
    let evt = LiveEvent::Midi { channel: 0.into(), message: msg };
    evt.write(&mut buf).unwrap();
    output[0].push(buf);
}

/// Update notes_in array
pub fn update_keys (keys: &mut[bool;128], message: &MidiMessage) {
    match message {
        MidiMessage::NoteOn  { key, .. } => { keys[key.as_int() as usize] = true; }
        MidiMessage::NoteOff { key, .. } => { keys[key.as_int() as usize] = false; },
        _ => {}
    }
}

impl<T: AsRef<Vec<MidiInput>> + AsMut<Vec<MidiInput>>> HasMidiIns for T {
    fn midi_ins (&self) -> &Vec<MidiInput> { self.as_ref() }
    fn midi_ins_mut (&mut self) -> &mut Vec<MidiInput> { self.as_mut() }
}

impl<T: AsRef<Vec<MidiOutput>> + AsMut<Vec<MidiOutput>>> HasMidiOuts for T {
    fn midi_outs (&self) -> &Vec<MidiOutput> { self.as_ref() }
    fn midi_outs_mut (&mut self) -> &mut Vec<MidiOutput> { self.as_mut() }
}

impl<T: HasMidiIns + HasJack<'static>> AddMidiIn for T {
    fn midi_in_add (&mut self) -> Usually<()> {
        let index = self.midi_ins().len();
        let port  = MidiInput::new(self.jack(), &format!("M/{index}"), &[])?;
        self.midi_ins_mut().push(port);
        Ok(())
    }
}

/// Trail for thing that may gain new MIDI ports.
impl<T: HasMidiOuts + HasJack<'static>> AddMidiOut for T {
    fn midi_out_add (&mut self) -> Usually<()> {
        let index = self.midi_outs().len();
        let port  = MidiOutput::new(self.jack(), &format!("{index}/M"), &[])?;
        self.midi_outs_mut().push(port);
        Ok(())
    }
}

/// May create new MIDI input ports.
pub trait AddMidiIn {
    fn midi_in_add (&mut self) -> Usually<()>;
}

/// May create new MIDI output ports.
pub trait AddMidiOut {
    fn midi_out_add (&mut self) -> Usually<()>;
}

#[derive(Clone, Debug, PartialEq)] pub enum ConnectName {
    /** Exact match */
    Exact(Arc<str>),
    /** Match regular expression */
    RegExp(Arc<str>),
}

#[derive(Clone, Copy, Debug, PartialEq)] pub enum ConnectScope {
    One,
    All
}

#[derive(Clone, Copy, Debug, PartialEq)] pub enum ConnectStatus {
    Missing,
    Disconnected,
    Connected,
    Mismatch,
}

/// Port connection manager.
///
/// ```
/// let connect = tengri::Connect::default();
/// ```
#[derive(Clone, Debug, Default)]
pub struct Connect {
    pub name:   Option<ConnectName>,
    pub scope:  Option<ConnectScope>,
    pub status: Arc<RwLock<Vec<(Port<Unowned>, Arc<str>, ConnectStatus)>>>,
    pub info:   Arc<str>,
}

impl Connect {
    pub fn new <T: AsRef<str>> (
        exact:  Option<impl Iterator<Item = T>>,
        re:     Option<impl Iterator<Item = T>>,
        re_all: Option<impl Iterator<Item = T>>,
    ) -> Vec<Self> {
        let mut connections = vec![];
        if let Some(exact ) = exact  { for port in exact  { connections.push(Self::exact(port))      } }
        if let Some(regexp) = re     { for port in regexp { connections.push(Self::regexp(port))     } }
        if let Some(re_all) = re_all { for port in re_all { connections.push(Self::regexp_all(port)) } }
        connections
    }

    /// Connect to this exact port
    pub fn exact (name: impl AsRef<str>) -> Self {
        let info = format!("=:{}", name.as_ref()).into();
        let name = Some(Exact(name.as_ref().into()));
        Self { name, scope: Some(One), status: Arc::new(RwLock::new(vec![])), info }
    }

    pub fn regexp (name: impl AsRef<str>) -> Self {
        let info = format!("~:{}", name.as_ref()).into();
        let name = Some(RegExp(name.as_ref().into()));
        Self { name, scope: Some(One), status: Arc::new(RwLock::new(vec![])), info }
    }

    pub fn regexp_all (name: impl AsRef<str>) -> Self {
        let info = format!("+:{}", name.as_ref()).into();
        let name = Some(RegExp(name.as_ref().into()));
        Self { name, scope: Some(All), status: Arc::new(RwLock::new(vec![])), info }
    }

    pub fn info (&self) -> Arc<str> {
        format!(" ({}) {} {}", {
            let status = self.status.read().unwrap();
            let mut ok = 0;
            for (_, _, state) in status.iter() {
                if *state == Connected {
                    ok += 1
                }
            }
            format!("{ok}/{}", status.len())
        }, match self.scope {
            None      => "x",
            Some(One) => " ",
            Some(All) => "*",
        }, match &self.name {
            None               => format!("x"),
            Some(Exact(name))  => format!("= {name}"),
            Some(RegExp(name)) => format!("~ {name}"),
        }).into()
    }
}

pub fn connect_midi_ins <T: AsRef<str>> (
    jack:         &Jack<'static>,
    name:         &T,
    midi_from:    &[T],
    midi_from_re: Option<&[T]>,
) -> Usually<Vec<MidiInput>> {
    Ok(Connect::new(
        Some(midi_from.into_iter()),
        Some([].into_iter()),
        midi_from_re.map(|x|x.into_iter())).iter().enumerate()
            .map(|(index, connect)|jack.midi_in(&format!("{}/{index}", name.as_ref()), &[connect.clone()]))
            .collect::<Result<_, _>>()?)
}

pub fn connect_midi_outs <T: AsRef<str>> (
    jack:         &Jack<'static>,
    name:         &T,
    midi_to:      &[T],
    midi_to_re:   Option<&[T]>,
) -> Usually<Vec<MidiOutput>> {
    Ok(Connect::new(
        Some(midi_to.into_iter()),
        Some([].into_iter()),
        midi_to_re.map(|x|x.into_iter())).iter().enumerate()
            .map(|(index, connect)|jack.midi_out(&format!("{index}/{}", name.as_ref()), &[connect.clone()]))
            .collect::<Result<_, _>>()?)
}

pub fn connect_audio_ins <T: AsRef<str>> (
    jack:          &Jack<'static>,
    name:          &T,
    audio_from:    &[T],
    audio_from_re: Option<&[T]>,
) -> Usually<Vec<AudioInput>> {
    Ok(Connect::new(
        Some(audio_from.into_iter()),
        Some([].into_iter()),
        audio_from_re.map(|x|x.into_iter())).iter().enumerate()
            .map(|(index, connect)|jack.audio_in(&format!("{}/{index}", name.as_ref()), &[connect.clone()]))
            .collect::<Result<_, _>>()?)
}

pub fn connect_audio_outs <T: AsRef<str>> (
    jack:        &Jack<'static>,
    name:        &T,
    audio_to:    &[T],
    audio_to_re: Option<&[T]>,
) -> Usually<Vec<AudioOutput>> {
    Ok(Connect::new(
        Some(audio_to.into_iter()),
        Some([].into_iter()),
        audio_to_re.map(|x|x.into_iter())).iter().enumerate()
            .map(|(index, connect)|jack.audio_out(&format!("{index}/{}", name.as_ref()), &[connect.clone()]))
            .collect::<Result<_, _>>()?)
}