{-# LANGUAGE CPP #-}

{- |
Module      : Network.MPD
Copyright   : (c) Joachim Fasting, Simon Hengel 2012
License     : MIT

Maintainer  : Joachim Fasting <joachifm@fastmail.fm>
Stability   : unstable
Portability : unportable

An MPD client library. MPD is a daemon for playing music that is
controlled over a network socket.

To use the library, do:

> {-# LANGUAGE OverloadedStrings #-}
> import qualified Network.MPD as MPD
-}

module Network.MPD (
    -- * Basic data types
    MonadMPD, MPD, MPDError(..), ACKType(..), Response,
    Host, Port, Password,
    -- * Connections
    withMPD, withMPD_, withMPDEx,
    module Network.MPD.Commands,
#ifdef TEST
    getConnectionSettings, getEnvDefault
#endif
    ) where

import           Prelude
import qualified Control.Exception as E
import           Network.MPD.Commands
import           Network.MPD.Core

import           System.Environment (getEnv)
import           System.IO.Error (isDoesNotExistError)
import           Data.Maybe (listToMaybe)

-- | A wrapper for 'withMPDEx' that uses localhost:6600 as the default
-- host:port, or whatever is found in the environment variables MPD_HOST and
-- MPD_PORT. If MPD_HOST is of the form \"password\@host\" the password
-- will be supplied as well.
--
-- Examples:
--
-- > withMPD $ play Nothing
-- > withMPD $ add_ "tool" >> play Nothing >> currentSong
withMPD :: MPD a -> IO (Response a)
withMPD :: forall a. MPD a -> IO (Response a)
withMPD = Maybe [Char] -> Maybe [Char] -> MPD a -> IO (Response a)
forall a. Maybe [Char] -> Maybe [Char] -> MPD a -> IO (Response a)
withMPD_ Maybe [Char]
forall a. Maybe a
Nothing Maybe [Char]
forall a. Maybe a
Nothing

-- | Same as `withMPD`, but takes optional arguments that override MPD_HOST and
-- MPD_PORT.
--
-- This is e.g. useful for clients that optionally take @--port@ and @--host@
-- as command line arguments, and fall back to `withMPD`'s defaults if those
-- arguments are not given.
withMPD_ :: Maybe String -- ^ optional override for MPD_HOST
         -> Maybe String -- ^ optional override for MPD_PORT
         -> MPD a -> IO (Response a)
withMPD_ :: forall a. Maybe [Char] -> Maybe [Char] -> MPD a -> IO (Response a)
withMPD_ Maybe [Char]
mHost Maybe [Char]
mPort MPD a
action = do
    settings <- Maybe [Char]
-> Maybe [Char] -> IO (Either [Char] ([Char], Integer, [Char]))
getConnectionSettings Maybe [Char]
mHost Maybe [Char]
mPort
    case settings of
      Right ([Char]
host, Integer
port, [Char]
pw) -> [Char] -> Integer -> [Char] -> MPD a -> IO (Response a)
forall a. [Char] -> Integer -> [Char] -> MPD a -> IO (Response a)
withMPDEx [Char]
host Integer
port [Char]
pw MPD a
action
      Left [Char]
err -> (Response a -> IO (Response a)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Response a -> IO (Response a))
-> ([Char] -> Response a) -> [Char] -> IO (Response a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MPDError -> Response a
forall a b. a -> Either a b
Left (MPDError -> Response a)
-> ([Char] -> MPDError) -> [Char] -> Response a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> MPDError
Custom) [Char]
err

getConnectionSettings :: Maybe String -> Maybe String -> IO (Either String (Host, Port, Password))
getConnectionSettings :: Maybe [Char]
-> Maybe [Char] -> IO (Either [Char] ([Char], Integer, [Char]))
getConnectionSettings Maybe [Char]
mHost Maybe [Char]
mPort = do
    (host, pw) <- [Char] -> ([Char], [Char])
parseHost ([Char] -> ([Char], [Char])) -> IO [Char] -> IO ([Char], [Char])
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap`
        IO [Char] -> ([Char] -> IO [Char]) -> Maybe [Char] -> IO [Char]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe ([Char] -> [Char] -> IO [Char]
getEnvDefault [Char]
"MPD_HOST" [Char]
"localhost") [Char] -> IO [Char]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe [Char]
mHost
    port <- maybe (getEnvDefault "MPD_PORT" "6600") return mPort
    case maybeRead port of
      Just Integer
p  -> (Either [Char] ([Char], Integer, [Char])
-> IO (Either [Char] ([Char], Integer, [Char]))
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Either [Char] ([Char], Integer, [Char])
 -> IO (Either [Char] ([Char], Integer, [Char])))
-> (([Char], Integer, [Char])
    -> Either [Char] ([Char], Integer, [Char]))
-> ([Char], Integer, [Char])
-> IO (Either [Char] ([Char], Integer, [Char]))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Char], Integer, [Char])
-> Either [Char] ([Char], Integer, [Char])
forall a b. b -> Either a b
Right) ([Char]
host, Integer
p, [Char]
pw)
      Maybe Integer
Nothing -> (Either [Char] ([Char], Integer, [Char])
-> IO (Either [Char] ([Char], Integer, [Char]))
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Either [Char] ([Char], Integer, [Char])
 -> IO (Either [Char] ([Char], Integer, [Char])))
-> ([Char] -> Either [Char] ([Char], Integer, [Char]))
-> [Char]
-> IO (Either [Char] ([Char], Integer, [Char]))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> Either [Char] ([Char], Integer, [Char])
forall a b. a -> Either a b
Left) ([Char] -> [Char]
forall a. Show a => a -> [Char]
show [Char]
port [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" is not a valid port!")
    where
        parseHost :: [Char] -> ([Char], [Char])
parseHost [Char]
s = case Char -> [Char] -> ([Char], [Char])
breakChar Char
'@' [Char]
s of
                          ([Char]
host, [Char]
"") -> ([Char]
host, [Char]
"")
                          ([Char]
pw, [Char]
host) -> ([Char]
host, [Char]
pw)

getEnvDefault :: String -> String -> IO String
getEnvDefault :: [Char] -> [Char] -> IO [Char]
getEnvDefault [Char]
x [Char]
dflt =
    IO [Char] -> (IOException -> IO [Char]) -> IO [Char]
forall e a. Exception e => IO a -> (e -> IO a) -> IO a
E.catch ([Char] -> IO [Char]
getEnv [Char]
x) (\IOException
e -> if IOException -> Bool
isDoesNotExistError IOException
e
                            then [Char] -> IO [Char]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [Char]
dflt else IOException -> IO [Char]
forall a. HasCallStack => IOException -> IO a
ioError IOException
e)

-- Break a string by character, removing the separator.
breakChar :: Char -> String -> (String, String)
breakChar :: Char -> [Char] -> ([Char], [Char])
breakChar Char
c [Char]
s = let ([Char]
x, [Char]
y) = (Char -> Bool) -> [Char] -> ([Char], [Char])
forall a. (a -> Bool) -> [a] -> ([a], [a])
break (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
c) [Char]
s in ([Char]
x, Int -> [Char] -> [Char]
forall a. Int -> [a] -> [a]
drop Int
1 [Char]
y)

maybeRead :: Read a => String -> Maybe a
maybeRead :: forall a. Read a => [Char] -> Maybe a
maybeRead = ((a, [Char]) -> a) -> Maybe (a, [Char]) -> Maybe a
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (a, [Char]) -> a
forall a b. (a, b) -> a
fst (Maybe (a, [Char]) -> Maybe a)
-> ([Char] -> Maybe (a, [Char])) -> [Char] -> Maybe a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(a, [Char])] -> Maybe (a, [Char])
forall a. [a] -> Maybe a
listToMaybe ([(a, [Char])] -> Maybe (a, [Char]))
-> ([Char] -> [(a, [Char])]) -> [Char] -> Maybe (a, [Char])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [(a, [Char])]
forall a. Read a => ReadS a
reads