interval s e = if s < e then Just (Interval s e) else Nothing

interval s e = if s < e then Interval s e else Interval e s

import Data.Map

import Data.Foldable as F
import Data.Map.Strict as M

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

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

type WorkIndex = Map BtcAddr ([LogEntry], [LogInterval])

intervals :: [LogEntry] -> [LogInterval]
intervals e = undefined

intervals :: Foldable f => f LogEntry -> WorkIndex
intervals = F.foldl' appendLogEntry M.empty 
appendLogEntry :: WorkIndex -> LogEntry -> WorkIndex
appendLogEntry workIndex entry = let acc = reduce $ pushEntry entry workIndex 
                                 in insert (btcAddr entry) acc workIndex

groupBy f = fromListWith (++) . fmap (f &&& pure)

pushEntry :: LogEntry -> WorkIndex -> ([LogEntry], [LogInterval])
pushEntry entry idx = consLeft entry $ findWithDefault ([], []) (btcAddr entry) idx where 
                      consLeft a (ex, ix) = (a : ex, ix)
reduce :: ([LogEntry], [LogInterval]) -> ([LogEntry], [LogInterval])
reduce ((LogEntry addr end StopWork) : (LogEntry _ start StartWork) : xs, intervals) = (xs, (LogInterval addr (interval start end)) : intervals)
reduce other = other

  , btcAddr

  , parseBtcAddr

newtype BtcAddr = BtcAddr { address :: T.Text } deriving (Show, Eq)

newtype BtcAddr = BtcAddr { address :: T.Text } deriving (Show, Eq, Ord)

btcAddr :: T.Text -> Maybe BtcAddr
btcAddr = Just . BtcAddr -- this will be changed to do validation

parseBtcAddr :: T.Text -> Maybe BtcAddr
parseBtcAddr = Just . BtcAddr -- this will be changed to do validation