module TestVector (tests) where

import Test.QuickCheck.Simple (Test, boolTest)

import Codec.Automotive.CSE
  (M1, unM1, makeM1, extractM1,
   M2, unM2, makeM2, extractM2,
   M3, unM3, makeM3,
   M4, unM4, makeM4, extractM4,
   M5, unM5, makeM5,
   UID, makeUID,
   KeyAuthUse, Auth, NotAuth, makeKeyAuthUse, derivedCipher,
   K1, K3, makeK1, makeK2, makeK3, makeK4)

import Numeric (showHex, showInt)
import Data.Maybe (fromJust)
import Data.ByteString (ByteString)
import qualified Data.ByteString as BS
import Data.Char (digitToInt)
import Data.Word (Word8, Word32)


{-
 Following test vectors are calculated using the implementation:
   https://github.com/naohaq/CSE_KeyGen/tree/master/C
 with input params:
   https://github.com/naohaq/CSE_KeyGen/blob/master/param_sample.txt
 -}

testAuthKey :: KeyAuthUse Auth
testAuthKey = fromJust . makeKeyAuthUse $ hxs "00010203_04050607_08090a0b_0c0d0e0f"

testKey :: KeyAuthUse NotAuth
testKey = fromJust . makeKeyAuthUse $ hxs "0f0e0d0c_0b0a0908_07060504_03020100"

testAuthKeyID :: Word8
testAuthKeyID = 1

testKeyID :: Word8
testKeyID = 4

testUID :: UID
testUID = fromJust . makeUID $ hxs "000000000000000000000000000001"

testCounter :: Word32
testCounter = 1

testFlags :: Word8
testFlags = 0


testM1 :: M1
testM1 = makeM1 testUID testKeyID testAuthKeyID

expectM1 :: Bool
expectM1 =
  unM1 testM1 == hxs "00000000000000000000000000000141"

expectE1 :: Bool
expectE1 = extractM1 testM1 == (testUID, testKeyID, testAuthKeyID)

testK1 :: K1
testK1 = derivedCipher $ makeK1 testAuthKey

testM2 :: M2
testM2 =
  makeM2 testK1 testCounter testFlags testKey

expectM2 :: Bool
expectM2 =
  unM2 testM2 == hxs "2b111e2d93f486566bcbba1d7f7a9797_c94643b050fc5d4d7de14cff682203c3"

expectE2 :: Bool
expectE2 = extractM2 testK1 testM2 == (testCounter, testFlags, testKey)

testM3 :: M3
testM3 =
  makeM3 (derivedCipher $ makeK2 testAuthKey) testM1 testM2

expectM3 :: Bool
expectM3 =
  unM3 testM3 == hxs "b9d745e5ace7d41860bc63c2b9f5bb46"

testK3 :: K3
testK3 = derivedCipher $ makeK3 testKey

testM4 :: M4
testM4 =
  makeM4 testK3 testUID testKeyID testAuthKeyID testCounter

expectM4 :: Bool
expectM4 =
  unM4 testM4 == hxs "00000000000000000000000000000141_b472e8d8727d70d57295e74849a27917"

expectE4 :: Bool
expectE4 = extractM4 testK3 testM4 == ((testUID, testKeyID, testAuthKeyID), testCounter)

testM5 :: M5
testM5 =
  makeM5 (derivedCipher $ makeK4 testKey) testM4

expectM5 :: Bool
expectM5 =
  unM5 testM5 == hxs "820d8d95dc11b4668878160cb2a4e23e"

hxs :: String -> ByteString
hxs = BS.pack . rec' where
    dtoW8 = fromIntegral . digitToInt
    rec' (' ':xs)  =  rec' xs
    rec' ('_':xs)  =  rec' xs
    rec' (x:y:xs)  =  dtoW8 x * 16 + dtoW8 y : rec' xs
    rec' [_]       =  error "hxs: invalid hex pattern."
    rec' []        =  []

_dump :: ByteString -> String
_dump = (`rec'` []) . BS.unpack  where
  rec'  []     =  id
  rec' (w:ws)  =  (if w < 16 then ('0' :) . showHex w else showHex w) . rec' ws

_dumpD :: ByteString -> String
_dumpD = (`rec'` []) . BS.unpack  where
  rec'  []     =  id
  rec' (w:ws)  =  showInt w . ("," ++) . rec' ws


tests :: [Test]
tests = [ boolTest "M1" expectM1
        , boolTest "extract M1" expectE1
        , boolTest "M2" expectM2
        , boolTest "extract M2" expectE2
        , boolTest "M3" expectM3
        , boolTest "M4" expectM4
        , boolTest "extract M4" expectE4
        , boolTest "M5" expectM5
        ]