aeson                     >= 0.7.0.2,

    ananke,
    aeson,

    text,
    time,

    ananke

    text,
    time

{-# LANGUAGE DeriveDataTypeable, ScopedTypeVariables #-}

{-# LANGUAGE DeriveDataTypeable, ScopedTypeVariables, OverloadedStrings #-}

import Data.Aeson
import qualified Data.Aeson.Types as A

import qualified Data.Text as T

import Control.Monad

import Debug.Trace

data LogEventParseError = LogEventParseError String deriving (Show, Typeable)
instance Exception LogEventParseError where

instance FromJSON WorkEvent where
  parseJSON (Object jv) = do
    t <- jv .: "type" :: A.Parser T.Text
    case t of
      "start" -> StartWork <$> jv .: "timestamp"     
      "stop"  -> StopWork <$> jv .: "timestamp"
      _ -> mzero

-- instance FromField WorkEvent where
--   fromField f m = let fromText "start_work" = return StartWork
--                       fromText "stop_work"  = return StopWork
--                       fromText a = conversionError $ LogEventParseError $ "unrecognized log event type " ++ a
--                   in fromField f m >>= fromText

data LogEntry = LogEntry 
  { btcAddr :: BtcAddr
  , event :: WorkEvent 
  } deriving (Show, Eq)

data LogEntry = LogEntry { btcAddr :: BtcAddr
                         , event :: WorkEvent 
                         } deriving (Show, Eq)

instance FromJSON LogEntry where
  parseJSON (Object jv) = LogEntry <$>
                          jv .: "btcAddr" <*>
                          jv .: "workEvent"

-- instance FromRow LogEntry where
--   fromRow = LogEntry <$> field <*> field <*> field 

  parseJSON _ = mzero

data LogInterval = LogInterval { intervalBtcAddr :: BtcAddr
                               , workInterval :: Interval
                               } deriving (Show, Eq) 

data LogInterval = LogInterval 
  { intervalBtcAddr :: BtcAddr
  , workInterval :: Interval
  } deriving (Show, Eq) 

intervals logEntries = M.map (bimap (fmap event) (fmap workInterval)) $ F.foldl' appendLogEntry M.empty logEntries

intervals logEntries = 
  let logSum = F.foldl' appendLogEntry M.empty logEntries
  in M.map (bimap (fmap event) (fmap workInterval)) $ logSum

reduceToIntervals misaligned = misaligned

reduceToIntervals misaligned = 
  misaligned

  let depf = undefined
  Depreciation depf

  let depf ndt = undefined
  in Depreciation depf
-- data LogEventParseError = LogEventParseError String deriving (Show, Typeable)
-- instance Exception LogEventParseError where
-- instance FromField WorkEvent where
--   fromField f m = let fromText "start_work" = return StartWork
--                       fromText "stop_work"  = return StopWork
--                       fromText a = conversionError $ LogEventParseError $ "unrecognized log event type " ++ a
--                   in fromField f m >>= fromText
-- instance FromRow LogEntry where
--   fromRow = LogEntry <$> field <*> field <*> field 

import Data.Aeson
import Data.Aeson.Types as JV
import Control.Monad

instance FromJSON BtcAddr where
  parseJSON (JV.String t) = return $ BtcAddr t
  parseJSON _ = mzero

import Data.Aeson

  describe "work event parsing" $ do
    it "parses a start event" $ do
      let startText = "{\"type\":\"start\", \"timestamp\":\"2014-03-22T11:37:08Z\"}"
          expected = fmap StartWork $ parseISO8601 "2014-03-22T11:37:08Z"
      (decode startText) `shouldBe` expected