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

{-# LANGUAGE ScopedTypeVariables, OverloadedStrings, NoImplicitPrelude, TemplateHaskell #-}

import Control.Lens

  { raiseAmount :: BTC
  , endsAt :: UTCTime 

  { _raiseAmount :: BTC
  , _endsAt :: UTCTime 

makeLenses ''Auction

  { userId :: UserId
  , seconds :: Seconds
  , btcAmount :: BTC

  { _userId :: UserId
  , _seconds :: Seconds
  , _btcAmount :: BTC

makeLenses ''Bid

    where costRatio bid = (toRational . seconds $ bid) / (toRational . runBTC . btcAmount $ bid) 

    where 
      bidSeconds bid = toRational $ bid ^. seconds
      bidAmount  bid = toRational $ bid ^. (btcAmount . btc)
      costRatio  bid = bidSeconds bid / bidAmount bid

        | total ++ btcAmount x < raiseAmount auction = 
          x : (takeWinningBids (total ++ btcAmount x) xs)

        | (total ++ x ^. btcAmount) < (auction ^. raiseAmount) = 
          x : (takeWinningBids (total ++ x ^. btcAmount) xs)

        | total < raiseAmount auction = 
          let remainder = raiseAmount auction <> invert total
              winFraction = (toRational . runBTC $ remainder) / (toRational . runBTC $ btcAmount x)
              remainderSeconds = Seconds . round $ winFraction * (toRational . seconds $ x)
          in  [Bid (userId x) remainderSeconds remainder]

        | total < auction ^. raiseAmount = 
          let remainder = (auction ^. raiseAmount) ++ invert total
              winFraction :: Rational
              winFraction = (toRational $ remainder ^. btc) / (toRational $ x ^. (btcAmount . btc))
              remainderSeconds = Seconds . round $ winFraction * (toRational $ x ^. seconds)
          in  [x & seconds .~ remainderSeconds & btcAmount .~ remainder]

import Control.Lens

import Data.Text.Lens

import Quixotic.Auction

import Quixotic.Users

    , newAuction = undefined
    , readAuction = undefined
    , recordBid = undefined
    , readBids = undefined
    , createUser = undefined

    , newAuction = newAuction'
    , readAuction = readAuction'
    , recordBid = recordBid'
    , readBids = readBids'
    , createUser = createUser'

    [ ("btcAddr", unpack (address ba))

    [ ("btcAddr", ba ^. address ^. from packed)

newAuction' :: Auction -> ReaderT a (EitherT Text IO) AuctionId
newAuction' = undefined
readAuction' :: AuctionId -> ReaderT a (EitherT Text IO) Auction
readAuction' = undefined
recordBid' :: UTCTime -> Bid -> ReaderT a (EitherT Text IO) ()
recordBid' = undefined
readBids' :: AuctionId -> ReaderT a (EitherT Text IO) [(UTCTime, Bid)]
readBids' = undefined
createUser' :: User -> ReaderT a (EitherT Text IO) UserId
createUser' = undefined

{-# LANGUAGE NoImplicitPrelude #-}

{-# LANGUAGE NoImplicitPrelude, TemplateHaskell #-}

module Quixotic
  ( BtcAddr(address)
  , parseBtcAddr
  , BTC(..)
  ) where

module Quixotic where

import qualified Data.Text as T

import Control.Lens

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

newtype BtcAddr = BtcAddr { _address :: Text } deriving (Show, Eq, Ord)
makeLenses ''BtcAddr

newtype BTC = BTC { runBTC :: Integer } deriving (Show, Eq, Ord)

newtype BTC = BTC { _btc :: Integer } deriving (Show, Eq, Ord)
makeLenses ''BTC

  (<>) b1 b2 = BTC $ runBTC b1 + runBTC b2

  (<>) b1 b2 = BTC $ _btc b1 + _btc b2

  invert b = BTC . negate . runBTC $ b

  invert b = BTC . negate . _btc $ b

parseBtcAddr :: T.Text -> Maybe BtcAddr

parseBtcAddr :: Text -> Maybe BtcAddr