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

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

import Data.JSDate as JSDate

import Aftok.Types (APIError(..))

import Aftok.Types (APIError(..), parseDate)

  jsDate <- lift $ JSDate.parse p.inceptionDate
  pdate <- except $ note (ParseFailure json "Could not parse inception date") 
                         (JSDate.toDateTime jsDate)

  pdate <- withExceptT (ParseFailure json) $ parseDate p.inceptionDate

import Control.Monad.Error.Class (throwError)
import Control.Monad.Except.Trans (except, withExceptT, runExceptT)

import Data.Argonaut.Decode (class DecodeJson, decodeJson, (.:), (.:?))

import Data.Either (Either(..))
import Data.Foldable (any)

import Data.Either (Either(..), note)
import Data.Foldable (class Foldable, any, foldMapDefaultR)

import Data.Traversable (traverse_)

import Data.Traversable (class Traversable, traverse_, traverse)

import Aftok.Types (APIError(..))

import Aftok.Types (APIError(..), parseDate)

import Effect.Class.Console (log)

import Effect.Class.Console as C

instance showTimelineError :: Show TimelineError where
  show = case _ of
    LogFailure e -> show e

        log $ "Active: " <> show active <> "; " <> show ((_.projectName) <<< unwrap <$> currentProject)
        log $ "Selected: " <> show ((_.projectName) <<< unwrap $ p)

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

        H.modify_ (_ { selectedProject = Just p, history = [] })

        Left _ -> log "Failed to start timer."

        Left err -> C.log $ "Failed to start timer: " <> show err

        Left _ -> log "Failed to stop timer."

        Left err -> C.log $ "Failed to stop timer: " <> show err

      toPct n = pct (100.0 * n / maxWidth)

      toPct n = 100.0 * n / maxWidth

        left (toPct ileft)
        width (toPct iwidth)

        left (pct $ toPct ileft)
        width (pct $ max (toPct iwidth) 0.5)

data Event i
  = StartEvent i
  | StopEvent i
derive instance eventFunctor :: Functor Event
instance eventFoldable :: Foldable Event where
  foldr f b = case _ of
    StartEvent a -> f a b
    StopEvent a -> f a b
  foldl f b = case _ of
    StartEvent a -> f b a
    StopEvent a -> f b a
  foldMap = foldMapDefaultR
instance eventTraversable :: Traversable Event where
  traverse f = case _ of
    StartEvent a -> StartEvent <$> f a 
    StopEvent a -> StopEvent <$> f a 
  sequence = traverse identity
instance decodeJsonEvent :: DecodeJson (Event String) where
  decodeJson json = do
    obj <- decodeJson json
    event <- obj .: "event"
    start' <- traverse (_ .: "eventTime") =<< event .:? "start"
    stop' <-  traverse (_ .: "eventTime") =<< event .:? "stop"
    note "Only 'stop' and 'start' events are supported." $ (StartEvent <$> start') <|> (StopEvent <$> stop')

  case result of
    Left err -> pure <<< Left <<< LogFailure $ Error { status: Nothing, message: printError err }

  liftEffect <<< runExceptT $ case result of
    Left err -> throwError <<< LogFailure $ Error { status: Nothing, message: printError err }

      StatusCode 403 -> pure <<< Left <<< LogFailure $ Forbidden
      StatusCode 200 -> Right <$> liftEffect now
      other -> pure <<< Left <<< LogFailure $ Error { status: Just other, message: r.statusText }

      StatusCode 403 -> 
        throwError $ LogFailure Forbidden
      StatusCode 200 -> 
        withExceptT (LogFailure <<< ParseFailure r.body) $ do
          event <- except $ decodeJson r.body
          timeEvent <- traverse parseDate event
          case timeEvent of 
              StartEvent t -> pure $ fromDateTime t
              StopEvent  _ -> throwError $ "Expected start event, got stop."
      other -> 
        throwError <<< LogFailure $ Error { status: Just other, message: r.statusText }

  case result of
    Left err -> pure <<< Left <<< LogFailure $ Error { status: Nothing, message: printError err }

  liftEffect <<< runExceptT $ case result of
    Left err -> throwError <<< LogFailure $ Error { status: Nothing, message: printError err }

      StatusCode 403 -> pure <<< Left <<< LogFailure $ Forbidden
      StatusCode 200 -> Right <$> liftEffect now
      other -> pure <<< Left <<< LogFailure $ Error { status: Just other, message: r.statusText }

      StatusCode 403 -> 
        throwError $ LogFailure Forbidden
      StatusCode 200 -> 
        withExceptT (LogFailure <<< ParseFailure r.body) $ do
          event <- except $ decodeJson r.body
          timeEvent <- traverse parseDate event
          case timeEvent of 
              StartEvent _ -> throwError $ "Expected stop event, got start."
              StopEvent  t -> pure $ fromDateTime t
      other -> 
        throwError <<< LogFailure $ Error { status: Just other, message: r.statusText }

import Prelude
import Control.Monad.Trans.Class (lift)
import Control.Monad.Except.Trans (ExceptT, except)

import Data.Argonaut.Core (Json)

import Data.Argonaut.Core (Json, stringify)
import Data.Argonaut.Decode (decodeJson)
import Data.DateTime (DateTime)
import Data.Either (note)
import Data.JSDate as JSDate

import Effect (Effect)

instance showAPIError :: Show APIError where
  show = case _ of
    Forbidden -> "Forbidden"
    ParseFailure js e -> "ParseFailure (" <> show (stringify js) <> ") " <> show e 
    Error r -> "Error { status: " <> show r.status <> ", message: " <> r.message <> "}"
parseJsonDate :: Json -> ExceptT String Effect DateTime
parseJsonDate json = do
  str    <- except $ decodeJson json
  parseDate str

parseDate :: String -> ExceptT String Effect DateTime
parseDate str = do
  jsDate <- lift $ JSDate.parse str
  except $ note ("Unable to convert date " <> show jsDate <> " to a valid DateTime value.") 
                (JSDate.toDateTime jsDate)

creditToParser' mode f v =
  let

creditToParser' mode f v = do
  tn <- typename f
  if tn /= "credit_to_t"
    then returnError Incompatible f "column was not of type credit_to_t"
    else maybe empty (pure . parser . decodeUtf8) v
  where

    parser "credit_to_address" =
      CreditToCurrency <$> (addressParser mode <* nullField <* nullField)
    parser "credit_to_user" =
      CreditToUser <$> (nullField *> nullField *> idParser UserId <* nullField)
    parser "credit_to_project" =
      CreditToProject
        <$> (nullField *> nullField *> nullField *> idParser ProjectId)
    parser _ = empty
  in
    do
      tn <- typename f
      if tn /= "credit_to_t"
        then returnError Incompatible f "column was not of type credit_to_t"
        else maybe empty (pure . parser . decodeUtf8) v

    parser = \case
      "credit_to_address" -> CreditToCurrency <$> (addressParser mode     <* nullField       <* nullField)
      "credit_to_user"    -> CreditToUser     <$> (nullField *> nullField *> idParser UserId <* nullField)
      "credit_to_project" -> CreditToProject  <$> (nullField *> nullField *> nullField       *> idParser ProjectId)
      _ -> empty