{-# LANGUAGE TemplateHaskell   #-}

module Tests.Set (setTests) where

import           Data.Foldable
import           Data.Functor.Identity
import           Data.Semigroup.Foldable
import           Hedgehog
import           Test.Tasty
import           Tests.Util
import qualified Data.Set                   as S
import qualified Data.Set.NonEmpty          as NES
import qualified Data.Set.NonEmpty.Internal as NES
import qualified Hedgehog.Gen               as Gen
import qualified Hedgehog.Range             as Range

setTests :: TestTree
setTests = groupTree $$(discover)





prop_valid :: Property
prop_valid = property $
    assert . NES.valid =<< forAll neSetGen

prop_valid_toSet :: Property
prop_valid_toSet = property $ do
    assert . S.valid . NES.toSet =<< forAll neSetGen

prop_valid_insertMinSet :: Property
prop_valid_insertMinSet = property $ do
    n  <- forAll $ do
        m <- setGen
        let k = maybe dummyKey (subtract 1) $ S.lookupMin m
        pure $ NES.insertMinSet k m
    assert $ S.valid n

prop_valid_insertMaxSet :: Property
prop_valid_insertMaxSet = property $ do
    n  <- forAll $ do
        m <- setGen
        let k = maybe dummyKey (+ 1) $ S.lookupMax m
        pure $ NES.insertMaxSet k m
    assert $ S.valid n

prop_valid_insertSetMin :: Property
prop_valid_insertSetMin = property $ do
    n  <- forAll $ do
        m <- setGen
        let k = maybe dummyKey (subtract 1) $ S.lookupMin m
        pure $ NES.insertSetMin k m
    assert $ NES.valid n

prop_valid_insertSetMax :: Property
prop_valid_insertSetMax = property $ do
    n  <- forAll $ do
        m <- setGen
        let k = maybe dummyKey (+ 1) $ S.lookupMax m
        pure $ NES.insertSetMax k m
    assert $ NES.valid n

prop_toSetIso1 :: Property
prop_toSetIso1 = property $ do
    m0 <- forAll setGen
    tripping m0 NES.nonEmptySet
                (Identity . maybe S.empty NES.toSet)

prop_toSetIso2 :: Property
prop_toSetIso2 = property $ do
    m0 <- forAll $ Gen.maybe neSetGen
    tripping m0 (maybe S.empty NES.toSet)
                (Identity . NES.nonEmptySet)

prop_read_show :: Property
prop_read_show = readShow neSetGen

prop_show_show1 :: Property
prop_show_show1 = showShow1 neSetGen

prop_splitRoot :: Property
prop_splitRoot = property $ do
    n <- forAll neSetGen
    let rs = NES.splitRoot n
        n' = foldl1 NES.merge rs
    assert $ NES.valid n'
    mapM_ (assert . (`NES.isSubsetOf` n)) rs
    n === n'




prop_insertSet :: Property
prop_insertSet = ttProp (GTKey :-> GTSet :-> TTNESet)
    S.insert
    NES.insertSet

prop_singleton :: Property
prop_singleton = ttProp (GTKey :-> TTNESet)
    S.singleton
    NES.singleton

prop_fromAscList :: Property
prop_fromAscList = ttProp (GTSorted STAsc (GTNEList Nothing (GTKey :&: GTVal)) :-> TTNESet)
    (S.fromAscList   . fmap fst)
    (NES.fromAscList . fmap fst)

prop_fromDescList :: Property
prop_fromDescList = ttProp (GTSorted STDesc (GTNEList Nothing (GTKey :&: GTVal)) :-> TTNESet)
    (S.fromDescList   . fmap fst)
    (NES.fromDescList . fmap fst)

prop_fromDistinctAscList :: Property
prop_fromDistinctAscList = ttProp (GTSorted STAsc (GTNEList Nothing GTKey) :-> TTNESet)
    S.fromDistinctAscList
    NES.fromDistinctAscList

prop_fromDistinctDescList :: Property
prop_fromDistinctDescList = ttProp (GTSorted STDesc (GTNEList Nothing GTKey) :-> TTNESet)
    S.fromDistinctDescList
    NES.fromDistinctDescList

prop_fromList :: Property
prop_fromList = ttProp (GTNEList Nothing GTKey :-> TTNESet)
    S.fromList
    NES.fromList

prop_powerSet :: Property
prop_powerSet = ttProp (GTNESet :-> TTNEList TTNESet)
    (S.toList   . S.drop 1 . NES.powerSetSet)
    (NES.toList            . NES.powerSet   )

prop_insert :: Property
prop_insert = ttProp (GTKey :-> GTNESet :-> TTNESet)
    S.insert
    NES.insert

prop_delete :: Property
prop_delete = ttProp (GTKey :-> GTNESet :-> TTSet)
    S.delete
    NES.delete

prop_member :: Property
prop_member = ttProp (GTKey :-> GTNESet :-> TTOther)
    S.member
    NES.member

prop_notMember :: Property
prop_notMember = ttProp (GTKey :-> GTNESet :-> TTOther)
    S.notMember
    NES.notMember

prop_lookupLT :: Property
prop_lookupLT = ttProp (GTKey :-> GTNESet :-> TTMaybe TTKey)
    S.lookupLT
    NES.lookupLT

prop_lookupGT :: Property
prop_lookupGT = ttProp (GTKey :-> GTNESet :-> TTMaybe TTKey)
    S.lookupGT
    NES.lookupGT

prop_lookupLE :: Property
prop_lookupLE = ttProp (GTKey :-> GTNESet :-> TTMaybe TTKey)
    S.lookupLE
    NES.lookupLE

prop_lookupGE :: Property
prop_lookupGE = ttProp (GTKey :-> GTNESet :-> TTMaybe TTKey)
    S.lookupGE
    NES.lookupGE

prop_size :: Property
prop_size = ttProp (GTNESet :-> TTOther)
    S.size
    NES.size

prop_isSubsetOf :: Property
prop_isSubsetOf = ttProp (GTNESet :-> GTNESet :-> TTOther)
    S.isSubsetOf
    NES.isSubsetOf

prop_isProperSubsetOf :: Property
prop_isProperSubsetOf = ttProp (GTNESet :-> GTNESet :-> TTOther)
    S.isProperSubsetOf
    NES.isProperSubsetOf

prop_disjoint :: Property
prop_disjoint = ttProp (GTNESet :-> GTNESet :-> TTOther)
    NES.disjointSet
    NES.disjoint

prop_union :: Property
prop_union = ttProp (GTNESet :-> GTNESet :-> TTNESet)
    S.union
    NES.union

prop_unions :: Property
prop_unions = ttProp (GTNEList (Just (Range.linear 2 5)) GTNESet :-> TTNESet)
    S.unions
    NES.unions

prop_difference :: Property
prop_difference = ttProp (GTNESet :-> GTNESet :-> TTSet)
    S.difference
    NES.difference

prop_intersection :: Property
prop_intersection = ttProp (GTNESet :-> GTNESet :-> TTSet)
    S.intersection
    NES.intersection

prop_cartesianProduct :: Property
prop_cartesianProduct = ttProp (GTNESet :-> GTNESet :-> TTNEList (TTKey :*: TTKey))
    (\xs -> S.toList   . NES.cartesianProductSet xs)
    (\xs -> NES.toList . NES.cartesianProduct    xs)

prop_disjointUnion :: Property
prop_disjointUnion = ttProp (GTNESet :-> GTNESet :-> TTNEList (TTEither TTKey TTKey))
    (\xs -> S.toList   . NES.disjointUnionSet xs)
    (\xs -> NES.toList . NES.disjointUnion    xs)

prop_filter :: Property
prop_filter = ttProp (gf1 Gen.bool :?> GTNESet :-> TTSet)
    S.filter
    NES.filter

prop_takeWhileAntitone :: Property
prop_takeWhileAntitone = ttProp (GTNESet :-> TTSet)
    (S.takeWhileAntitone   ((< 0) . getKX))
    (NES.takeWhileAntitone ((< 0) . getKX))

prop_dropWhileAntitone :: Property
prop_dropWhileAntitone = ttProp (GTNESet :-> TTSet)
    (S.dropWhileAntitone   ((< 0) . getKX))
    (NES.dropWhileAntitone ((< 0) . getKX))

prop_spanAntitone :: Property
prop_spanAntitone = ttProp (GTNESet :-> TTThese TTNESet TTNESet)
    (S.spanAntitone   ((< 0) . getKX))
    (NES.spanAntitone ((< 0) . getKX))

prop_partition :: Property
prop_partition = ttProp (gf1 Gen.bool :?> GTNESet :-> TTThese TTNESet TTNESet)
    S.partition
    NES.partition

prop_split :: Property
prop_split = ttProp (GTKey :-> GTNESet :-> TTMThese TTNESet TTNESet)
    S.split
    NES.split

prop_splitMember :: Property
prop_splitMember = ttProp (GTKey :-> GTNESet :-> TTOther :*: TTMThese TTNESet TTNESet)
    (\k -> (\(x,y,z) -> (y,(x,z))) . S.splitMember k)
    NES.splitMember

prop_lookupIndex :: Property
prop_lookupIndex = ttProp (GTKey :-> GTNESet :-> TTMaybe TTOther)
    S.lookupIndex
    NES.lookupIndex

prop_elemAt :: Property
prop_elemAt = ttProp (GTSize :-> GTNESet :-> TTKey)
    (\i m -> S.elemAt   (i `mod` S.size   m) m)
    (\i m -> NES.elemAt (i `mod` NES.size m) m)

prop_deleteAt :: Property
prop_deleteAt = ttProp (GTSize :-> GTNESet :-> TTSet)
    (\i m -> S.deleteAt   (i `mod` S.size   m) m)
    (\i m -> NES.deleteAt (i `mod` NES.size m) m)

prop_take :: Property
prop_take = ttProp (GTSize :-> GTNESet :-> TTSet)
    S.take
    NES.take

prop_drop :: Property
prop_drop = ttProp (GTSize :-> GTNESet :-> TTSet)
    S.drop
    NES.drop

prop_splitAt :: Property
prop_splitAt = ttProp (GTSize :-> GTNESet :-> TTThese TTNESet TTNESet)
    S.splitAt
    NES.splitAt

prop_map :: Property
prop_map = ttProp (gf1 keyGen :?> GTNESet :-> TTNESet)
    S.map
    NES.map

prop_mapMonotonic :: Property
prop_mapMonotonic = ttProp (GF valGen go :?> GTNESet :-> TTNESet)
    S.mapMonotonic
    NES.mapMonotonic
  where
    go f (K i t) = K (i * 2) (f t)

prop_foldr :: Property
prop_foldr = ttProp ( gf2 valGen
                  :?> GTOther valGen
                  :-> GTNESet
                  :-> TTOther
                    )
    S.foldr
    NES.foldr

prop_foldl :: Property
prop_foldl = ttProp ( gf2 valGen
                  :?> GTOther valGen
                  :-> GTNESet
                  :-> TTOther
                    )
    S.foldl
    NES.foldl

prop_foldr1 :: Property
prop_foldr1 = ttProp ( gf2 keyGen
                   :?> GTNESet
                   :-> TTOther
                     )
    foldr1
    NES.foldr1

prop_foldl1 :: Property
prop_foldl1 = ttProp ( gf2 keyGen
                   :?> GTNESet
                   :-> TTOther
                     )
    foldl1
    NES.foldl1

prop_foldr' :: Property
prop_foldr' = ttProp ( gf2 keyGen
                   :?> GTOther keyGen
                   :-> GTNESet
                   :-> TTOther
                     )
    S.foldr'
    NES.foldr'

prop_foldl' :: Property
prop_foldl' = ttProp ( gf2 keyGen
                   :?> GTOther keyGen
                   :-> GTNESet
                   :-> TTOther
                     )
    S.foldl'
    NES.foldl'

prop_foldr1' :: Property
prop_foldr1' = ttProp ( gf2 keyGen
                    :?> GTNESet
                    :-> TTOther
                      )
    foldr1
    NES.foldr1'

prop_foldl1' :: Property
prop_foldl1' = ttProp ( gf2 keyGen
                    :?> GTNESet
                    :-> TTOther
                      )
    foldl1
    NES.foldl1'

prop_findMin :: Property
prop_findMin = ttProp (GTNESet :-> TTKey)
    S.findMin
    NES.findMin

prop_findMax :: Property
prop_findMax = ttProp (GTNESet :-> TTKey)
    S.findMax
    NES.findMax

prop_deleteMin :: Property
prop_deleteMin = ttProp (GTNESet :-> TTSet)
    S.deleteMin
    NES.deleteMin

prop_deleteMax :: Property
prop_deleteMax = ttProp (GTNESet :-> TTSet)
    S.deleteMax
    NES.deleteMax

prop_deleteFindMin :: Property
prop_deleteFindMin = ttProp (GTNESet :-> TTKey :*: TTSet)
    S.deleteFindMin
    NES.deleteFindMin

prop_deleteFindMax :: Property
prop_deleteFindMax = ttProp (GTNESet :-> TTKey :*: TTSet)
    S.deleteFindMax
    NES.deleteFindMax

prop_toList :: Property
prop_toList = ttProp (GTNESet :-> TTNEList TTKey)
    S.toList
    NES.toList

prop_toDescList :: Property
prop_toDescList = ttProp (GTNESet :-> TTNEList TTKey)
    S.toDescList
    NES.toDescList

prop_elem :: Property
prop_elem = ttProp (GTKey :-> GTNESet :-> TTOther)
    elem
    elem

prop_fold1 :: Property
prop_fold1 = ttProp (GTNESet :-> TTKey)
    fold
    fold1

prop_fold :: Property
prop_fold = ttProp (GTNESet :-> TTKey)
    fold
    fold

prop_foldMap1 :: Property
prop_foldMap1 = ttProp (gf1 keyGen :?> GTNESet :-> TTOther)
    (\f -> foldMap  ((:[]) . f))
    (\f -> foldMap1 ((:[]) . f))

prop_foldMap :: Property
prop_foldMap = ttProp (gf1 keyGen :?> GTNESet :-> TTOther)
    (\f -> foldMap ((:[]) . f))
    (\f -> foldMap ((:[]) . f))