import Data.Time.Duration (Hours)

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

parseBillableIdJSON :: String -> Either JsonDecodeError BillableId
parseBillableIdJSON uuidStr = 
    BillableId <$> note (TypeMismatch"Failed to decode billable UUID") (parseUUID uuidStr)

    uuidStr <- obj .: "billableId"
    BillableId <$> note (TypeMismatch"Failed to decode billable UUID") (parseUUID uuidStr)

    parseBillableIdJSON =<< obj .: "billableId"

  , gracePeriod :: Hours

  , gracePeriod :: Days

  -- API requires grace period as days

  , requestExpiryPeriod: unwrap b.expiryPeriod

  -- API requires expiry period as seconds
  , requestExpiryPeriod: unwrap b.expiryPeriod * 60.0 * 60.0

-- parseBillableJSON :: Object Json -> Either JsonDecodeError (Tuple BillableId Billable)
-- parseBillableJSON obj = do
--   billableId <- parseBillableIdJSON =<< obj .: "billableId"
--   bobj <- obj .: "billable"
--   amount <- 
--     Zatoshi <$> (note (TypeMismatch "Failed to decode as Zatoshi") <<< BigInt.fromNumber) 
--             =<< (_ .: "zatoshi")
--             =<< (bobj .: "amount")
--   gracePeriod <- Hours <$> bobj .: "gracePeriod"
--   recurrence <- parseRecurrence =<< bobj .: "recurrence"

import Data.Time.Duration (Hours(..))

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

  , gracePeriod :: Maybe Hours

  , gracePeriod :: Maybe Days

              [ HH.text "Grace Period (Hours)" ] 

              [ HH.text "Grace Period (Days)" ] 

              , P.placeholder "Hours until a bill is considered overdue"

              , P.placeholder "Days until a bill is considered overdue"

             (Just n) -> H.modify_ (_ { gracePeriod = Just (Hours n) })

             (Just n) -> H.modify_ (_ { gracePeriod = Just (Days n) })

            lift $ system.log "BILLABLE OK"