import Control.Monad.Except.Trans (runExceptT)

import Control.Monad.Except.Trans (ExceptT, runExceptT)

import Data.DateTime.Instant (toDateTime)

import Data.DateTime.Instant (Instant, toDateTime)

import Data.Foldable (class Foldable, foldMapDefaultR)

import Data.Foldable (class Foldable, foldr, foldl, foldMapDefaultR)
import Data.Functor.Compose (Compose(..))

import Data.Newtype (class Newtype)

import Data.Maybe (Maybe)
import Data.Newtype (class Newtype, unwrap)

-- import Effect (Effect)

import Effect (Effect)

  , pidStr

  , parseDatedResponseMay

  , depFn :: DepreciationFn

  , depf :: DepreciationFn

    depFn <- project .: "depreciationFn"
    pure $ Project' { projectId, projectName, inceptionDate, initiator, depFn }

    depf <- project .: "depf"
    pure $ Project' { projectId, projectName, inceptionDate, initiator, depf }

derive instance contributorNewtype :: Newtype (Contributor' a) _
derive instance contributorFunctor :: Functor Contributor'
instance contributorFoldable :: Foldable Contributor' where
  foldr f b (Contributor' p) = f (p.joinedOn) b
  foldl f b (Contributor' p) = f b (p.joinedOn)
  foldMap = foldMapDefaultR
instance contributorTraversable :: Traversable Contributor' where
  traverse f (Contributor' p) = 
    Contributor' <<< (\b -> p { joinedOn = b }) <$> f (p.joinedOn)
  sequence = traverse identity

projectDetail :: 
  forall date. 
  Project' date -> 
  M.Map UserId (Contributor' date) -> 
  ProjectDetail' date
projectDetail project contributors = 
  ProjectDetail' { project, contributors }

type ProjectDetailJson date = 
  { project :: Project' date
  , contributors :: Array (Contributor' date)
  }

derive instance projectDetailNewtype :: Newtype (ProjectDetail' a) _
derive instance projectDetailFunctor :: Functor ProjectDetail'
instance projectDetailFoldable :: Foldable ProjectDetail' where
  foldr f b (ProjectDetail' p) = foldr f (foldr f b (p.project)) (Compose p.contributors)
  foldl f b (ProjectDetail' p) = foldl f (foldl f b (p.project)) (Compose p.contributors)
  foldMap = foldMapDefaultR
instance projectDetailTraversable :: Traversable ProjectDetail' where
  traverse f (ProjectDetail' p) = 
    projectDetail <$> traverse f p.project 
                  <*> (map unwrap $ traverse f (Compose p.contributors))
  sequence = traverse identity

-- getProjectDetail :: ProjectId -> Aff (Maybe ProjectDetail)
-- getProjectDetail pid = do
--   response <- get RF.json ("/api/user/projects/" <> pidStr pid)
--   EC.liftEffect
--    <<< map (\dt -> ProjectDetail' { 
--              project: dt.project, 
--              contributors: M.fromFoldable $ map (\c -> (Tuple c.userId c)) dt.contributors
--            })
--    $ parsed

getProjectDetail :: ProjectId -> Aff (Either APIError (Maybe ProjectDetail))
getProjectDetail pid = do
  response <- get RF.json ("/api/user/projects/" <> pidStr pid <> "/detail")
  let parsed :: ExceptT APIError Effect (Maybe (ProjectDetail' Instant))
      parsed = parseDatedResponseMay response
  EC.liftEffect 
    <<< runExceptT
    <<< map (map (map toDateTime))
    $ parsed

           depreciationCols project.depFn <>

           depreciationCols project.depf <>

          , depFn: LinearDepreciation { undep: Days 30.0, dep: Days 300.0 }

          , depf: LinearDepreciation { undep: Days 30.0, dep: Days 300.0 }