{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE DeriveGeneric #-}

module Bio.RealWorld.Reactome
    ( getPathways
    ) where

import Data.Aeson
import GHC.Generics (Generic)
import qualified Data.Text as T
import           Network.HTTP.Simple

base :: String
base :: String
base = String
"https://reactome.org/ContentService"

data Obj = Obj
    { Obj -> Maybe Text
className :: Maybe T.Text
    , Obj -> Int
dbId :: Int 
    , Obj -> Text
displayName :: T.Text
    , Obj -> Maybe Text
schemaClass :: Maybe T.Text
    , Obj -> Maybe Text
stId :: Maybe T.Text
    , Obj -> Maybe Text
stIdVersion :: Maybe T.Text
    } deriving (Int -> Obj -> ShowS
[Obj] -> ShowS
Obj -> String
(Int -> Obj -> ShowS)
-> (Obj -> String) -> ([Obj] -> ShowS) -> Show Obj
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Obj] -> ShowS
$cshowList :: [Obj] -> ShowS
show :: Obj -> String
$cshow :: Obj -> String
showsPrec :: Int -> Obj -> ShowS
$cshowsPrec :: Int -> Obj -> ShowS
Show, (forall x. Obj -> Rep Obj x)
-> (forall x. Rep Obj x -> Obj) -> Generic Obj
forall x. Rep Obj x -> Obj
forall x. Obj -> Rep Obj x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Obj x -> Obj
$cfrom :: forall x. Obj -> Rep Obj x
Generic)

instance ToJSON Obj
instance FromJSON Obj
 
-- | All Reactome top level pathways
getPathways :: String -> IO [Obj]
getPathways :: String -> IO [Obj]
getPathways String
species = do
    Request
req <- String -> IO Request
forall (m :: * -> *). MonadThrow m => String -> m Request
parseRequest String
url
    Response [Obj]
response <- Request -> IO (Response [Obj])
forall (m :: * -> *) a.
(MonadIO m, FromJSON a) =>
Request -> m (Response a)
httpJSON Request
req
    [Obj] -> IO [Obj]
forall (m :: * -> *) a. Monad m => a -> m a
return ([Obj] -> IO [Obj]) -> [Obj] -> IO [Obj]
forall a b. (a -> b) -> a -> b
$ Response [Obj] -> [Obj]
forall a. Response a -> a
getResponseBody Response [Obj]
response
  where
    url :: String
url = String
base String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
"/data/pathways/top/" String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
species

{-
pathwayAnalysis :: [B.ByteString]   -- ^ A list of identifiers
                -> IO B.ByteString
pathwayAnalysis ids = do
    initReq <- parseRequest base
    let request = urlEncodedBody [] initReq
    manager <- newManager tlsManagerSettings
    r <- fmap M.fromList $ runResourceT $ do
        response <- http request manager
        runConduit $ responseBody response .| linesUnboundedAsciiC .|
            (dropC 1 >> mapC ((\[a,b] -> (a,b)) . B.split '\t')) .| sinkList
    return $ map (flip M.lookup r) ids
  where
    params =
-}