module Tests.Cardinal
where

import Control.Monad (liftM, liftM2)
import Prelude hiding (LT)
import Test.QuickCheck

import Cardinal



instance Arbitrary Cardinal where
    arbitrary = oneof [f,b,l,r,d,t,fl,fr,fd,ft,bl,br,bd,bt,ld,lt,
                       rd,rt,fld,flt,frd,frt,bld,blt,brd,brt,i,
                       scalar,csum,cdiff,cprod,cquot]
        where
          f = return F
          b = return B
          l = return L
          r = return R
          d = return D
          t = return T
          fl = return FL
          fr = return FR
          fd = return FD
          ft = return FT
          bl = return BL
          br = return BR
          bd = return BD
          bt = return BT
          ld = return LD
          lt = return LT
          rd = return RD
          rt = return RT
          fld = return FLD
          flt = return FLT
          frd = return FRD
          frt = return FRT
          bld = return BLD
          blt = return BLT
          brd = return BRD
          brt = return BRT
          i = return I
          scalar = liftM Scalar arbitrary
          csum = liftM2 Sum arbitrary arbitrary
          cdiff = liftM2 Difference arbitrary arbitrary
          cprod = liftM2 Product arbitrary arbitrary
          cquot = liftM2 Quotient arbitrary arbitrary


prop_ccwx_rotation_changes_direction :: Cardinal -> Property
prop_ccwx_rotation_changes_direction c =
    -- The front and back faces are unchanged by x-rotation.
    c `elem` [L, R, D, T, FL, FR, FD, FT, BL, BR, BD, BT, LD, LT,
               RD, RT, FLD, FLT, FRD, FRT, BLD, BLT, BRD, BRT]
          ==> ccwx c /= c

prop_cwx_rotation_changes_direction :: Cardinal -> Property
prop_cwx_rotation_changes_direction c =
    -- The front and back faces are unchanged by x-rotation.
    c `elem` [L, R, D, T, FL, FR, FD, FT, BL, BR, BD, BT, LD, LT,
               RD, RT, FLD, FLT, FRD, FRT, BLD, BLT, BRD, BRT]
          ==> cwx c /= c

-- | If you rotate a cardinal direction four times in the clockwise
--   (with respect to x) direction, you should wind up with the same
--   direction.
prop_four_cwx_is_identity :: Cardinal -> Bool
prop_four_cwx_is_identity c =
    (cwx . cwx . cwx . cwx) c == c

-- | If you rotate a cardinal direction four times in the
--   counter-clockwise (with respect to x) direction, you should wind up
--   with the same direction.
prop_four_ccwx_is_identity :: Cardinal -> Bool
prop_four_ccwx_is_identity c =
    (ccwx . ccwx . ccwx . ccwx) c == c

-- | If you rotate a cardinal direction four times in the clockwise
--   (with respect to y) direction, you should wind up with the same
--   direction.
prop_four_cwy_is_identity :: Cardinal -> Bool
prop_four_cwy_is_identity c =
    (cwy . cwy . cwy . cwy) c == c

-- | If you rotate a cardinal direction four times in the counter-clockwise
--   (with respect to y) direction, you should wind up with the same
--   direction.
prop_four_ccwy_is_identity :: Cardinal -> Bool
prop_four_ccwy_is_identity c =
    (ccwy . ccwy . ccwy . ccwy) c == c

-- | If you rotate a cardinal direction four times in the clockwise
--   (with respect to z) direction, you should wind up with the same
--   direction.
prop_four_cwz_is_identity :: Cardinal -> Bool
prop_four_cwz_is_identity c =
    (cwz . cwz . cwz . cwz) c == c

-- | If you rotate a cardinal direction four times in the
--   counter-clockwise (with respect to z) direction, you should wind up
--   with the same direction.
prop_four_ccwz_is_identity :: Cardinal -> Bool
prop_four_ccwz_is_identity c =
    (ccwz . ccwz . ccwz . ccwz) c == c