{-# LANGUAGE OverloadedStrings #-}

{- |
Module      : Network.MPD.Commands.Database
Copyright   : (c) Ben Sinclair 2005-2009, Joachim Fasting 2012
License     : MIT (see LICENSE)

Maintainer  : joachifm@fastmail.fm
Stability   : stable
Portability : unportable

The music database.
-}

module Network.MPD.Commands.Database
    ( count
    , find
    , findAdd
    , list
    , listAll
    , listAllInfo
    , lsInfo
    , readComments
    , search
    , searchAdd
    , searchAddPl
    , update
    , rescan
    ) where

import qualified Network.MPD.Applicative.Internal as A
import qualified Network.MPD.Applicative.Database as A
import           Network.MPD.Commands.Query
import           Network.MPD.Commands.Types
import           Network.MPD.Core

-- | Count the number of entries matching a query.
count :: MonadMPD m => Query -> m Count
count :: Query -> m Count
count = Command Count -> m Count
forall (m :: * -> *) a. MonadMPD m => Command a -> m a
A.runCommand (Command Count -> m Count)
-> (Query -> Command Count) -> Query -> m Count
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Query -> Command Count
A.count

-- | Search the database for entries exactly matching a query.
find :: MonadMPD m => Query -> m [Song]
find :: Query -> m [Song]
find = Command [Song] -> m [Song]
forall (m :: * -> *) a. MonadMPD m => Command a -> m a
A.runCommand (Command [Song] -> m [Song])
-> (Query -> Command [Song]) -> Query -> m [Song]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Query -> Command [Song]
A.find

-- | Adds songs matching a query to the current playlist.
findAdd :: MonadMPD m => Query -> m ()
findAdd :: Query -> m ()
findAdd = Command () -> m ()
forall (m :: * -> *) a. MonadMPD m => Command a -> m a
A.runCommand (Command () -> m ()) -> (Query -> Command ()) -> Query -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Query -> Command ()
A.findAdd

-- | List all tags of the specified type of songs that that satisfy the query.
--
-- @since 0.10.0.0
list :: MonadMPD m
     => Metadata -- ^ Metadata to list
     -> Query -> m [Value]
list :: Metadata -> Query -> m [Value]
list Metadata
m = Command [Value] -> m [Value]
forall (m :: * -> *) a. MonadMPD m => Command a -> m a
A.runCommand (Command [Value] -> m [Value])
-> (Query -> Command [Value]) -> Query -> m [Value]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Metadata -> Query -> Command [Value]
A.list Metadata
m

-- | List the songs (without metadata) in a database directory recursively.
listAll :: MonadMPD m => Path -> m [Path]
listAll :: Path -> m [Path]
listAll = Command [Path] -> m [Path]
forall (m :: * -> *) a. MonadMPD m => Command a -> m a
A.runCommand (Command [Path] -> m [Path])
-> (Path -> Command [Path]) -> Path -> m [Path]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Path -> Command [Path]
A.listAll

-- | Recursive 'lsInfo'.
listAllInfo :: MonadMPD m => Path -> m [LsResult]
listAllInfo :: Path -> m [LsResult]
listAllInfo = Command [LsResult] -> m [LsResult]
forall (m :: * -> *) a. MonadMPD m => Command a -> m a
A.runCommand (Command [LsResult] -> m [LsResult])
-> (Path -> Command [LsResult]) -> Path -> m [LsResult]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Path -> Command [LsResult]
A.listAllInfo

-- | Non-recursively list the contents of a database directory.
lsInfo :: MonadMPD m => Path -> m [LsResult]
lsInfo :: Path -> m [LsResult]
lsInfo = Command [LsResult] -> m [LsResult]
forall (m :: * -> *) a. MonadMPD m => Command a -> m a
A.runCommand (Command [LsResult] -> m [LsResult])
-> (Path -> Command [LsResult]) -> Path -> m [LsResult]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Path -> Command [LsResult]
A.lsInfo

-- | Read comments from file at path.
readComments :: MonadMPD m => Path -> m [(String, String)]
readComments :: Path -> m [(String, String)]
readComments = Command [(String, String)] -> m [(String, String)]
forall (m :: * -> *) a. MonadMPD m => Command a -> m a
A.runCommand (Command [(String, String)] -> m [(String, String)])
-> (Path -> Command [(String, String)])
-> Path
-> m [(String, String)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Path -> Command [(String, String)]
A.readComments

-- | Search the database using case insensitive matching.
search :: MonadMPD m => Query -> m [Song]
search :: Query -> m [Song]
search = Command [Song] -> m [Song]
forall (m :: * -> *) a. MonadMPD m => Command a -> m a
A.runCommand (Command [Song] -> m [Song])
-> (Query -> Command [Song]) -> Query -> m [Song]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Query -> Command [Song]
A.search

-- | Like 'search' but adds the results to the current playlist.
--
-- @since 0.10.0.0
searchAdd :: MonadMPD m => Query -> m ()
searchAdd :: Query -> m ()
searchAdd = Command () -> m ()
forall (m :: * -> *) a. MonadMPD m => Command a -> m a
A.runCommand (Command () -> m ()) -> (Query -> Command ()) -> Query -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Query -> Command ()
A.searchAdd

-- | Like 'searchAdd' but adds results to the named playlist.
--
-- @since 0.10.0.0
searchAddPl :: MonadMPD m => PlaylistName -> Query -> m ()
searchAddPl :: PlaylistName -> Query -> m ()
searchAddPl PlaylistName
pl = Command () -> m ()
forall (m :: * -> *) a. MonadMPD m => Command a -> m a
A.runCommand (Command () -> m ()) -> (Query -> Command ()) -> Query -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PlaylistName -> Query -> Command ()
A.searchAddPl PlaylistName
pl

-- | Update the server's database.
--
-- If no path is given, the whole library will be scanned.  Unreadable or
-- non-existent paths are silently ignored.
--
-- The update job id is returned.
update :: MonadMPD m => Maybe Path -> m Integer
update :: Maybe Path -> m Integer
update = Command Integer -> m Integer
forall (m :: * -> *) a. MonadMPD m => Command a -> m a
A.runCommand (Command Integer -> m Integer)
-> (Maybe Path -> Command Integer) -> Maybe Path -> m Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe Path -> Command Integer
A.update

-- | Like 'update' but also rescans unmodified files.
rescan :: MonadMPD m => Maybe Path -> m Integer
rescan :: Maybe Path -> m Integer
rescan = Command Integer -> m Integer
forall (m :: * -> *) a. MonadMPD m => Command a -> m a
A.runCommand (Command Integer -> m Integer)
-> (Maybe Path -> Command Integer) -> Maybe Path -> m Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe Path -> Command Integer
A.rescan