, WorkIndex

  , WorkIndex(WorkIndex), _WorkIndex

import Data.Heap as H
import Data.List.NonEmpty as L

instance Ord EventType where
  compare StartWork StopWork = LT
  compare StopWork StartWork = GT
  compare _ _ = EQ

instance Ord LogEntry where
  compare a b = 
    let ordElems e = (e ^. (event.eventTime), e ^. (event.eventType), e ^. btcAddr)
    in  ordElems a `compare` ordElems b

type WorkIndex = Map BtcAddr [Interval]

newtype WorkIndex = WorkIndex (Map BtcAddr (NonEmpty Interval)) deriving (Show, Eq)
makePrisms ''WorkIndex

workIndexJSON widx = toJSON $ (fmap intervalJSON) <$> (MS.mapKeysWith (++) (^._BtcAddr) widx)

workIndexJSON (WorkIndex widx) = 
  toJSON $ (L.toList . fmap intervalJSON) <$> (MS.mapKeysMonotonic (^._BtcAddr) widx)

payouts dep ptime widx = 

payouts dep ptime (WorkIndex widx) = 

  let logSum :: RawIndex
      logSum = F.foldl' appendLogEntry MS.empty logEntries
  in  fmap (fmap workInterval . snd) $ logSum

  let sortedEntries :: Heap LogEntry
      sortedEntries = F.foldr H.insert H.empty $ logEntries
      rawIndex :: RawIndex
      rawIndex = F.foldl' appendLogEntry MS.empty $ sortedEntries
      accum k (_, l) m = case nonEmpty l of 
        Just l' -> MS.insert k (workInterval <$> l') m
        Nothing -> m
  in  WorkIndex $ MS.foldrWithKey accum MS.empty rawIndex

  in  insert (entry ^. btcAddr) acc idx

  in  MS.insert (entry ^. btcAddr) acc idx

{-|
 - Find the set of accumulated log intervals and log entries
 - for a given BTC address, and concatenate the entry to the entry list.
 -}

    , template-haskell

    , base64-bytestring    >= 1.0.0.1

    , blaze-builder        

    , lens                 >= 4.4.0.2
    , safe                 >= 0.3.8

    , groups               >= 0.4
    , heaps                >= 0.3.1
    , hourglass            >= 0.2.6    && < 0.3
    , lens                 >= 4.4.0.2
    , network-bitcoin      >= 1.7.0

    , sqlite-simple        >= 0.4.8    && < 0.5

    , blaze-builder        

    , safe                 >= 0.3.8
    , semigroups
    , sqlite-simple        >= 0.4.8    && < 0.5
    , template-haskell

    , hourglass            >= 0.2.6    && < 0.3
    , groups               >= 0.4
    , network-bitcoin      >= 1.7.0
    , base64-bytestring    >= 1.0.0.1

    , QuickCheck >= 2.7

    , hspec >= 1.8.1
    , iso8601-time
    , lens
    , QuickCheck >= 2.7
    , semigroups

    , iso8601-time
    , hspec >= 1.8.1

import Test.Hspec

import Control.Lens ((^.))
import Data.AffineSpace
import Data.List.NonEmpty as L 
import Data.Map.Strict as M
import Data.Time.ISO8601
import Data.Thyme.Time as T

import Quixotic.TimeLog as L

import Quixotic.TimeLog 

import Data.AffineSpace
import Data.Map.Strict as M
import Data.Time.ISO8601
import Data.Thyme.Clock
import Data.Thyme.Time
import qualified Data.Text as T

import Test.Hspec

  arbitrary = BtcAddr . T.pack <$> vectorOf 34 arbitrary

  arbitrary = BtcAddr . pack <$> vectorOf 34 arbitrary

    start <- arbitrary

    startTime <- arbitrary

    pure $ I.interval start (start .+^ delta)
    

    pure $ I.interval startTime (startTime .+^ delta)
instance Arbitrary WorkIndex where
  arbitrary = 
    let record = (,) <$> arbitrary <*> (L.fromList <$> listOf1 arbitrary)
    in  WorkIndex . M.fromList <$> listOf record

    it "reduces a log to a work index" $ do
      let testAddrs = catMaybes [ parseBtcAddr "123"
                                , parseBtcAddr "456"
                                , parseBtcAddr "789" ]

    it "reduces a log to a work index" $ 
      let testAddrs = L.fromList $ catMaybes 
            [ parseBtcAddr "123"
            , parseBtcAddr "456"
            , parseBtcAddr "789" ]

          starts    = toThyme <$> catMaybes [ parseISO8601 "2014-01-01T00:08:00Z"
                                            , parseISO8601 "2014-02-12T00:12:00Z" ]

          starts = L.fromList $ toThyme <$> catMaybes 
            [ parseISO8601 "2014-01-01T00:08:00Z"
            , parseISO8601 "2014-02-12T00:12:00Z" ]

          ends      = toThyme <$> catMaybes [ parseISO8601 "2014-01-01T00:12:00Z"
                                            , parseISO8601 "2014-02-12T00:18:00Z" ]

          ends   = L.fromList $ toThyme <$> catMaybes 
            [ parseISO8601 "2014-01-01T00:12:00Z"
            , parseISO8601 "2014-02-12T00:18:00Z" ]

          testLogEntries :: [LogEntry]

          testLogEntries :: NonEmpty LogEntry

            (start', end') <- zip starts ends
            [ LogEntry addr (WorkEvent StartWork start' Nothing), LogEntry addr (WorkEvent StopWork end' Nothing) ]

            (start', end') <- L.zip starts ends
            L.fromList [ LogEntry addr (WorkEvent StartWork start' Nothing)
                       , LogEntry addr (WorkEvent StopWork end' Nothing) ]

          testIntervals :: [LogInterval]
          testIntervals = do

          testIntervals :: NonEmpty LogInterval
          testIntervals = L.reverse $ do

            (start', end') <- zip starts ends
            return $ LogInterval addr (I.interval start' end')

            (start', end') <- L.zip starts ends
            pure $ LogInterval addr (I.interval start' end')
          expected :: WorkIndex
          expected = WorkIndex . fromListWith (<>) . L.toList $ (intervalBtcAddr &&& pure . workInterval) <$> testIntervals

          expected0 :: Map BtcAddr ([LogEntry], [LogInterval])
          expected0 = fmap (const [] &&& id) . fromListWith (++) . fmap (intervalBtcAddr &&& return) $ testIntervals

      in (workIndex testLogEntries) `shouldBe` expected

          expected :: WorkIndex
          expected = fmap (fmap workInterval . snd) expected0

    it "recovers a work index from events" $ property $
      \widx -> 
        let ivalEntries addr ival = [ LogEntry addr (WorkEvent StartWork (ival ^. start) Nothing)
                                    , LogEntry addr (WorkEvent StopWork  (ival ^. end) Nothing) ]

      (workIndex testLogEntries) `shouldBe` expected

            acc k a b = b ++ (L.toList a >>= ivalEntries k)
            logEntries = foldrWithKey acc [] (widx ^. _WorkIndex)
        in  workIndex logEntries `shouldBe` widx

{--
(fromList [
(BtcAddr "S\187\156\a\SOx\229`[\133a%7o%'XBt\249\226\n\ENQ\SOH\GS<\241WU5{Si\251",
  [ Interval {_start = 1858-11-16 23:59:59.999997 UTC, _end = 1858-11-16 23:59:59.999997 UTC}
  , Interval {_start = 1858-11-16 23:59:59.999998 UTC, _end = 1858-11-17 00:00:00.000002 UTC}]),
(BtcAddr "\138;\GS\132U0\SUB\ESCf[\NAKo`\ACKR[\EMq\b\v\159\184u\ACK&jS#n#?\SI&v",
  [Interval {_start = 1858-11-16 23:59:59.999999 UTC, _end = 1858-11-17 00:00:00 UTC}
  ,Interval {_start = 1858-11-17 00:00:00.000002 UTC, _end = 1858-11-17 00:00:00.000006 UTC}
  ,Interval {_start = 1858-11-16 23:59:59.999994 UTC, _end = 1858-11-16 23:59:59.999998 UTC}])
])
 -}