import           Data.Thyme.Format ()

  } deriving Eq

  } deriving (Eq, Show)

  comparing costRatio

  comparing costRatio `mappend` comparing (^. bidTime)

      takeWinningBids total (x : xs)

      takeWinningBids total (bid : xs)

        | total + (x ^. bidAmount) < raiseAmount' =
          x : takeWinningBids (total + (x ^. bidAmount)) xs

        | total + (bid ^. bidAmount) < raiseAmount' =
          bid : takeWinningBids (total + (bid ^. bidAmount)) xs

              winFraction = toRational remainder / toRational (x ^. bidAmount)
              remainderSeconds = Seconds . round $ winFraction * toRational (x ^. bidSeconds)

              winFraction = toRational remainder / toRational (bid ^. bidAmount)
              remainderSeconds = Seconds . round $ winFraction * toRational (bid ^. bidSeconds)

          in  [x & bidSeconds .~ remainderSeconds & bidAmount .~ remainder]

          in  [bid & bidSeconds .~ remainderSeconds & bidAmount .~ remainder]

import           Control.Lens

--import           Data.Thyme.Clock as C

import           Text.Read (read)

import           Test.QuickCheck

--import           Test.QuickCheck

spec = do
  describe "bid ordering" $
    it "ensures that bids with lowest seconds/btc ratio are first" $
      let testB1 = Bid (UserId nil) (Seconds 60) (Satoshi 1000) undefined
          testB2 = Bid (UserId nil) (Seconds 60) (Satoshi 100) undefined
          testB3 = Bid (UserId nil) (Seconds 90) (Satoshi 100) undefined
      in do

spec = 
  let testB0 = Bid (UserId nil) (Seconds 3)  (Satoshi 100) (read "2016-03-05 15:59:26.033176 UTC")
      testB1 = Bid (UserId nil) (Seconds 60) (Satoshi 1000)(read "2016-03-05 15:59:26.033177 UTC")
      testB2 = Bid (UserId nil) (Seconds 60) (Satoshi 100) (read "2016-03-05 15:59:26.033178 UTC")
      testB3 = Bid (UserId nil) (Seconds 90) (Satoshi 100) (read "2016-03-05 15:59:26.033179 UTC")
      testB4 = Bid (UserId nil) (Seconds 60) (Satoshi 100) (read "2016-03-05 15:59:26.033180 UTC")
  in do 
    describe "bid ordering" $ do
      it "ensures that bids with lowest seconds/btc ratio are first" $ do
        bidOrder testB0 testB1 `shouldBe` LT

      it "ensures breaks ties in bid ordering by timestamp" $ do
        bidOrder testB2 testB4 `shouldBe` LT

  describe "winning bids" $ 
    it "determines a sufficient number of winners to fulfill the raise amount" $
      True `shouldBe` True

    describe "winning bids" $ do
      it "determines a sufficient number of winners to fulfill the raise amount" $
        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]