[ P.classes (ClassName <$> ["row", "no-gutters"]) ]

          [ P.classes (ClassName <$> ["row", "no-gutters", "container"]) ]

import Data.Array (index)

-- import Data.HTTP.Method (Method(POST))

import Data.Traversable (traverse)

import Data.Traversable (traverse, traverse_)

import Effect.Class (liftEffect)

import Effect.Class as EC

-- import Halogen as H
-- import Halogen.HTML.Core (ClassName(..))
-- import Halogen.HTML as HH
-- import Halogen.HTML.CSS as CSS
-- import Halogen.HTML.Events as E
-- import Web.Event.Event as WE
-- import Halogen.HTML.Properties as P

import Aftok.Types (APIError(..))
import Halogen as H
import Halogen.HTML as HH
import Halogen.HTML.Events as E
import Halogen.HTML.Properties as P
import Effect.Class.Console (error)
newtype ProjectId = ProjectId UUID
pidStr :: ProjectId -> String
pidStr (ProjectId uuid) = show uuid

  { projectName :: String

  { projectId :: ProjectId
  , projectName :: String

type ProjectCState =
  { projects :: Array Project
  }
data ProjectAction 
  = Initialize
  | Select Int
type ProjectListSlot id = forall query. H.Slot query Project id

data APIError 
  = Forbidden
  | ParseFailure Json String
  | Error { status :: Maybe StatusCode, message :: String }

projectListComponent
  :: forall query input m
  .  EC.MonadEffect m
  => Capability m 
  -> H.Component HH.HTML query input Project m
projectListComponent caps = H.mkComponent
  { initialState
  , render
  , eval: H.mkEval $ H.defaultEval 
      { handleAction = eval
      , initialize = Just Initialize 
      }
  } where
    initialState :: input -> ProjectCState
    initialState _ = { projects: [] }
    render :: forall slots. ProjectCState -> H.ComponentHTML ProjectAction slots m
    render st = 
     let renderOption (Project' p) =
           HH.option [P.value $ pidStr p.projectId] [HH.text p.projectName]
       in HH.select
            [E.onSelectedIndexChange (Just <<< Select)]
            ([HH.option [P.selected true, P.disabled true] [HH.text "Select a project"]] <> map renderOption st.projects)
    eval :: ProjectAction -> H.HalogenM ProjectCState ProjectAction () Project m Unit
    eval = case _ of
      Initialize -> do
        res <- lift caps.listProjects
        case res of 
            Left _ -> error "Could not retrieve project list."
            Right projects -> H.modify_ (_ { projects = projects })
      Select i -> do
        projects <- H.gets (_.projects)
        traverse_ H.raise (index projects i)

    projectName <- x .: "projectName" 
    inceptionDate <- x .: "inceptionDate" 
    initiatorStr <- x .: "initiator" 
    initiator <- note "Failed to decode initiator UUID" $ parseUUID initiatorStr
    pure $ Project' { projectName, inceptionDate, initiator }

    project <- x .: "project"
    projectIdStr <- x .: "projectId"
    projectId    <- ProjectId <$> (note "Failed to decode project UUID" $ parseUUID projectIdStr)

    projectName   <- project .: "projectName"
    inceptionDate <- project .: "inceptionDate"
    initiatorStr  <- project .: "initiator"
    initiator     <- note "Failed to decode initiator UUID" $ parseUUID initiatorStr
    pure $ Project' { projectId, projectName, inceptionDate, initiator }

  liftEffect <<< runExceptT $ case result of

  EC.liftEffect <<< runExceptT $ case result of

import Data.Maybe (Maybe(..), maybe)

import Data.Either (Either(..))
import Data.Maybe (Maybe(..), maybe, isJust)
import Data.Symbol (SProxy(..))
import Data.Time.Duration (Milliseconds(..), Days(..))
import Data.Traversable (traverse_)

import Data.Time.Duration (Milliseconds(..), Days(..))

import Data.UUID as UUID

import Affjax (post, printError)
import Affjax.StatusCode (StatusCode(..))
import Affjax.RequestBody as RB
import Affjax.ResponseFormat as RF
import Data.Argonaut.Encode (encodeJson)

type TimelineConfig = 
  { width :: Number
  }

import Aftok.Project as Project
import Aftok.Project (Project, Project'(..), ProjectId(..))
import Aftok.Types (APIError(..))
import Effect.Class.Console (log)

  , selectedProject :: Maybe Project

  | ProjectSelected Project.Project

data TimelineError
  = LogFailure (APIError)

type Slots = 
  ( projectList :: Project.ProjectListSlot Unit
  )
_projectList = SProxy :: SProxy "projectList"

  { logStart :: m Instant
  , logEnd :: m Instant

  { logStart :: ProjectId -> m (Either TimelineError Instant)
  , logEnd :: ProjectId -> m (Either TimelineError Instant)

component :: forall query input output. Capability Aff -> TimelineConfig -> H.Component HH.HTML query input output Aff
component caps conf = H.mkComponent 

component 
  :: forall query input output
  .  Capability Aff 
  -> Project.Capability Aff
  -> H.Component HH.HTML query input output Aff
component caps pcaps = H.mkComponent 

      let limits = { start: bottom, current: bottom, end: bottom }
          history = []
          active = Nothing
       in { limits, history, active }

      { limits: { start: bottom, current: bottom, end: bottom }
      , history: []
      , active: Nothing
      , selectedProject: Nothing
      }

    render :: forall slots m. TimelineState -> H.ComponentHTML TimelineAction slots m

    render :: TimelineState -> H.ComponentHTML TimelineAction Slots Aff

      HH.section 
        [P.classes (ClassName <$> ["section-border", "border-primary"])]
        [HH.div
          [P.classes (ClassName <$> ["container", "pt-6"])]
          [HH.h1 
            [P.classes (ClassName <$> ["mb-0", "font-weight-bold", "text-center"])]
            [HH.text "Time Tracker"]
          ,HH.p
            [P.classes (ClassName <$> ["col-md-5", "text-muted", "text-center", "mx-auto"])]
            [HH.text "Today's project timeline"]
          ,lineHtml (intervalHtml conf st.limits <$> st.history <> fromMaybe st.active)
          ,HH.div_
            [HH.button
              [P.classes (ClassName <$> ["btn", "btn-primary", "float-left"])
              ,E.onClick \_ -> Just Start
              ]
              [HH.text "Start Work"]
            ,HH.button
              [P.classes (ClassName <$> ["btn", "btn-primary", "float-right"])
              ,E.onClick \_ -> Just Stop

      let lineForm = 
            [lineHtml (intervalHtml st.limits <$> st.history <> fromMaybe st.active)
            ,HH.div_
              [HH.button
                [P.classes (ClassName <$> ["btn", "btn-primary", "float-left"])
                ,E.onClick \_ -> Just Start
                ]
                [HH.text "Start Work"]
              ,HH.button
                [P.classes (ClassName <$> ["btn", "btn-primary", "float-right"])
                ,E.onClick \_ -> Just Stop
                ]
                [HH.text "Stop Work"]

              [HH.text "Stop Work"]

          ]
        ]

       in HH.section 
          [P.classes (ClassName <$> ["section-border", "border-primary"])]
          ([HH.div
            [P.classes (ClassName <$> ["container-fluid", "pt-6"])]
            [HH.h1 
              [P.classes (ClassName <$> ["mb-0", "font-weight-bold", "text-center"])]
              [HH.text "Time Tracker"]
            ,HH.p
              [P.classes (ClassName <$> ["col-md-5", "text-muted", "text-center", "mx-auto"])]
              [HH.text "Today's project timeline"]
            ,HH.div_ 
              [HH.slot _projectList unit (Project.projectListComponent pcaps) unit (Just <<< ProjectSelected)]
            ]
          ] <> (if isJust st.selectedProject then lineForm else []))

    eval :: TimelineAction -> H.HalogenM TimelineState TimelineAction () output Aff Unit

    eval :: TimelineAction -> H.HalogenM TimelineState TimelineAction Slots output Aff Unit

                , selectedProject: Nothing

      ProjectSelected p -> 
        H.modify_ (_ { selectedProject = Just p })

        t <- lift caps.logStart 
        H.modify_ (start t)

        let withProject (Project' p) = do
              logged <- lift $ caps.logStart p.projectId
              case logged of 
                Left _ -> log "Failed to start timer."
                Right t -> H.modify_ (start t)
        project <- H.gets (_.selectedProject)
        log $ "Project selected? " <> show (isJust project)
        traverse_ withProject project

        t <- lift caps.logEnd
        H.modify_ (stop t)

        let withProject (Project' p) = do
              logged <- lift $ caps.logEnd p.projectId
              case logged of 
                Left _ -> log "Failed to stop timer."
                Right t -> H.modify_ (stop t)
        project <- H.gets (_.selectedProject)
        traverse_ withProject project

  .  TimelineConfig 
  -> TimelineLimits 

  .  TimelineLimits 

intervalHtml conf limits i = 

intervalHtml limits i = 

logStart :: ProjectId -> Aff (Either TimelineError Instant)
logStart (ProjectId pid) = do
  let requestBody = Just <<< RB.Json <<< encodeJson $ { schemaVersion: "2.0" }
  result <- post RF.json ("/api/projects/" <> UUID.toString pid <> "/logStart") requestBody
  case result of
    Left err -> pure <<< Left <<< LogFailure $ Error { status: Nothing, message: printError err }
    Right r -> case r.status of
      StatusCode 403 -> pure <<< Left <<< LogFailure $ Forbidden
      StatusCode 200 -> Right <$> liftEffect now
      other -> pure <<< Left <<< LogFailure $ Error { status: Just other, message: r.statusText }
logEnd :: ProjectId -> Aff (Either TimelineError Instant)
logEnd (ProjectId pid) = do
  let requestBody = Just <<< RB.Json <<< encodeJson $ { schemaVersion: "2.0" }
  result <- post RF.json ("/api/projects/" <> UUID.toString pid <> "/logEnd") requestBody
  case result of
    Left err -> pure <<< Left <<< LogFailure $ Error { status: Nothing, message: printError err }
    Right r -> case r.status of
      StatusCode 403 -> pure <<< Left <<< LogFailure $ Forbidden
      StatusCode 200 -> Right <$> liftEffect now
      other -> pure <<< Left <<< LogFailure $ Error { status: Just other, message: r.statusText }
apiCapability :: Capability Aff
apiCapability = { logStart, logEnd }

  { logStart: liftEffect now
  , logEnd: liftEffect now

  { logStart: \_ -> Right <$> liftEffect now
  , logEnd:  \_ -> Right <$> liftEffect now

module Aftok.Types where
import Data.Argonaut.Core (Json)
import Data.Maybe (Maybe)
import Affjax.StatusCode (StatusCode)
data APIError 
  = Forbidden
  | ParseFailure Json String
  | Error { status :: Maybe StatusCode, message :: String }

      timeline = Timeline.mockCapability

      timeline = Timeline.apiCapability

          [ HH.slot _timeline unit (Timeline.component tlCap { width: 600.0 }) unit absurd ]

          [ HH.slot _timeline unit (Timeline.component tlCap pCap) unit absurd ]

curl --verbose --insecure --user $USER \

curl --insecure --user $USER \