{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE OverloadedStrings #-}

import qualified Data.ByteString.Char8 as BS
import Data.Csv (FromField (..), FromRecord, ToField (..), ToRecord)

import Data.Text.Encoding (decodeUtf8Lenient)

import Control.Monad

type Category = Refined NonEmpty Text
type CardName = Refined NonEmpty Text

import GHC.Generics (Generic)
newtype NonEmptyText = NonEmptyText {runText :: (Refined NonEmpty Text)}
    deriving (Show, Eq, Ord)
type Category = NonEmptyText
type CardName = NonEmptyText
newtype PositiveNumber = PositiveNumber {runNumber :: (Refined Positive Natural)}
    deriving (Show, Eq, Ord)

    , quantity :: !(Refined Positive Natural)

    , quantity :: !PositiveNumber

    deriving (Show, Eq, Ord)

    deriving (Show, Eq, Ord, Generic, FromRecord, ToRecord)
instance FromField NonEmptyText where
    parseField s = (refineFail . decodeUtf8Lenient $ s) >>= return . NonEmptyText
instance FromField PositiveNumber where
    parseField s =
        maybe
            mzero
            (\x -> refineFail x >>= return . PositiveNumber)
            (fromIntegral . fst <$> BS.readInt s)
instance ToField NonEmptyText where
    toField s = error "not implemented"

instance ToField PositiveNumber where
    toField s = error "not implemented"

    runQuantity = fromIntegral . unrefine . quantity

    runQuantity = fromIntegral . unrefine . runNumber . quantity

    exposed-modules:  Deck

    exposed-modules:
        Deck,
        Parser

        cassava >= 0.5 && < 0.6,
        bytestring >= 0.11.5 && < 0.12,