module Main where

import Text.Printf

import Data.Binary
import Data.Binary.Get
import Data.Binary.Put
import Data.ByteString.Lazy hiding (concatMap, putStrLn)

data Foo = Foo {
    w16 :: Word16,
    w32 :: Word32,
    w64 :: Word64
} deriving (Read,Show)

newtype FooLE = FooLE { unFooLE :: Foo }
  deriving (Read,Show)

newtype FooBE = FooBE { unFooBE :: Foo }
  deriving (Read,Show)

instance Binary FooLE where
    get = do
        w16le <- getWord16le
        w32le <- getWord32le
        w64le <- getWord64le
        return $ FooLE $ Foo { w16 = w16le,
                               w32 = w32le,
                               w64 = w64le }
    put fle = do
        let f = unFooLE fle
        putWord16le $ w16 f
        putWord32le $ w32 f
        putWord64le $ w64 f

instance Binary FooBE where
    get = do
        w16be <- getWord16be
        w32be <- getWord32be
        w64be <- getWord64be
        return $ FooBE $ Foo { w16 = w16be,
                               w32 = w32be,
                               w64 = w64be }
    put fbe = do
        let f = unFooBE fbe
        putWord16be $ w16 f
        putWord32be $ w32 f
        putWord64be $ w64 f

-- Test Data
td :: Foo
td = Foo { w16 = 0x0011,
           w32 = 0x00112233,
           w64 = 0x0011223344556677 }

tdBE :: FooBE
tdBE = FooBE td

tdLE :: FooLE
tdLE = FooLE td

printHex :: ByteString -> String
printHex b = concatMap (printf "%02x") $ unpack b

main :: IO ()
main = do
    let le  = encode $ tdLE
        be  = encode $ tdBE
        le' = decode $ le :: FooLE
        be' = decode $ be :: FooBE

    putStrLn $ "le:" ++ (printHex le)
    print le'

    putStrLn $ "be:" ++ (printHex be)
    print be'


{- Output:

le:1100332211007766554433221100
FooLE {unFooLE = Foo {w16 = 17, w32 = 1122867, w64 = 4822678189205111}}
be:0011001122330011223344556677
FooBE {unFooBE = Foo {w16 = 17, w32 = 1122867, w64 = 4822678189205111}}

-}