{-# LANGUAGE CPP #-}
{-# LANGUAGE ScopedTypeVariables #-}
module Crypto.Cipher.ThomasToVincent where

import qualified Data.ByteString as S
import Crypto.Cipher.Types
import Crypto.Cipher.Cast5
#if defined(VERSION_cryptonite)
import qualified Data.ByteArray as Bytes
import Crypto.Error
#else
import Data.Byteable
#endif

import Data.Tagged
{-
import qualified Crypto.Classes as Thomas
if ! MIN_VERSION_crypto_api(0,11,0)
import qualified Crypto.Modes as Thomas
endif
-}


type ThomasToVincent b = b

instance Cast5Bits size => Cipher (Cast5 size) where
    cipherName _ = "CAST-"++show (cast5bits (undefined :: size))
#if defined(VERSION_cryptonite)
    cipherInit k = CryptoPassed b
      where Just b = buildKey (Bytes.convert k)
#else
    cipherInit k = b
      where Just b = buildKey (toBytes k)
#endif
    cipherKeySize _ =  KeySizeFixed (bitlen `div` 8)
      where Tagged bitlen = keyLength :: Tagged (Cast5 size) Int


-- Break a bytestring into block size chunks.
chunkFor' :: (Cast5Bits size) => Cast5 size -> S.ByteString -> [S.ByteString]
chunkFor' k = go
  where
  blkSz = (Crypto.Cipher.Cast5.blockSize `for` k) `div` 8
  go bs | S.length bs < blkSz = []
        | otherwise           = let (blk,rest) = S.splitAt blkSz bs in blk : go rest

-- |Obtain a tagged value for a particular instantiated type.
for :: Tagged a b -> a -> b
for t _ = unTagged t

instance Cast5Bits size => BlockCipher (Cast5 size) where
    blockSize _ = bitlen `div` 8
     where Tagged bitlen = Crypto.Cipher.Cast5.blockSize :: Tagged (Cast5 size) Int

    -- ecbEncrypt :: (BlockCipher cipher, ByteArray ba) => cipher -> ba -> ba
    -- modeEcb' :: BlockCipher k => k -> B.ByteString -> B.ByteString
    ecbEncrypt k msg =
#if defined(VERSION_cryptonite)
            let chunks = chunkFor' k $ Bytes.convert msg
                    in Bytes.convert $ S.concat $ map (encryptBlock k) chunks
#else
            let chunks = chunkFor' k $ msg
                    in S.concat $ map (encryptBlock k) chunks
#endif

    ecbDecrypt k ct =
#if defined(VERSION_cryptonite)
        let chunks = chunkFor' k $ Bytes.convert ct
        in Bytes.convert $ S.concat $ map (decryptBlock k) chunks
#else
        let chunks = chunkFor' k ct
        in S.concat $ map (decryptBlock k) chunks
#endif


{-
newtype ThomasToVincent b = ThomasToVincent b

instance Thomas.BlockCipher b => Cipher (ThomasToVincent b) where
    cipherName _ = "ThomasToVincent"
    cipherInit k = ThomasToVincent b
      where Just b = Thomas.buildKey (toBytes k)
    cipherKeySize _ =  KeySizeFixed (bitlen `div` 8)
      where Tagged bitlen = Thomas.keyLength :: Tagged b Int

instance Thomas.BlockCipher b => BlockCipher (ThomasToVincent b) where
    blockSize _ = bitlen `div` 8
     where Tagged bitlen = Thomas.blockSize :: Tagged b Int
if ! MIN_VERSION_crypto_api(0,11,0)
    ecbEncrypt (ThomasToVincent k) = Thomas.ecb' k
    ecbDecrypt (ThomasToVincent k) = Thomas.unEcb' k
else
    ecbEncrypt (ThomasToVincent k) = Thomas.ecb k
    ecbDecrypt (ThomasToVincent k) = Thomas.unEcb k
endif
-}