use crate::*;

mod port_audio_out; pub use self::port_audio_out::*;
mod port_audio_in;  pub use self::port_audio_in::*;
mod port_midi_out;  pub use self::port_midi_out::*;
mod port_midi_in;   pub use self::port_midi_in::*;
pub(crate) use ConnectName::*;
pub(crate) use ConnectScope::*;
pub(crate) use ConnectStatus::*;

pub trait RegisterPorts: 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>> RegisterPorts 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> {
    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 port_name (&self) -> &Arc<str>;
    fn connections (&self) -> &[Connect];
    fn port (&self) -> &Port<Self::Port>;
    fn port_mut (&mut self) -> &mut Port<Self::Port>;
    fn into_port (self) -> Port<Self::Port> where Self: Sized;
    fn close (self) -> Usually<()> where Self: Sized {
        let jack = self.jack().clone();
        Ok(jack.with_client(|c|c.unregister_port(self.into_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 connect_to_matching <'k> (&'k self) -> Usually<()> {
        for connect in self.connections().iter() {
            //panic!("{connect:?}");
            let status = match &connect.name {
                Exact(name) => self.connect_exact(name),
                RegExp(re)  => self.connect_regexp(re, connect.scope),
            }?;
            *connect.status.write().unwrap() = status;
        }
        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: 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 == 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
        }))
    }
}

#[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,
}

#[derive(Clone, Debug)] pub struct Connect {
    pub name:   ConnectName,
    pub scope:  ConnectScope,
    pub status: Arc<RwLock<Vec<(Port<Unowned>, Arc<str>, ConnectStatus)>>>,
    pub info:   Arc<String>,
}

impl Connect {
    pub fn collect (exact: &[impl AsRef<str>], re: &[impl AsRef<str>], re_all: &[impl AsRef<str>])
        -> Vec<Self>
    {
        let mut connections = vec![];
        for port in exact.iter()  { connections.push(Self::exact(port)) }
        for port in re.iter()     { connections.push(Self::regexp(port)) }
        for port in re_all.iter() { 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 = Exact(name.as_ref().into());
        Self { name, scope: 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 = RegExp(name.as_ref().into());
        Self { name, scope: 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 = RegExp(name.as_ref().into());
        Self { name, scope: All, status: Arc::new(RwLock::new(vec![])), info }
    }
    pub fn info (&self) -> Arc<str> {
        let status = {
            let status = self.status.read().unwrap();
            let mut ok = 0;
            for (_, _, state) in status.iter() {
                if *state == Connected {
                    ok += 1
                }
            }
            format!("{ok}/{}", status.len())
        };
        let scope  = match self.scope {
            One => " ", All => "*",
        };
        let name   = match &self.name {
            Exact(name) => format!("= {name}"), RegExp(name) => format!("~ {name}"),
        };
        format!(" ({}) {} {}", status, scope, name).into()
    }
}