use crate::*;
pub use ::jack::{*, contrib::{*, ClosureProcessHandler}};
/// Wraps [JackState] and through it [jack::Client] when connected.
#[derive(Clone, Debug, Default)]
pub struct Jack<'j>(Arc<RwLock<JackState<'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)))))
    }
    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 {
            let client = client.activate_async(
                // 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.
                Notifications(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.
                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),
            )?;
            *client_state.write().unwrap() = Active(client);
        } else {
            unreachable!();
        }
        Ok(app)
    }
    /// 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()),
        }
    }
}
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
    }
}
/// 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.
#[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>),
}
/// Things that can provide a [jack::Client] reference.
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)->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(())
    }
}
/// 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
        }
    }
}
/// Implement [Audio]: provide JACK callbacks.
#[macro_export] macro_rules! 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 })?
        }
    }
}
/// Event enum for JACK events.
#[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]
pub struct Notifications<T: Fn(JackEvent) + Send>(pub T);

impl<T: Fn(JackEvent) + Send> NotificationHandler for Notifications<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
    }
}

/// This is a running JACK [AsyncClient] with maximum type erasure.
/// It has one [Box] containing a function that handles [JackEvent]s,
/// and another [Box] containing a function that handles realtime IO,
/// and that's all it knows about them.
pub type DynamicAsyncClient<'j>
    = AsyncClient<DynamicNotifications<'j>, DynamicAudioHandler<'j>>;
/// This is the notification handler wrapper for a boxed realtime callback.
pub type DynamicAudioHandler<'j> =
    ClosureProcessHandler<(), BoxedAudioHandler<'j>>;
/// This is a boxed realtime callback.
pub type BoxedAudioHandler<'j> =
    Box<dyn FnMut(&Client, &ProcessScope) -> Control + Send + Sync + 'j>;
/// This is the notification handler wrapper for a boxed [JackEvent] callback.
pub type DynamicNotifications<'j> =
    Notifications<BoxedJackEventHandler<'j>>;
/// This is a boxed [JackEvent] callback.
pub type BoxedJackEventHandler<'j> =
    Box<dyn Fn(JackEvent) + Send + Sync + 'j>;
use self::JackState::*;