--, network-bitcoin     >= 1.8      && < 1.9

    , HUnit

    , network-bitcoin

import           Data.Thyme.Clock as C

import           Data.Thyme.Clock  as C

data AuctionResult
  = WinningBids [Bid]
  | InsufficientBids Satoshi
  deriving (Show, Eq)
bidsTotal :: [Bid] -> Satoshi
bidsTotal bids =
  foldl' (\s b -> s + (b^.bidAmount)) (Satoshi 0) bids

winningBids :: Auction -> [Bid] -> [Bid]
winningBids auction = winningBids' (auction ^. raiseAmount) 

runAuction :: Auction -> [Bid] -> AuctionResult
runAuction auction = runAuction' (auction ^. raiseAmount)

winningBids' :: Satoshi -> [Bid] -> [Bid]
winningBids' raiseAmount' bids = 

runAuction' :: Satoshi -> [Bid] -> AuctionResult
runAuction' raiseAmount' bids =

  in  takeWinningBids 0 $ sortBy bidOrder bids

      submittedTotal = bidsTotal bids
  in  if submittedTotal >= raiseAmount'
        then WinningBids $ takeWinningBids 0 $ sortBy bidOrder bids
        else InsufficientBids (raiseAmount' - submittedTotal)

{-# OPTIONS_GHC -Wwarn #-}

{-# OPTIONS_GHC -Wwarn -fno-warn-orphans #-}

--import           Data.Thyme.Clock as C

import           Data.Thyme.Clock ()

import           Text.Read (read)

import           Text.Read        (read)

--import           Test.QuickCheck

import           Test.HUnit.Base  (assertFailure)
import           Test.QuickCheck
uuidGen :: Gen UUID
uuidGen = fromWords <$> arbitrary <*> arbitrary <*> arbitrary <*> arbitrary
genSatoshi :: Gen Satoshi
genSatoshi = Satoshi <$> arbitrary
genBid :: Gen Bid
genBid = Bid <$> (UserId <$> uuidGen)
             <*> (Seconds <$> arbitrary `suchThat` (>= 0))
             <*> genSatoshi `suchThat` (> Satoshi 0)
             <*> arbitrary

spec = 

spec =

  in do 

  in do

        let winners = winningBids' (Satoshi 1250) [testB0, testB1, testB2, testB3, testB4] 
            split   = Bid (UserId nil) (Seconds 30) (Satoshi 50) (testB4 ^. bidTime)
        in  sortBy bidOrder winners `shouldBe` sortBy bidOrder [testB0, testB1, testB2, split]

        let result   = runAuction' (Satoshi 1250) [testB0, testB1, testB2, testB3, testB4]
            split    = Bid (UserId nil) (Seconds 30) (Satoshi 50) (testB4 ^. bidTime)
            expected = sortBy bidOrder [testB0, testB1, testB2, split]
        in  case result of
          WinningBids winners ->
            sortBy bidOrder winners `shouldBe` expected
          InsufficientBids t  ->
            assertFailure "Sufficinent bids were presented, but auction algorithm asserted otherwise."

      it "ensures that the raise amount is fully consumed by the winning bids" $
        forAll ((,) <$> genSatoshi <*> listOf genBid) $
          \(raiseAmount', bids) ->
            case runAuction' raiseAmount' bids of
              WinningBids xs     -> bidsTotal xs == raiseAmount'
              InsufficientBids t -> t == (raiseAmount' - bidsTotal bids)

instance Arbitrary BtcAddr where
  arbitrary = BtcAddr . pack <$> vectorOf 34 arbitrary

genBtcAddr :: Gen BtcAddr
genBtcAddr =
  BtcAddr . pack <$> vectorOf 34 arbitrary

instance Arbitrary Interval where
  arbitrary = do
    startTime <- arbitrary
    delta <- arbitrary :: Gen (Positive T.NominalDiffTime)
    pure $ I.interval startTime (startTime .+^ getPositive delta)

genInterval :: Gen I.Interval
genInterval = do
  startTime <- arbitrary
  delta <- arbitrary :: Gen (Positive T.NominalDiffTime)
  pure $ I.interval startTime (startTime .+^ getPositive delta)

newtype Intervals = Intervals (L.NonEmpty Interval)

genIntervals :: Gen (L.NonEmpty I.Interval)
genIntervals =
  let deltas = fmap T.fromSeconds <$> ((listOf $ choose (0, 72 * 60 * 60)) :: Gen[Int])

buildIntervals :: T.UTCTime -> [NominalDiffTime] -> [Interval]
buildIntervals t (d : s : dx) | d > 0 =
  let ival = I.interval t (t .+^ d)
  in  ival : buildIntervals (ival ^. end .+^ s) dx
buildIntervals _ _ = []
instance Arbitrary Intervals where
  arbitrary = do

      buildIntervals :: T.UTCTime -> [NominalDiffTime] -> [I.Interval]
      buildIntervals t (d : s : dx) | d > 0 =
        let ival = I.interval t (t .+^ d)
        in  ival : buildIntervals (ival ^. I.end .+^ s) dx
      buildIntervals _ _ = []
  in  do

    let deltas = fmap T.fromSeconds <$> ((listOf $ choose (0, 72 * 60 * 60)) :: Gen[Int])

    pure . Intervals $ L.fromList intervals

    pure $ L.fromList intervals

instance Arbitrary WorkIndex where
  arbitrary =
    let record = do addr <- arbitrary
                    Intervals ivals <- arbitrary
                    pure (addr, ivals)
    in  WorkIndex . M.fromList <$> listOf record

genWorkIndex :: Gen WorkIndex
genWorkIndex =
  let record = do addr <- genBtcAddr
                  ivals <- genIntervals
                  pure (addr, ivals)
  in  WorkIndex . M.fromList <$> listOf record

    it "recovers a work index from events" $ property $
      \(WorkIndex widx) ->
        let mergeAdjacent ((Interval s e) : (Interval s' e') : xs) | e == s' = mergeAdjacent $ Interval s e' : xs

    it "recovers a work index from events" $
      forAll genWorkIndex $ \(WorkIndex widx) ->
        let mergeAdjacent ((I.Interval s e) : (I.Interval s' e') : xs) | e == s' = mergeAdjacent $ I.Interval s e' : xs