mpdclient 0.2.0

use std::ffi::CString;

use mpdclient_sys::{
    mpd_count_db_songs, mpd_operator_MPD_OPERATOR_DEFAULT, mpd_response_finish,
    mpd_search_add_any_tag_constraint, mpd_search_add_base_constraint, mpd_search_add_db_songs,
    mpd_search_add_db_songs_to_playlist, mpd_search_add_expression,
    mpd_search_add_modified_since_constraint, mpd_search_add_position, mpd_search_add_sort_name,
    mpd_search_add_sort_tag, mpd_search_add_tag_constraint, mpd_search_add_uri_constraint,
    mpd_search_add_window, mpd_search_commit, mpd_search_db_songs, mpd_search_db_tags,
    mpd_search_queue_songs, mpd_searchcount_db_songs,
};

#[cfg(feature = "protocol_0_24")]
use mpdclient_sys::mpd_search_add_added_since_constraint;
const DEF_OP: u32 = mpd_operator_MPD_OPERATOR_DEFAULT;

use crate::{
    Tag,
    entity::{EntityReceiver, Song},
    error::Result,
};

use super::{Connection, Position, stats::Stats};

/// Intermediate to bundle MPD search functions.
pub struct Search<'a> {
    connection: &'a Connection,
}

impl<'a> Search<'a> {
    pub(super) fn new(connection: &'a Connection) -> Self {
        Self { connection }
    }

    /// Searches through the database of the MPD.
    ///
    /// # Errors
    ///
    /// Returns an [`Error::Mpd`](crate::Error::Mpd) if MPD returns an error.
    pub fn database(&self, exact: bool) -> Result<SongConstraints<'_>> {
        self.connection.get_bool_error(|| unsafe {
            mpd_search_db_songs(self.connection.connection(), exact)
        })?;
        Ok(SongConstraints {
            connection: self.connection,
        })
    }

    /// Searches through the database of the MPD and adds the results to the queue.
    ///
    /// # Errors
    ///
    /// Returns an [`Error::Mpd`](crate::Error::Mpd) if MPD returns an error.
    pub fn database_add(&self, exact: bool) -> Result<AddConstraint<'_>> {
        self.connection.get_bool_error(|| unsafe {
            mpd_search_add_db_songs(self.connection.connection(), exact)
        })?;
        Ok(AddConstraint {
            connection: self.connection,
        })
    }

    /// Searches through the database of the MPD and adds the results to a playlist.
    ///
    /// # Errors
    ///
    /// Returns an [`Error::Mpd`](crate::Error::Mpd) if MPD returns an error.
    pub fn database_add_playlist(&self, name: &str) -> Result<AddConstraint<'_>> {
        let cname = CString::new(name)?;
        self.connection.get_bool_error(|| unsafe {
            mpd_search_add_db_songs_to_playlist(self.connection.connection(), cname.as_ptr())
        })?;
        Ok(AddConstraint {
            connection: self.connection,
        })
    }

    /// Searches through the current queue.
    ///
    /// # Errors
    ///
    /// Returns an [`Error::Mpd`](crate::Error::Mpd) if MPD returns an error.
    pub fn queue(&self, exact: bool) -> Result<SongConstraints<'_>> {
        self.connection.get_bool_error(|| unsafe {
            mpd_search_queue_songs(self.connection.connection(), exact)
        })?;
        Ok(SongConstraints {
            connection: self.connection,
        })
    }

    /// Searches through a tag on every song in the database.
    ///
    /// # Errors
    ///
    /// Returns an [`Error::Mpd`](crate::Error::Mpd) if MPD returns an error.
    pub fn tags(&self, tag: Tag) -> Result<TagConstraints<'_>> {
        self.connection.get_bool_error(|| unsafe {
            mpd_search_db_tags(self.connection.connection(), tag as i32)
        })?;
        println!("Tags");
        Ok(TagConstraints {
            connection: self.connection,
            tag,
        })
    }

    /// Returns statistics on songs in the database.
    ///
    /// # Errors
    ///
    /// Returns an [`Error::Mpd`](crate::Error::Mpd) if MPD returns an error.
    pub fn count_database(&self) -> Result<StatsConstraints<'_>> {
        self.connection
            .get_bool_error(|| unsafe { mpd_count_db_songs(self.connection.connection()) })?;
        Ok(StatsConstraints {
            connection: self.connection,
        })
    }

    /// Returns statistics on songs in the database with a case insensitive search.
    ///
    /// # Errors
    ///
    /// Returns an [`Error::Mpd`](crate::Error::Mpd) if MPD returns an error.
    pub fn count_database_i(&self) -> Result<StatsConstraints<'_>> {
        self.connection
            .get_bool_error(|| unsafe { mpd_searchcount_db_songs(self.connection.connection()) })?;
        Ok(StatsConstraints {
            connection: self.connection,
        })
    }
}

// --- Constraint ---

/// Constraint to [search](Search) in.
pub trait Constraint<'a> {
    /// Expected return type from the commit.
    type Commit;

    /// Trait access to the [`Connection`] stored in the implementing structs.
    fn connection(&self) -> &'a Connection;

    /// Needs to commit the search and get the correct return type from MPD.
    ///
    /// # Errors
    ///
    /// Usually returns [`Error::Mpd`](crate::error::Error::Mpd)  if MPD returns an error.
    fn commit(&self) -> Result<Self::Commit>;

    /// Sets the base directory within the MPD database in which to search.
    ///
    /// # Errors
    ///
    /// Returns [`Error::Mpd`](crate::Error::Mpd) if MPD returns an error.
    fn base(&self, dir: &str) -> Result<&Self> {
        let cdir = CString::new(dir)?;
        self.connection().get_bool_error(|| unsafe {
            mpd_search_add_base_constraint(self.connection().connection(), DEF_OP, cdir.as_ptr())
        })?;
        Ok(self)
    }

    /// Sets the uri within the MPD database that should be searched.
    ///
    /// # Errors
    ///
    /// Returns [`Error::Mpd`](crate::Error::Mpd) if MPD returns an error.
    fn uri(&self, uri: &str) -> Result<&Self> {
        let curi = CString::new(uri)?;
        self.connection().get_bool_error(|| unsafe {
            mpd_search_add_uri_constraint(self.connection().connection(), DEF_OP, curi.as_ptr())
        })?;
        Ok(self)
    }

    /// Sets the value for a tag within a song that should be searched.
    ///
    /// # Errors
    ///
    /// Returns [`Error::Mpd`](crate::Error::Mpd) if MPD returns an error.
    fn tag(&self, tag: Tag, value: &str) -> Result<&Self> {
        let cvalue = CString::new(value)?;
        self.connection().get_bool_error(|| unsafe {
            mpd_search_add_tag_constraint(
                self.connection().connection(),
                DEF_OP,
                tag as i32,
                cvalue.as_ptr(),
            )
        })?;
        Ok(self)
    }

    /// Sets the value for any tag within a song that should be searched.
    ///
    /// # Errors
    ///
    /// Returns [`Error::Mpd`](crate::Error::Mpd) if MPD returns an error.
    fn any_tag(&self, value: &str) -> Result<&Self> {
        let cvalue = CString::new(value)?;
        self.connection().get_bool_error(|| unsafe {
            mpd_search_add_any_tag_constraint(
                self.connection().connection(),
                DEF_OP,
                cvalue.as_ptr(),
            )
        })?;
        Ok(self)
    }

    /// Sets the search to all entities modified since `time`.
    ///
    /// `time` is entered in the `UNIX_TIMESTAMP`.
    ///
    /// # Errors
    ///
    /// Returns [`Error::Mpd`](crate::Error::Mpd) if MPD returns an error.
    // allow because it should be just accepted by the c code
    #[allow(clippy::cast_possible_wrap)]
    fn modified_since(&self, time: u64) -> Result<&Self> {
        self.connection().get_bool_error(|| unsafe {
            mpd_search_add_modified_since_constraint(
                self.connection().connection(),
                DEF_OP,
                time as i64,
            )
        })?;
        Ok(self)
    }

    /// Sets the search to all entities added since `time` to the database.
    ///
    /// # Errors
    ///
    /// Returns [`Error::Mpd`](crate::Error::Mpd) if MPD returns an error.
    #[cfg(feature = "protocol_0_24")]
    // allow because it should be just accepted by the c code
    #[allow(clippy::cast_possible_wrap)]
    fn added_since(&self, time: u64) -> Result<&Self> {
        self.connection().get_bool_error(|| unsafe {
            mpd_search_add_added_since_constraint(
                self.connection().connection(),
                DEF_OP,
                time as i64,
            )
        })?;
        Ok(self)
    }

    /// Sets the search to a expression term.
    ///
    /// An expression may look like: `"((artist == "Kraftwerk") AND (title == "Metall auf
    /// Metall"))"`. Further information in the
    /// [MPD protocol documentation](https://mpd.readthedocs.io/en/latest/protocol.html#filters)
    ///
    /// # Errors
    ///
    /// Returns [`Error::Mpd`](crate::Error::Mpd) if MPD returns an error.
    fn expression(&self, value: &str) -> Result<&Self> {
        let cvalue = CString::new(value)?;
        self.connection().get_bool_error(|| unsafe {
            mpd_search_add_expression(self.connection().connection(), cvalue.as_ptr())
        })?;
        Ok(self)
    }

    // --- Grouping/Sorting ---

    // Doesnt get accepted by the server
    // /// Group the results by a tag.
    // ///
    // /// # Errors
    // ///
    // /// Returns [`Error::Mpd`](crate::Error::Mpd) if MPD returns an error.
    // fn group_tag(&self, tag: Tag) -> Result<&Self> {
    //     self.connection().get_bool_error(|| unsafe {
    //         mpd_search_add_group_tag(self.connection().connection(), tag as i32)
    //     })?;
    //     Ok(self)
    // }

    /// Sort the results by a named attribute. Can either be a [`Tag`] or `"Last-Modified"`.
    /// The `String` representation of a [`Tag`] can be aquired through [`Tag::name()`].
    ///
    /// # Errors
    ///
    /// Returns [`Error::Mpd`](crate::Error::Mpd) if MPD returns an error.
    fn sort_name(&self, name: &str, descending: bool) -> Result<&Self> {
        let cname = CString::new(name)?;
        self.connection().get_bool_error(|| unsafe {
            mpd_search_add_sort_name(self.connection().connection(), cname.as_ptr(), descending)
        })?;
        Ok(self)
    }

    /// Sort the results by a tag.
    ///
    /// # Errors
    ///
    /// Returns [`Error::Mpd`](crate::Error::Mpd) if MPD returns an error.
    fn sort_tag(&self, tag: Tag, descending: bool) -> Result<&Self> {
        self.connection().get_bool_error(|| unsafe {
            mpd_search_add_sort_tag(self.connection().connection(), tag as i32, descending)
        })?;
        Ok(self)
    }

    /// Requests only a part of the whole result.
    ///
    /// # Errors
    ///
    /// Returns [`Error::Mpd`](crate::Error::Mpd) if MPD returns an error.
    fn window(&self, start: u32, end: u32) -> Result<&Self> {
        self.connection().get_bool_error(|| unsafe {
            mpd_search_add_window(self.connection().connection(), start, end)
        })?;
        Ok(self)
    }
}

/// Constraint used when the search immediatly adds results to a playlist.
pub struct AddConstraint<'a> {
    connection: &'a Connection,
}

impl<'a> Constraint<'a> for AddConstraint<'a> {
    type Commit = ();

    fn connection(&self) -> &'a Connection {
        self.connection
    }

    fn commit(&self) -> Result<Self::Commit> {
        self.connection()
            .get_bool_error(|| unsafe { mpd_search_commit(self.connection().connection()) })?;
        self.connection()
            .get_bool_error(|| unsafe { mpd_response_finish(self.connection().connection()) })?;
        Ok(())
    }
}

impl AddConstraint<'_> {
    /// Adds the results to a specific position in the queue or a playlist.
    ///
    /// # Errors
    ///
    /// Returns [`Error::Mpd`](crate::Error::Mpd) if MPD returns an error.
    pub fn add_position(&self, position: u32, whence: Position) -> Result<&Self> {
        self.connection().get_bool_error(|| unsafe {
            mpd_search_add_position(self.connection().connection(), position, whence as u32)
        })?;
        Ok(self)
    }
}

/// Constraint used when the search returns a list of [`Song`]s.
pub struct SongConstraints<'a> {
    connection: &'a Connection,
}

impl<'a> Constraint<'a> for SongConstraints<'a> {
    type Commit = Vec<Song>;

    fn connection(&self) -> &'a Connection {
        self.connection
    }

    fn commit(&self) -> Result<Self::Commit> {
        self.connection
            .get_bool_error(|| unsafe { mpd_search_commit(self.connection.connection()) })?;
        Song::extract_all(EntityReceiver::new(self.connection))
    }
}

/// Constraint used when the search returns stats about the database.
pub struct StatsConstraints<'a> {
    connection: &'a Connection,
}

impl<'a> Constraint<'a> for StatsConstraints<'a> {
    type Commit = Stats;

    fn connection(&self) -> &'a Connection {
        self.connection
    }

    fn commit(&self) -> Result<Self::Commit> {
        self.connection
            .get_bool_error(|| unsafe { mpd_search_commit(self.connection.connection()) })?;
        Stats::receive(self.connection)
    }
}

/// Constraint used when the search returns tag values.
pub struct TagConstraints<'a> {
    connection: &'a Connection,
    tag: Tag,
}

impl<'a> Constraint<'a> for TagConstraints<'a> {
    type Commit = TagReceiver<'a>;

    fn connection(&self) -> &'a Connection {
        self.connection
    }

    fn commit(&self) -> Result<Self::Commit> {
        self.connection
            .get_bool_error(|| unsafe { mpd_search_commit(self.connection.connection()) })?;

        Ok(TagReceiver::new(self.connection, self.tag))
    }
}

/// Describing a tag returned by searching with [`Search::tags()`].
pub struct TagReceiver<'a> {
    connection: &'a Connection,
    tag: Tag,
}

impl<'a> TagReceiver<'a> {
    pub(super) fn new(connection: &'a Connection, tag: Tag) -> Self {
        Self { connection, tag }
    }

    /// Shortcut to collect all tag values
    ///
    /// # Errors
    ///
    /// Returns [`Error::Mpd`](crate::Error::Mpd) if MPD returns an error.
    pub fn receive_all(self) -> Result<Vec<String>> {
        self.collect()
    }
}

impl Iterator for TagReceiver<'_> {
    type Item = Result<String>;

    fn next(&mut self) -> Option<Self::Item> {
        match self.tag.receive(self.connection) {
            Ok(val) => val.map(Ok),
            Err(err) => Some(Err(err)),
        }
    }
}