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

import Control.Alternative ((<|>))
-- import Control.Monad.Error.Class (throwError)
-- import Control.Monad.Except.Trans (runExceptT, except, withExceptT)

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

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

import Data.BigInt (toNumber)

import Data.BigInt (toNumber, fromNumber) as BigInt

import Foreign.Object (Object)

import Data.Tuple (Tuple)
-- import Data.Traversable (class Traversable, traverse)

import Data.Tuple (Tuple(..))
import Data.Traversable (traverse)

import Affjax (post, printError)

import Affjax (post, get)

import Affjax.StatusCode (StatusCode(..))

-- import Affjax.StatusCode (StatusCode(..))

  ( Zatoshi )

  ( Zatoshi(..) )

-- import Aftok.Api.Json
--   ( Decode
--   , decompose
--   , parseDatedResponse
--   , parseDatedResponseMay
--   )

import Aftok.Api.Json
  ( parseResponse
  )

  , amount: toNumber (unwrap b.amount)

  , amount: BigInt.toNumber (unwrap b.amount)

-- 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"

parseRecurrence :: Json -> Either JsonDecodeError Recurrence
parseRecurrence json = do
  obj <- decodeJson json
  let annually = traverse (map \(_ :: Unit) -> Annually) (obj .:? "annually")
      monthly =  traverse (map Monthly) (obj .:? "monthly")
      weekly =   traverse (map Weekly) (obj .:? "weekly")
      onetime =  traverse (map \(_ :: Unit) -> OneTime) (obj .:? "onetime")
  join $ note (UnexpectedValue json) (annually <|> monthly <|> weekly <|> onetime)
      

parseBillableJSON :: Object Json -> Either JsonDecodeError (Tuple BillableId Billable)
parseBillableJSON obj = do
  billableId <- parseBillableIdJSON =<< obj .: "billableId"
  bobj <- obj .: "billable"
  name :: String <- bobj .: "name"
  description :: String <- bobj .: "description"
  let message = ""
  recurrence :: Recurrence <- parseRecurrence =<< bobj .: "recurrence"
  amount <- 
    map Zatoshi 
      $   (note (TypeMismatch "Failed to decode as Zatoshi") <<< BigInt.fromNumber) 
      =<< (_ .: "zatoshi")
      =<< (bobj .: "amount")
  gracePeriod <- Days <$> bobj .: "gracePeriod"
  expiryPeriod <- Hours <$> bobj .: "gracePeriod"
  pure $ Tuple billableId {name, description, message, recurrence, amount, gracePeriod, expiryPeriod }

  runExceptT $ case response of 
    Left err -> throwError $ Error { status: Nothing, message: printError err }
    Right r -> case r.status of
      StatusCode 403 -> throwError $ Forbidden
      StatusCode 200 -> withExceptT ParseFailure <<< except $ decodeJson r.body
      other -> throwError $ Error { status: Just other, message: r.statusText }

  parseResponse decodeJson response

listProjectBillables pid = pure $ Left Forbidden

listProjectBillables pid = do
  response <- get RF.json ("/api/projects/" <> pidStr pid <> "/billables")
  parseResponse (traverse parseBillableJSON <=< decodeJson) response

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

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

import Effect.Aff (Aff)

parseResponse ::
  forall a.
  Decode a -> 
  Either AJAX.Error (Response Json) ->
  Aff (Either APIError a)
parseResponse decode response = 
  runExceptT $ case response of 
    Left err -> throwError $ Error { status: Nothing, message: printError err }
    Right r -> case r.status of
      StatusCode 403 -> throwError $ Forbidden
      StatusCode 200 -> withExceptT ParseFailure <<< except $ decode r.body
      other -> throwError $ Error { status: Just other, message: r.statusText }

-- import Data.Unfoldable as U

import Data.Unfoldable as U

import Data.Tuple (Tuple)

import Data.Tuple (Tuple(..))

import Aftok.Zcash (toZEC, zecString)

                  [ Modals.modalButton "createBillable" "Create billable"

                  [ renderBillableList st.billables
                  , Modals.modalButton "createBillable" "Create billable"

  renderBillableList :: Array (Tuple BillableId Billable) -> H.ComponentHTML BillingAction Slots m
  renderBillableList billables = 
    HH.div
      [ P.classes (ClassName <$> [ "container-fluid" ]) ]
      [ HH.section
          [ P.id_ "projectOverview", P.classes (ClassName <$> [ "pt-3" ]) ]
          ([ HH.div
              -- header
              [ P.classes (ClassName <$> [ "row", "pt-3", "font-weight-bold" ]) ]
              [ colmd2 (Just "Billable Name")
              , colmd2 (Just "Description")
              , colmd2 (Just "Amount")
              , colmd2 (Just "Recurrence")
              , colmd2 Nothing
              ] 
          ] <> (billableRow <$> billables))
      ]
    
    where
      billableRow (Tuple bid b) = 
        HH.div
          [ P.classes (ClassName <$> [ "row", "pt-3" ]) ]
          [ colmd2 (Just b.name)
          , colmd2 (Just b.description)
          , colmd2 (Just (zecString <<< toZEC $ b.amount))
          ]
  colmd2 :: forall i w. Maybe String -> HH.HTML i  w
  colmd2 xs = HH.div [ P.classes (ClassName <$> [ "col-md-2" ]) ] (U.fromMaybe $ HH.text <$> xs)

        billables <- lift $ traverse (caps.listProjectBillables <<< (_.projectId) <<< unwrap) currentProject
        case billables of
          Nothing -> pure unit
          Just (Left err) -> lift $ system.error (show err)
          Just (Right b) -> H.modify_ (_ { billables = b })

        refreshBillables currentProject

        refreshBillables currentProject

      BillableCreated _ ->
        pure unit

      BillableCreated _ -> do
        currentProject <- H.gets (_.selectedProject)
        refreshBillables currentProject
    where 
      refreshBillables currentProject = do
        billables <- lift $ traverse (caps.listProjectBillables <<< (_.projectId) <<< unwrap) currentProject
        case billables of
          Nothing -> pure unit
          Just (Left err) -> lift $ system.error (show err)
          Just (Right b) -> H.modify_ (_ { billables = b })

import Data.Fixed (Fixed, P1000000, TenTimes, fromInt,  numerator) 

import Data.Fixed (Fixed, P1000000, TenTimes, fromInt, numerator, fromBigInt) 

toZEC :: Zatoshi -> ZEC
toZEC (Zatoshi z) = 
  ZEC $ fromBigInt z / fromInt 100000000

    haskellPackages.HDBC-postgresql
    haskellPackages.dbmigrations-postgresql