{-# LANGUAGE BangPatterns        #-}
{-# LANGUAGE DataKinds           #-}
{-# LANGUAGE GADTs               #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# OPTIONS_GHC -Wno-orphans #-}
-- | Test copilot-bluespec:Copilot.Compile.Bluespec.
module Test.Copilot.Compile.Bluespec
    ( tests )
  where

-- External imports
import Control.Arrow                        ((&&&))
import Control.Exception                    (IOException, catch)
import Control.Monad                        (when)
import Data.AEq                             (AEq (..))
import Data.Bits                            (Bits, complement)
import Data.Foldable                        (foldl')
import Data.List                            (intercalate, stripPrefix)
import Data.List.Extra                      (stripSuffix)
import Data.Type.Equality                   (testEquality)
import Data.Typeable                        (Proxy (..), (:~:) (Refl))
import GHC.Float                            (castDoubleToWord64,
                                             castFloatToWord32,
                                             castWord32ToFloat,
                                             castWord64ToDouble)
import GHC.TypeLits                         (KnownNat, natVal)
import Numeric.IEEE                         (infinity, nan)
import System.Directory                     (doesFileExist,
                                             getTemporaryDirectory,
                                             removeDirectoryRecursive,
                                             setCurrentDirectory)
import System.IO                            (hPutStrLn, stderr)
import System.Posix.Temp                    (mkdtemp)
import System.Process                       (callProcess, readProcess)
import System.Random                        (Random)
import Test.Framework                       (Test, testGroup)
import Test.Framework.Providers.QuickCheck2 (testProperty)
import Test.QuickCheck                      (Arbitrary, Gen, Property,
                                             arbitrary, choose, elements,
                                             forAll, forAllBlind, frequency,
                                             getPositive, ioProperty, once,
                                             oneof, vectorOf, withMaxSuccess,
                                             (.&&.))
import Test.QuickCheck.Gen                  (chooseAny, chooseBoundedIntegral)
import Text.ParserCombinators.ReadPrec      (minPrec)

-- External imports: Copilot
import Copilot.Core hiding (Property)

-- External imports
import Copilot.Compile.Bluespec (bluespecSettingsOutputDirectory, compile,
                                 compileWith, mkDefaultBluespecSettings)

-- Internal imports
import Test.Copilot.Compile.Bluespec.External (External (extName), gatherExts)

-- * Constants

-- | All tests for copilot-bluespec:Copilot.Compile.Bluespec.
tests :: Test.Framework.Test
tests =
  testGroup "Copilot.Compile.Bluespec"
    [ testGroup "Unit tests"
      [ testProperty "Compile specification"               testCompile
      , testProperty "Compile specification in custom dir" testCompileCustomDir
      , testProperty "Run specification"                   testRun
      , testProperty "Run and compare results"             testRunCompare
      ]
    , testGroup "Regression tests"
      [ test14
      , test15
      ]
    ]

-- * Individual tests

-- | Test compiling a spec.
testCompile :: Property
testCompile = once $ ioProperty $ do
    tmpDir <- getTemporaryDirectory
    setCurrentDirectory tmpDir

    testDir <- mkdtemp "CopilotTest"
    setCurrentDirectory testDir

    compile "CopilotTest" spec
    r <- compileBluespec "CopilotTest" []

    setCurrentDirectory tmpDir
    removeDirectoryRecursive testDir

    return r

  where

    spec = Spec streams observers triggers properties

    streams    = []
    observers  = []
    triggers   = [ Trigger function guard args ]
    properties = []

    function = "func"

    guard = Const Bool True

    args = []

-- | Test compiling a spec in a custom directory.
testCompileCustomDir :: Property
testCompileCustomDir = once $ ioProperty $ do
    tmpDir <- getTemporaryDirectory
    setCurrentDirectory tmpDir

    testDir <- mkdtemp "CopilotTest"

    compileWith (mkDefaultBluespecSettings
                   { bluespecSettingsOutputDirectory = testDir })
                "CopilotTest"
                spec

    setCurrentDirectory testDir
    r <- compileBluespec "CopilotTest" []

    setCurrentDirectory tmpDir
    removeDirectoryRecursive testDir

    return r

  where

    spec = Spec streams observers triggers properties

    streams    = []
    observers  = []
    triggers   = [ Trigger function guard args ]
    properties = []

    function = "nop"

    guard = Const Bool True

    args = []

-- | Test compiling a spec and running the resulting program.
--
-- The actual behavior is ignored.
testRun :: Property
testRun = once $ ioProperty $ do
    tmpDir <- getTemporaryDirectory
    setCurrentDirectory tmpDir

    testDir <- mkdtemp "CopilotTest"
    setCurrentDirectory testDir

    let bluespecProgram = unlines
          [ "package Top where"
          , ""
          , "import CopilotTest"
          , "import CopilotTestIfc"
          , "import CopilotTestTypes"
          , ""
          , "copilotTestIfc :: Module CopilotTestIfc"
          , "copilotTestIfc ="
          , "  module"
          , "    interface"
          , "      nop :: Action"
          , "      nop = return ()"
          , ""
          , "mkTop :: Module Empty"
          , "mkTop = mkCopilotTest copilotTestIfc"
          ]

    writeFile "Top.bs" bluespecProgram

    compile "CopilotTest" spec
    r <- compileBluespec "Top" ["-g", "mkTop"]

    -- Compile a main program
    r2 <- compileExecutable "mkTop"
    callProcess "./mkTop" ["-m", "2"]

    setCurrentDirectory tmpDir
    removeDirectoryRecursive testDir

    return $ r && r2

  where

    spec = Spec streams observers triggers properties

    streams    = []
    observers  = []
    triggers   = [ Trigger function guard args ]
    properties = []

    function = "nop"

    guard = Const Bool True

    args = []

-- | Test running compiled spec and comparing the results to the
-- expectation.
testRunCompare :: Property
testRunCompare =
  -- It takes a pretty long time to run these tests, so we set the maximum
  -- number of successful tests to 5 instead of the default (100) for the sake
  -- of making the test suite complete in a more reasonable amount of time.
  withMaxSuccess 5 $
       testRunCompare1 (arbitraryOpIntegralBool :: Gen (TestCase1 Int8   Bool))
  .&&. testRunCompare1 (arbitraryOpIntegralBool :: Gen (TestCase1 Int16  Bool))
  .&&. testRunCompare1 (arbitraryOpIntegralBool :: Gen (TestCase1 Int32  Bool))
  .&&. testRunCompare1 (arbitraryOpIntegralBool :: Gen (TestCase1 Int64  Bool))
  .&&. testRunCompare1 (arbitraryOpIntegralBool :: Gen (TestCase1 Word8  Bool))
  .&&. testRunCompare1 (arbitraryOpIntegralBool :: Gen (TestCase1 Word16 Bool))
  .&&. testRunCompare1 (arbitraryOpIntegralBool :: Gen (TestCase1 Word32 Bool))
  .&&. testRunCompare1 (arbitraryOpIntegralBool :: Gen (TestCase1 Word64 Bool))
  .&&. testRunCompare1 (arbitraryOpFloatingBool :: Gen (TestCase1 Float  Bool))
  .&&. testRunCompare1 (arbitraryOpFloatingBool :: Gen (TestCase1 Double Bool))
  .&&. testRunCompare1 (arbitraryOpStruct       :: Gen (TestCase1 MyStruct Int8))
  .&&. testRunCompare2 (arbitraryOp2Struct      :: Gen (TestCase2 MyStruct Int8 MyStruct))
  .&&. testRunCompare2 (arbitraryArray2Num      :: Gen (TestCase2 (Array 2 Int8) Word32 Int8))
  .&&. testRunCompare2 (arbitraryArray2Num      :: Gen (TestCase2 (Array 2 Int16) Word32 Int16))
  .&&. testRunCompare3 (arbitraryArray3Num      :: Gen (TestCase3 (Array 2 Int16) Word32 Int16 (Array 2 Int16)))

-- * Regression tests

-- | Regression tests for
-- https://github.com/Copilot-Language/copilot-bluespec/issues/14 which ensure
-- that @copilot-bluespec@ generates code for the @signum@ function that adheres
-- to Copilot's @signum@ semantics.
test14 :: Test.Framework.Test
test14 =
  testGroup "#14"
    [ testProperty "`signum @Int8` generates correct Bluespec code" $
      mkRegressionTest1 (Sign Int8) (fmap signum)
        [-2, -1, 0, 1, 2]
    , testProperty "`signum @Double` generates correct Bluespec code" $
      mkRegressionTest1 (Sign Double) (fmap signum)
        [-nan, -infinity, -2, -1, -0.0, 0, 1, 2, infinity, nan]
    ]

-- | Regression tests for
-- https://github.com/Copilot-Language/copilot-bluespec/issues/15 which ensure
-- that @copilot-bluespec@ generates valid code for comparison operators (('<'),
-- ('<='), ('>'), and ('>=')) that are capable of handling NaN values.
test15 :: Test.Framework.Test
test15 =
  testGroup "#15"
    [ testProperty "Generates valid (<) code for NaNs" $
      mkRegressionTest2 (Lt Double) (zipWith (<)) vals
    , testProperty "Generates valid (<=) code for NaNs" $
      mkRegressionTest2 (Le Double) (zipWith (<=)) vals
    , testProperty "Generates valid (>) code for NaNs" $
      mkRegressionTest2 (Gt Double) (zipWith (>)) vals
    , testProperty "Generates valid (>=) code for NaNs" $
      mkRegressionTest2 (Ge Double) (zipWith (>=)) vals
    ]
  where
    vals :: [(Double, Double)]
    vals = [(0, nan), (nan, 0)]

-- | Test the behavior of a unary operation (an @'Op1' a b@ value) against its
-- expected behavior (as a Haskell function of type @[a] -> [b]@) using the
-- supplied inputs (of type @[a]@). This function is intended to be used to
-- construct regression tests.
mkRegressionTest1 :: (Typed a, Typed b,
                      DisplayableInBluespec b, ReadableFromBluespec b, AEq b)
                  => Op1 a b
                  -> ([a] -> [b])
                  -> [a]
                  -> Property
mkRegressionTest1 op haskellFun vals =
    let spec = alwaysTriggerArg1 (UExpr t2 appliedOp)
        appliedOp = Op1 op (ExternVar t1 varName Nothing)

        len = length vals
        inputs  = filterOutUnusedExts
                    spec
                    [ (typeBluespec t1,
                       fmap (bluespecShow t1) vals,
                       varName)
                    ]
        outputs = haskellFun vals in

    once $
    testRunCompareArg
      inputs len outputs spec (typeBluespec t2)

  where

    t1 = typeOf
    t2 = typeOf

    varName = "input"

-- | Test the behavior of a binary operation (an @'Op2' a b c@ value) against
-- its expected behavior (as a Haskell function of type @[a] -> [b] -> [c]@)
-- using the supplied inputs (of type @[(a, b)]@). This function is intended to
-- be used to construct regression tests.
mkRegressionTest2 :: (Typed a, Typed b, Typed c,
                      DisplayableInBluespec c, ReadableFromBluespec c, AEq c)
                  => Op2 a b c
                  -> ([a] -> [b] -> [c])
                  -> [(a, b)]
                  -> Property
mkRegressionTest2 op haskellFun vals =
    let spec = alwaysTriggerArg1 (UExpr t3 appliedOp)
        appliedOp = Op2 op (ExternVar t1 varName1 Nothing)
                           (ExternVar t2 varName2 Nothing)

        len = length vals
        (vals1, vals2) = unzip vals
        inputs  = filterOutUnusedExts
                    spec
                    [ (typeBluespec t1,
                       fmap (bluespecShow t1) vals1,
                       varName1)
                    , (typeBluespec t2,
                       fmap (bluespecShow t2) vals2,
                       varName2)
                    ]
        outputs = haskellFun vals1 vals2 in

    once $
    testRunCompareArg
      inputs len outputs spec (typeBluespec t3)

  where

    t1 = typeOf
    t2 = typeOf
    t3 = typeOf

    varName1 = "input1"
    varName2 = "input2"

-- * Random generators

-- ** Random function generators

-- | Generator of functions that produce booleans.
arbitraryOpBool :: Typed a => Gen (Fun a Bool, [a] -> [Bool])
arbitraryOpBool =
  frequency
    [ (5, arbitraryOp1Any)
    , (5, funCompose1 <$> arbitraryOp1Bool <*> arbitraryOpBool)
    , (2, funCompose2 <$> arbitraryOp2Bool <*> arbitraryOpBool <*> arbitraryOpBool)
    , (1, funCompose2 <$> arbitraryOp2Eq   <*> arbitraryOpBool <*> arbitraryOpBool)
    ]

-- | Generator of functions that take Bits and produce booleans.
arbitraryOpBoolBits :: (Typed a, Bits a) => Gen (Fun a Bool, [a] -> [Bool])
arbitraryOpBoolBits =
  frequency
    [ (1, funCompose2 <$> arbitraryOp2Eq <*> arbitraryOpBits <*> arbitraryOpBits)
    ]

-- | Generator of functions that take Nums and produce booleans.
arbitaryOpBoolOrdEqNum :: (Typed a, Eq a, Ord a, Num a)
                       => Gen (Fun a Bool, [a] -> [Bool])
arbitaryOpBoolOrdEqNum =
  frequency
    [ (1, funCompose2 <$> arbitraryOp2Eq  <*> arbitraryOpNum <*> arbitraryOpNum)
    , (1, funCompose2 <$> arbitraryOp2Ord <*> arbitraryOpNum <*> arbitraryOpNum)
    ]

-- | Generator of functions that take Floating point numbers and produce
-- booleans.
arbitraryOpBoolEqNumFloat :: (Typed t, Eq t, Num t, Floating t)
                          => Gen (Fun t Bool, [t] -> [Bool])
arbitraryOpBoolEqNumFloat =
  frequency
    [ (1, funCompose2 <$> arbitraryOp2Eq <*> arbitraryOpNum   <*> arbitraryOpFloat)
    , (1, funCompose2 <$> arbitraryOp2Eq <*> arbitraryOpFloat <*> arbitraryOpNum)
    ]

-- | Generator of functions that take and produce Bits.
arbitraryOpBits :: (Bits t, Typed t)
                => Gen (Fun t t, [t] -> [t])
arbitraryOpBits = elements
  [ (Op1 (BwNot typeOf), fmap complement)
  ]

-- | Generator of functions that take and produce Nums.
arbitraryOpNum :: (Typed t, Num t) => Gen (Fun t t, [t] -> [t])
arbitraryOpNum = elements
  [ (Op1 (Abs typeOf),  fmap abs)
  , (Op1 (Sign typeOf), fmap signum)
  ]

-- | Generator of functions that take an arrays and indicates and produce
-- elements from the array.
arbitraryArrayIx :: forall t n . (Typed t, KnownNat n, Num t)
                 => Gen ( Fun2 (Array n t) Word32 t
                        , [Array n t] -> [Word32] -> [t]
                        )
arbitraryArrayIx = return
  (Op2 (Index typeOf), zipWith (\x y -> arrayElems x !! fromIntegral y))

-- | Generator of functions that take arrays, indices, and values, and then
-- produce new arrays by updating the elements at the indices with the values.
arbitraryArrayUpdate :: forall t n . (Typed t, KnownNat n, Num t)
                     => Gen ( Fun3 (Array n t) Word32 t (Array n t)
                            , [Array n t] -> [Word32] -> [t] -> [Array n t]
                            )
arbitraryArrayUpdate = return
  (Op3 (UpdateArray typeOf), zipWith3 (\x y z -> array (updateAt y z (arrayElems x))))
  where
    updateAt :: forall a. Word32 -> a -> [a] -> [a]
    updateAt _ _ [] = []
    updateAt 0 x (_ : as) = x : as
    updateAt n x (a : as) = a : updateAt (n-1) x as

-- | Generator of functions that take structs produce fields of the struct.
arbitraryStructField :: Gen ( Fun MyStruct Int8
                            , [MyStruct] -> [Int8]
                            )
arbitraryStructField = elements
  [ (Op1 (GetField typeOf typeOf myStruct1), fmap (unField . myStruct1))
  , (Op1 (GetField typeOf typeOf myStruct2), fmap (unField . myStruct2))
  ]

-- | Generator of functions that take and produce structs, where the returned
-- structs have one field value updated.
arbitraryStructUpdate :: Gen ( Fun2 MyStruct Int8 MyStruct
                             , [MyStruct] -> [Int8] -> [MyStruct]
                             )
arbitraryStructUpdate = elements
  [ ( Op2 (UpdateField typeOf typeOf myStruct1)
    , zipWith (\s i -> s { myStruct1 = Field i })
    )
  , ( Op2 (UpdateField typeOf typeOf myStruct2)
    , zipWith (\s i -> s { myStruct2 = Field i })
    )
  ]

-- | Generator of functions on Floating point numbers.
arbitraryOpFloat :: (Floating t, Typed t) => Gen (Fun t t, [t] -> [t])
arbitraryOpFloat = elements
  [ (Op1 (Recip typeOf), fmap recip)
  , (Op1 (Exp typeOf),   fmap exp)
  , (Op1 (Sqrt typeOf),  fmap sqrt)
  , (Op1 (Log typeOf),   fmap log)
  , (Op1 (Sin typeOf),   fmap sin)
  , (Op1 (Tan typeOf),   fmap tan)
  , (Op1 (Cos typeOf),   fmap cos)
  , (Op1 (Asin typeOf),  fmap asin)
  , (Op1 (Atan typeOf),  fmap atan)
  , (Op1 (Acos typeOf),  fmap acos)
  , (Op1 (Sinh typeOf),  fmap sinh)
  , (Op1 (Tanh typeOf),  fmap tanh)
  , (Op1 (Cosh typeOf),  fmap cosh)
  , (Op1 (Asinh typeOf), fmap asinh)
  , (Op1 (Atanh typeOf), fmap atanh)
  , (Op1 (Acosh typeOf), fmap acosh)
  ]

-- | Generator of functions on that produce elements of any type.
arbitraryOp1Any :: forall a b
                .  (Arbitrary b, Typed a, Typed b)
                => Gen (Fun a b, [a] -> [b])
arbitraryOp1Any = oneof $
    [ (\v -> (\_ -> Const typeOf v, fmap (const v))) <$> arbitrary ]
    ++
    rest
  where
    rest | Just Refl <- testEquality t1 t2
         = [return (id, id)]
         | otherwise
         = []

    t1 :: Type a
    t1 = typeOf

    t2 :: Type b
    t2 = typeOf

-- | Generator of functions on Booleans.
arbitraryOp1Bool :: Gen (Fun Bool Bool, [Bool] -> [Bool])
arbitraryOp1Bool = elements
  [ (Op1 Not, fmap not)
  ]

-- | Generator of binary functions on Booleans.
arbitraryOp2Bool :: Gen (Fun2 Bool Bool Bool, [Bool] -> [Bool] -> [Bool])
arbitraryOp2Bool = elements
  [ (Op2 And, zipWith (&&))
  , (Op2 Or,  zipWith (||))
  ]

-- | Generator of binary functions that take two Eq elements of the same type
-- and return a Bool.
arbitraryOp2Eq :: (Typed t, Eq t)
               => Gen (Fun2 t t Bool, [t] -> [t] -> [Bool])
arbitraryOp2Eq = elements
  [ (Op2 (Eq typeOf), zipWith (==))
  , (Op2 (Ne typeOf), zipWith (/=))
  ]

-- | Generator of binary functions that take two Ord elements of the same type
-- and return a Bool.
arbitraryOp2Ord :: (Typed t, Ord t)
                => Gen (Fun2 t t Bool, [t] -> [t] -> [Bool])
arbitraryOp2Ord = elements
  [ (Op2 (Le typeOf), zipWith (<=))
  , (Op2 (Lt typeOf), zipWith (<))
  , (Op2 (Ge typeOf), zipWith (>=))
  , (Op2 (Gt typeOf), zipWith (>))
  ]

-- ** Random data generators

-- | Random array generator.
arbitraryArray :: forall n t . (KnownNat n, Random t) => Gen (Array n t)
arbitraryArray = array <$> vectorOf len chooseAny
  where
   len :: Int
   len = fromIntegral $ natVal (Proxy :: Proxy n)

-- | Random struct generator.
arbitraryStruct :: Gen MyStruct
arbitraryStruct = do
   fld1 <- Field <$> gen
   fld2 <- Field <$> gen
   return $ MyStruct fld1 fld2
  where
   gen :: Gen Int8
   gen = chooseBoundedIntegral (minBound, maxBound)

-- ** Random test case generators

-- | Generator for test cases on integral numbers that produce booleans.
arbitraryOpIntegralBool :: (Typed t, Bounded t, Integral t, Bits t)
                        => Gen (TestCase1 t Bool)
arbitraryOpIntegralBool = frequency
  [ (5, mkTestCase1
          arbitraryOpBool
          (chooseBoundedIntegral (minBound, maxBound)))

  , (2, mkTestCase1
          arbitraryOpBoolBits
          (chooseBoundedIntegral (minBound, maxBound)))

    -- we need to use +1 because certain operations overflow the number
  , (2, mkTestCase1
          arbitaryOpBoolOrdEqNum
          (chooseBoundedIntegral (minBound + 1, maxBound)))
  ]

-- | Generator for test cases on floating-point numbers that produce booleans.
arbitraryOpFloatingBool :: (Random t, Typed t, Floating t, Eq t)
                        => Gen (TestCase1 t Bool)
arbitraryOpFloatingBool = oneof
  [ mkTestCase1 arbitraryOpBoolEqNumFloat chooseAny
  ]

-- | Generator for test cases on Arrays selection producing values of the
-- array.
arbitraryArray2Num :: forall n a
                  .  (KnownNat n, Num a, Random a, Typed a)
                  => Gen (TestCase2 (Array n a) Word32 a)
arbitraryArray2Num = oneof
    [ mkTestCase2 arbitraryArrayIx arbitraryArray gen
    ]
  where
   gen :: Gen Word32
   gen = choose (0, len - 1)

   len :: Word32
   len = fromIntegral $ natVal (Proxy :: Proxy n)

-- | Generator for test cases on Arrays which update values of the array.
arbitraryArray3Num :: forall n a
                   .  (KnownNat n, Num a, Random a, Typed a)
                   => Gen (TestCase3 (Array n a) Word32 a (Array n a))
arbitraryArray3Num = oneof
    [ mkTestCase3 arbitraryArrayUpdate arbitraryArray gen chooseAny
    ]
  where
   gen :: Gen Word32
   gen = choose (0, len - 1)

   len :: Word32
   len = fromIntegral $ natVal (Proxy :: Proxy n)

-- | Generator for test cases on structs that produce fields of the struct.
arbitraryOpStruct :: Gen (TestCase1 MyStruct Int8)
arbitraryOpStruct = oneof
    [ mkTestCase1
        arbitraryStructField
        arbitraryStruct
    ]

-- | Generator for test cases that take and produce structs, where the returned
-- structs have one field value updated.
arbitraryOp2Struct :: Gen (TestCase2 MyStruct Int8 MyStruct)
arbitraryOp2Struct = oneof
    [ mkTestCase2
        arbitraryStructUpdate
        arbitraryStruct
        gen
    ]
  where
   gen :: Gen Int8
   gen = chooseBoundedIntegral (minBound, maxBound)

-- * Semantics

-- ** Functions

-- | Unary Copilot function.
type Fun a b = Expr a -> Expr b

-- | Binary Copilot function.
type Fun2 a b c = Expr a -> Expr b -> Expr c

-- | Ternary Copilot function.
type Fun3 a b c d = Expr a -> Expr b -> Expr c -> Expr d

-- | Compose functions, paired with the Haskell functions that define their
-- idealized meaning.
funCompose1 :: (Fun b c, [b] -> [c])
            -> (Fun a b, [a] -> [b])
            -> (Fun a c, [a] -> [c])
funCompose1 (f1, g1) (f2, g2) = (f1 . f2, g1 . g2)

-- | Compose a binary function, with two functions, one for each argument.
funCompose2 :: (Fun2 b c d, [b] -> [c] -> [d])
            -> (Fun a b, [a] -> [b])
            -> (Fun a c, [a] -> [c])
            -> (Fun a d, [a] -> [d])
funCompose2 (f1, g1) (f2, g2) (f3, g3) =
  (uncurry f1 . (f2 &&& f3), uncurry g1 . (g2 &&& g3))

-- ** Test cases

-- | Test case specification for specs with one input variable and one output.
data TestCase1 a b = TestCase1
  { wrapTC1Expr :: Spec
    -- ^ Specification containing a trigger with an extern of type 'a'.

  , wrapTC1Fun :: [a] -> [b]
    -- ^ Function expected to function in the same way as the Spec being
    -- tested.

  , wrapTC1CopInp :: (Type a, String, Gen a)
    -- ^ Input specification.
    --
    -- - The first element contains the type of the input in Bluespec.
    --
    -- - The second contains the variable name in Bluespec.
    --
    -- - The latter contains a randomized generator for values of the given
    -- type.

  , wrapTC1CopOut :: Type b
    -- ^ The type of the output in Bluespec.
  }

-- | Test case specification for specs with two input variables and one output.
data TestCase2 a b c = TestCase2
  { wrapTC2Expr :: Spec
    -- ^ Specification containing a trigger with an extern of type 'a' and a
    -- trigger with an argument of type 'b'.

  , wrapTC2Fun :: [a] -> [b] -> [c]
    -- ^ Function expected to function in the same way as the Spec being
    -- tested.

  , wrapTC2CopInp1 :: (Type a, String, Gen a)
    -- ^ Input specification for the first input.
    --
    -- - The first element contains the type of the input in Bluespec.
    --
    -- - The second contains the variable name in Bluespec.
    --
    -- - The latter contains a randomized generator for values of the given
    -- type.

  , wrapTC2CopInp2 :: (Type b, String, Gen b)
    -- ^ Input specification for the second input.
    --
    -- - The first element contains the type of the input in Bluespec.
    --
    -- - The second contains the variable name in Bluespec.
    --
    -- - The latter contains a randomized generator for values of the given
    -- type.

  , wrapTC2CopOut :: Type c
    -- ^ The type of the output in Bluespec.
  }

-- | Test case specification for specs with three input variables and one output.
data TestCase3 a b c d = TestCase3
  { wrapTC3Expr :: Spec
    -- ^ Specification containing a trigger with an extern of type 'a', a
    -- trigger with an argument of type 'b', and a trigger with an argument of
    -- type 'c'.

  , wrapTC3Fun :: [a] -> [b] -> [c] -> [d]
    -- ^ Function expected to function in the same way as the Spec being
    -- tested.

  , wrapTC3CopInp1 :: (Type a, String, Gen a)
    -- ^ Input specification for the first input.
    --
    -- - The first element contains the type of the input in Bluespec.
    --
    -- - The second contains the variable name in Bluespec.
    --
    -- - The latter contains a randomized generator for values of the given
    -- type.

  , wrapTC3CopInp2 :: (Type b, String, Gen b)
    -- ^ Input specification for the second input.
    --
    -- - The first element contains the type of the input in Bluespec.
    --
    -- - The second contains the variable name in Bluespec.
    --
    -- - The latter contains a randomized generator for values of the given
    -- type.

  , wrapTC3CopInp3 :: (Type c, String, Gen c)
    -- ^ Input specification for the second input.
    --
    -- - The first element contains the type of the input in Bluespec.
    --
    -- - The second contains the variable name in Bluespec.
    --
    -- - The latter contains a randomized generator for values of the given
    -- type.

  , wrapTC3CopOut :: Type d
    -- ^ The type of the output in Bluespec.
  }

-- | Generate test cases for expressions that behave like unary functions.
mkTestCase1 :: (Typed a, Typed b)
            => Gen (Fun a b, [a] -> [b])
            -> Gen a
            -> Gen (TestCase1 a b)
mkTestCase1 genO gen = do
    (copilotF, semF) <- genO

    let spec = alwaysTriggerArg1 (UExpr t2 appliedOp)
        appliedOp = copilotF (ExternVar t1 varName Nothing)

    return $
      TestCase1
        { wrapTC1Expr = spec
        , wrapTC1Fun = semF
        , wrapTC1CopInp = ( t1, varName, gen )
        , wrapTC1CopOut = t2
        }

  where

    t1 = typeOf
    t2 = typeOf

    varName = "input"

-- | Generate test cases for expressions that behave like binary functions.
mkTestCase2 :: (Typed a, Typed b, Typed c)
            => Gen (Fun2 a b c, [a] -> [b] -> [c])
            -> Gen a
            -> Gen b
            -> Gen (TestCase2 a b c)
mkTestCase2 genO genA genB = do
    (copilotF, semF) <- genO

    let spec = alwaysTriggerArg1 (UExpr t3 appliedOp)
        appliedOp = copilotF (ExternVar t1 varName1 Nothing)
                             (ExternVar t2 varName2 Nothing)

    return $
      TestCase2
        { wrapTC2Expr = spec
        , wrapTC2Fun = semF
        , wrapTC2CopInp1 = ( t1, varName1, genA )
        , wrapTC2CopInp2 = ( t2, varName2, genB )
        , wrapTC2CopOut = t3
        }

  where

    t1 = typeOf
    t2 = typeOf
    t3 = typeOf

    varName1 = "input1"
    varName2 = "input2"

-- | Generate test cases for expressions that behave like ternary functions.
mkTestCase3 :: (Typed a, Typed b, Typed c, Typed d)
            => Gen (Fun3 a b c d, [a] -> [b] -> [c] -> [d])
            -> Gen a
            -> Gen b
            -> Gen c
            -> Gen (TestCase3 a b c d)
mkTestCase3 genO genA genB genC = do
    (copilotF, semF) <- genO

    let spec = alwaysTriggerArg1 (UExpr t4 appliedOp)
        appliedOp = copilotF (ExternVar t1 varName1 Nothing)
                             (ExternVar t2 varName2 Nothing)
                             (ExternVar t3 varName3 Nothing)

    return $
      TestCase3
        { wrapTC3Expr = spec
        , wrapTC3Fun = semF
        , wrapTC3CopInp1 = ( t1, varName1, genA )
        , wrapTC3CopInp2 = ( t2, varName2, genB )
        , wrapTC3CopInp3 = ( t3, varName3, genC )
        , wrapTC3CopOut = t4
        }

  where

    t1 = typeOf
    t2 = typeOf
    t3 = typeOf
    t4 = typeOf

    varName1 = "input1"
    varName2 = "input2"
    varName3 = "input3"

-- | Test running a compiled Bluespec program and comparing the results.
testRunCompare1 :: (Show a, Typed a,
                    DisplayableInBluespec b, ReadableFromBluespec b,
                    AEq b, Typed b)
                => Gen (TestCase1 a b) -> Property
testRunCompare1 ops =
  forAllBlind ops $ \testCase ->
    let (TestCase1
           { wrapTC1Expr = copilotSpec
           , wrapTC1Fun = haskellFun
           , wrapTC1CopInp = inputVar
           , wrapTC1CopOut = outputType
           }) = testCase
        (bluespecTypeInput, bluespecInputName, gen) = inputVar

    in forAll (getPositive <$> arbitrary) $ \len ->

         forAll (vectorOf len gen) $ \vals -> do

         let inputs  = filterOutUnusedExts
                         copilotSpec
                         [ (typeBluespec bluespecTypeInput,
                            fmap (bluespecShow bluespecTypeInput) vals,
                            bluespecInputName)
                         ]
             outputs = haskellFun vals

         testRunCompareArg
           inputs len outputs copilotSpec (typeBluespec outputType)

-- | Test running a compiled Bluespec program and comparing the results.
testRunCompare2 :: (Show a1, Typed a1, Show a2, Typed a2,
                    DisplayableInBluespec b, ReadableFromBluespec b,
                    AEq b, Typed b)
                => Gen (TestCase2 a1 a2 b) -> Property
testRunCompare2 ops =
  forAllBlind ops $ \testCase ->
    let (TestCase2
           { wrapTC2Expr = copilotSpec
           , wrapTC2Fun = haskellFun
           , wrapTC2CopInp1 = inputVar1
           , wrapTC2CopInp2 = inputVar2
           , wrapTC2CopOut = outputType
           }) =
          testCase

        (bluespecTypeInput1, bluespecInputName1, gen1) = inputVar1
        (bluespecTypeInput2, bluespecInputName2, gen2) = inputVar2

    in forAll (getPositive <$> arbitrary) $ \len ->
       forAll (vectorOf len gen1) $ \vals1 ->
       forAll (vectorOf len gen2) $ \vals2 -> do
         let inputs  = filterOutUnusedExts
                         copilotSpec
                         [ (typeBluespec bluespecTypeInput1,
                            fmap (bluespecShow bluespecTypeInput1) vals1,
                            bluespecInputName1)
                         , (typeBluespec bluespecTypeInput2,
                            fmap (bluespecShow bluespecTypeInput2) vals2,
                            bluespecInputName2)
                         ]
             outputs = haskellFun vals1 vals2

         testRunCompareArg
           inputs len outputs copilotSpec (typeBluespec outputType)

-- | Test running a compiled Bluespec program and comparing the results.
testRunCompare3 :: (Show a1, Typed a1, Show a2, Typed a2, Show a3, Typed a3,
                    DisplayableInBluespec b, ReadableFromBluespec b,
                    AEq b, Typed b)
                => Gen (TestCase3 a1 a2 a3 b) -> Property
testRunCompare3 ops =
  forAllBlind ops $ \testCase ->
    let (TestCase3
           { wrapTC3Expr = copilotSpec
           , wrapTC3Fun = haskellFun
           , wrapTC3CopInp1 = inputVar1
           , wrapTC3CopInp2 = inputVar2
           , wrapTC3CopInp3 = inputVar3
           , wrapTC3CopOut = outputType
           }) =
          testCase

        (bluespecTypeInput1, bluespecInputName1, gen1) = inputVar1
        (bluespecTypeInput2, bluespecInputName2, gen2) = inputVar2
        (bluespecTypeInput3, bluespecInputName3, gen3) = inputVar3

    in forAll (getPositive <$> arbitrary) $ \len ->
       forAll (vectorOf len gen1) $ \vals1 ->
       forAll (vectorOf len gen2) $ \vals2 ->
       forAll (vectorOf len gen3) $ \vals3 -> do
         let inputs  = filterOutUnusedExts
                         copilotSpec
                         [ (typeBluespec bluespecTypeInput1,
                            fmap (bluespecShow bluespecTypeInput1) vals1,
                            bluespecInputName1)
                         , (typeBluespec bluespecTypeInput2,
                            fmap (bluespecShow bluespecTypeInput2) vals2,
                            bluespecInputName2)
                         , (typeBluespec bluespecTypeInput3,
                            fmap (bluespecShow bluespecTypeInput3) vals3,
                            bluespecInputName3)
                         ]
             outputs = haskellFun vals1 vals2 vals3

         testRunCompareArg
           inputs len outputs copilotSpec (typeBluespec outputType)

-- | Test running a compiled Bluespec program and comparing the results, when
-- the program produces one output as an argument to a trigger that always
-- fires.
--
-- PRE: all lists (second argument) of inputs have the length given as second
-- argument.
--
-- PRE: the monitoring code this is linked against uses the function
-- @printBack@ with exactly one argument to pass the results.
testRunCompareArg :: forall b
                   . (DisplayableInBluespec b, ReadableFromBluespec b, AEq b)
                  => [(String, [String], String)]
                  -> Int
                  -> [b]
                  -> Spec
                  -> String
                  -> Property
testRunCompareArg inputs numInputs vals spec outputType =
  ioProperty $ do
    tmpDir <- getTemporaryDirectory
    setCurrentDirectory tmpDir

    -- Operate in temporary directory
    testDir <- mkdtemp "CopilotTest"
    setCurrentDirectory testDir

    -- Produce wrapper program
    let bluespecProgram =
          testRunCompareArgBluespecProgram (Proxy :: Proxy b) inputs outputType
    writeFile "Top.bs" bluespecProgram

    -- Produce copilot monitoring code
    compile "CopilotTest" spec
    r <- compileBluespec "Top" ["-g", "mkTop"]

    -- Compile main program
    r2 <- compileExecutable "mkTop"

    -- Print result so far (for debugging purposes only)
    {-
    print r2
    print testDir
    -}

    -- Run the program and compare the results. Note that we use (===) (using
    -- the `AEq` class from the `ieee754` package) rather than (==) (using the
    -- `Eq` class), as the former allows us to use exact equality comparisons
    -- for floating-point types. This lets us ensure that we are handling NaN
    -- and -0.0 values correctly.
    out <- readProcess "./mkTop" ["-m", show (numInputs + 2)] ""
    let outNums = readFromBluespec <$> lines out
        comparison = outNums === vals

    -- Only clean up if the test succeeded; otherwise, we want to inspect it.
    when comparison $ do
      -- Remove temporary directory
      setCurrentDirectory tmpDir
      removeDirectoryRecursive testDir

    return $ r && r2 && comparison

-- | Return a wrapper Bluespec program that runs for a number of clock cycles,
-- updating external stream registers on every cycle, running the monitors, and
-- publishing the results of any outputs.
testRunCompareArgBluespecProgram
  :: DisplayableInBluespec b
  => Proxy b
  -> [(String, [String], String)]
  -> String
  -> String
testRunCompareArgBluespecProgram proxy inputs outputType = unlines $
    [ "package Top where"
    , ""
    , "import FloatingPoint"
    , "import Vector"
    , ""
    , "import CopilotTest"
    , "import CopilotTestIfc"
    , "import CopilotTestTypes"
    , ""
    ]
    ++ inputVecDecls ++
    [ ""
    , "copilotTestIfc :: Module CopilotTestIfc"
    , "copilotTestIfc ="
    , "  module"
    ]
    ++ inputRegs ++
    [ "    i :: Reg (Bit 64) <- mkReg 0"
    , "    ready :: Reg Bool <- mkReg False"
    , "    interface"
    , "      printBack :: " ++ outputType ++ " -> Action"
    , "      printBack output = $display " ++ printBackDisplayArgs
    , "                         when ready"
    , ""
    ]
    ++ inputMethods ++
    [ ""
    , "    rules"
    , "      \"inputs\": when True ==> do"
    ]
    ++ inputUpdates ++
    [ "        i := i + 1"
    , "        ready := True"
    , ""
    , "mkTop :: Module Empty"
    , "mkTop = mkCopilotTest copilotTestIfc"
    ]
  where
    printBackDisplayArgs :: String
    printBackDisplayArgs = unwords (displayInBluespec proxy "output")

    inputVecDecls :: [String]
    inputVecDecls =
      concatMap
        (\(bluespecType, _varName, _regName, inputVecName, inputVals) ->
          [ inputVecName ++ " :: Vector " ++ show (length inputVals) ++
            " (" ++ bluespecType ++ ")"
          , inputVecName ++ " = " ++ genVector inputVals
          ])
        vars

    inputRegs :: [String]
    inputRegs =
      map
        (\(bluespecType, _varName, regName, _inputVecName, _inputVals) ->
          "    " ++ regName ++ " :: Reg (" ++ bluespecType ++ ") <- mkRegU")
        vars

    inputMethods :: [String]
    inputMethods =
      concatMap
        (\(bluespecType, varName, regName, _inputVecName, _inputVals) ->
          [ "      " ++ varName ++ " :: Reg (" ++ bluespecType ++ ")"
          , "      " ++ varName ++ " = " ++ regName
          ])
        vars

    inputUpdates :: [String]
    inputUpdates =
      map
        (\(_bluespecType, _varName, regName, inputVecName, _inputVals) ->
          "        " ++ regName ++ " := select " ++ inputVecName ++ " i")
        vars

    vars = map oneInput inputs
    oneInput (bluespecTypeInput, inputVals, bluespecInputName) =
        (bluespecTypeInput, inputVarName, inputRegVarName, inputVecVarName,
         inputVals)
      where
        inputVarName    = bluespecInputName
        inputRegVarName = bluespecInputName ++ "Impl"
        inputVecVarName = bluespecInputName ++ "Inputs"

-- * Auxiliary functions

-- ** Specs handling

-- | Build a 'Spec' that triggers at every step, passing the given expression
-- as argument, and execution a function 'printBack'.
alwaysTriggerArg1 :: UExpr -> Spec
alwaysTriggerArg1 = triggerArg1 (Const Bool True)

  where

    -- | Build a 'Spec' that triggers based on a given boolean stream, passing
    -- the given expression as argument, and execution a function 'printBack'.
    triggerArg1 :: Expr Bool -> UExpr -> Spec
    triggerArg1 guard expr = Spec streams observers triggers properties

      where

        streams    = []
        observers  = []
        properties = []

        triggers = [ Trigger function guard args ]
        function = "printBack"
        args     = [ expr ]

-- | Filter out any elements in the input list (of type @[(a, b, String)]@)
-- whose first element (the name of an external stream) does not correspond to
-- the name of an external stream in the supplied 'Spec'. For example, a Copilot
-- source program may declare external streams, but if none of them are used in
-- the 'Spec', then the 'Spec' value itself will not contain any external stream
-- definitions. As a result, we want to ensure that the input list also does not
-- contain any external streams.
filterOutUnusedExts :: Spec -> [(a, b, String)] -> [(a, b, String)]
filterOutUnusedExts spec = filter (\(_, _, name) -> name `elem` extNames)
  where
    extNames = map extName $ gatherExts (specStreams spec) (specTriggers spec)

-- ** Compilation of Bluespec programs

-- | Compile a Bluespec file given its basename.
compileBluespec :: String -> [String] -> IO Bool
compileBluespec baseName extraArgs = do
  result <- catch (do callProcess "bsc" $ extraArgs ++
                                          [ "-sim", "-quiet", "-u",
                                            -- We suppress the G0023 warning,
                                            -- which arises due to the `nop`
                                            -- triggers defined above. See the
                                            -- DESIGN.md document for more
                                            -- details on what these warning
                                            -- codes mean.
                                            "-suppress-warnings", "G0023:S0080",
                                            baseName ++ ".bs" ]
                      return True
                  )
                  (\e -> do
                     hPutStrLn stderr $
                       "copilot-bluespec: error: compileBluespec: "
                         ++ "cannot compile " ++ baseName ++ ".bs with bsc"
                     hPutStrLn stderr $
                       "copilot-bluespec: exception: " ++ show (e :: IOException)
                     return False
                  )
  if result
    then doesFileExist $ baseName ++ ".bo"
    else return False

-- | Compile a Bluespec file into an executable given its basename.
compileExecutable :: String -> IO Bool
compileExecutable topExe = do
  result <- catch (do callProcess "bsc" [ "-sim", "-quiet"
                                        , "-e", topExe
                                        , "-o", topExe
                                        , "bs_fp.c"
                                        ]
                      return True
                  )
                  (\e -> do
                     hPutStrLn stderr $
                       "copilot-bluespec: error: compileExecutable: "
                         ++ "cannot compile " ++ topExe ++ " with bsc"
                     hPutStrLn stderr $
                       "copilot-bluespec: exception: "
                         ++ show (e :: IOException)
                     return False
                  )
  if result
    then doesFileExist topExe
    else return False

-- ** Interfacing between Haskell and Bluespec

-- | Bluespec type used to store values of a given type.
typeBluespec :: Typed a => Type a -> String
typeBluespec Bool         = "Bool"
typeBluespec Int8         = "Int 8"
typeBluespec Int16        = "Int 16"
typeBluespec Int32        = "Int 32"
typeBluespec Int64        = "Int 64"
typeBluespec Word8        = "UInt 8"
typeBluespec Word16       = "UInt 16"
typeBluespec Word32       = "UInt 32"
typeBluespec Word64       = "UInt 64"
typeBluespec Float        = "Float"
typeBluespec Double       = "Double"
typeBluespec t@(Array tE) =
  "Vector " ++ show (typeLength t)  ++ "(" ++ typeBluespec tE ++ ")"
typeBluespec (Struct s)   = typeName s

-- | Show a value of a given type in Bluespec.
bluespecShow :: Type a -> a -> String
bluespecShow Bool       x = show x
bluespecShow Int8       x = bluespecShowIntegral x
bluespecShow Int16      x = bluespecShowIntegral x
bluespecShow Int32      x = bluespecShowIntegral x
bluespecShow Int64      x = bluespecShowIntegral x
bluespecShow Word8      x = bluespecShowIntegral x
bluespecShow Word16     x = bluespecShowIntegral x
bluespecShow Word32     x = bluespecShowIntegral x
bluespecShow Word64     x = bluespecShowIntegral x
bluespecShow Float      x = bluespecShowRealFloat 32 castFloatToWord32 x
bluespecShow Double     x = bluespecShowRealFloat 64 castDoubleToWord64 x
bluespecShow (Array tE) x = genVector $ map (bluespecShow tE) $ arrayElems x
bluespecShow (Struct s) x =
  typeName s
    ++ "{ "
    ++ intercalate ";"
         (map
           (\(Value fldTy fld@(Field val)) ->
             fieldName fld ++ " = " ++ bluespecShow fldTy val)
           (toValues x))
    ++ "}"

-- | Show a value of a integral type (e.g., 'Int8' or 'Word8').
bluespecShowIntegral :: (Integral a, Num a, Ord a, Show a) => a -> String
bluespecShowIntegral x
  | x >= 0    = show x
  -- Bluespec Haskell doesn't have negative integer literals, so something like
  -- "-42" won't parse. Instead, we must rely on Bluespec's `negate` function.
  --
  -- We must be careful to negate an Integer literal rather than than a
  -- fixed-precision literal. For instance, suppose we wanted to display
  -- (-128 :: Int8). We wouldn't want to do this by displaying `negate 128`,
  -- since 128 isn't a valid Int8 value—the maximum Int8 value is 127!
  -- Instead, we want to display `fromInteger (negate 128)`, where 128 is an
  -- Integer. This way, `negate` can turn `128` to `-128` without issues.
  | otherwise = "fromInteger (negate " ++ show (abs (toInteger x)) ++ ")"

-- | Show a value of a floating-point type (e.g., 'Float' or 'Double'). We make
-- sure to convert NaN and infinity values to the corresponding Bluespec
-- @FloatingPoint@ functions that construct these values.
bluespecShowRealFloat ::
     (Num float, Ord float, RealFloat float, Show float, Show word)
  => Int
  -> (float -> word)
  -> float
  -> String
bluespecShowRealFloat floatSizeInBits castFloatToWord float
    -- We want to ensure that NaN values are correctly translated to Bluespec,
    -- bit by bit. We have two mechanisms to do so. On the Haskell side, we have
    -- `ieee754`'s `nanWithPayload` function, and on the Bluespec side, we have
    -- `FloatingPoint`'s `nanQuiet` function. Unfortunately, their arguments are
    -- of different types, and it isn't quite clear how to express one function
    -- in terms of the other.
    --
    -- To avoid this problem, we take a more indirect approach: we first cast
    -- the Haskell floating-point value to a word and then `unpack` the word to
    -- a floating-point value on the Bluespec side. It's somewhat verbose, but
    -- it gets the job done reliably.
  | isNaN float
  = "unpack (" ++ show (castFloatToWord float) ++
    " :: Bit " ++ show floatSizeInBits ++ ")"

  | isInfinite float
  = "infinity " ++ show floatIsNeg

  | floatIsNeg
  = "negate " ++ show (abs float)

  | otherwise
  = show float
  where
    floatIsNeg = (float < 0) || isNegativeZero float

-- | Given a list of elements as arguments, show a @Vector@ expression. For
-- example, @'genVector' [\"27\", \"42\"]@ will return
-- @\"updateVector (updateVector newVector 0 27) 1 42)\"@.
genVector :: [String] -> String
genVector vals =
  snd $
  foldl'
    (\(!i, !v) x ->
      (i+1, "update (" ++ v ++ ") " ++ show i ++ " (" ++ x ++ ")"))
    (0 :: Int, "newVector")
    vals

-- | Display a value of a given type in Bluespec using @$display@.
class DisplayableInBluespec a where
  displayInBluespec ::
       proxy a  -- ^ The type of the value.
    -> String   -- ^ The name of the Bluespec variable.
    -> [String] -- ^ All arguments that are passed to @$display@.

-- | Most Bluespec types can be displayed using @fshow@.
fshowDisplay :: proxy a -> String -> [String]
fshowDisplay _ output = ["(fshow " ++ output ++ ")"]

-- | We display floating-point numbers by converting them to an integer and
-- printing them in hexadecimal (using the @%x@ modifier). This somewhat unusual
-- choice is motivated by the fact that this output is easier to parse than the
-- @fshow@ output.
hexFloatDisplay :: proxy a -> String -> [String]
hexFloatDisplay _ output = ["\"%x\"", output]

instance DisplayableInBluespec Bool where
  displayInBluespec = fshowDisplay

instance DisplayableInBluespec Int8 where
  displayInBluespec = fshowDisplay

instance DisplayableInBluespec Int16 where
  displayInBluespec = fshowDisplay

instance DisplayableInBluespec Int32 where
  displayInBluespec = fshowDisplay

instance DisplayableInBluespec Int64 where
  displayInBluespec = fshowDisplay

instance DisplayableInBluespec Word8 where
  displayInBluespec = fshowDisplay

instance DisplayableInBluespec Word16 where
  displayInBluespec = fshowDisplay

instance DisplayableInBluespec Word32 where
  displayInBluespec = fshowDisplay

instance DisplayableInBluespec Word64 where
  displayInBluespec = fshowDisplay

instance DisplayableInBluespec Float where
  displayInBluespec = hexFloatDisplay

instance DisplayableInBluespec Double where
  displayInBluespec = hexFloatDisplay

instance DisplayableInBluespec a => DisplayableInBluespec (Array n a) where
  displayInBluespec = fshowDisplay

-- | @copilot-bluespec@–generated structs currently do not have @FShow@
-- instances. (Perhaps they should: see
-- https://github.com/Copilot-Language/copilot-bluespec/issues/12)
-- In lieu of this, we manually define the same code that would be used in a
-- derived @FShow@ instance.
instance DisplayableInBluespec MyStruct where
  displayInBluespec _ output =
    [ "\"MyStruct { myStruct1 = %d ; myStruct2 = %d }\""
    , output ++ ".myStruct1"
    , output ++ ".myStruct2"
    ]

-- | Read a value of a given type in Bluespec.
class ReadableFromBluespec a where
  readFromBluespec :: String -> a

instance ReadableFromBluespec Bool where
  readFromBluespec = read

instance ReadableFromBluespec Int8 where
  readFromBluespec = read

instance ReadableFromBluespec Int16 where
  readFromBluespec = read

instance ReadableFromBluespec Int32 where
  readFromBluespec = read

instance ReadableFromBluespec Int64 where
  readFromBluespec = read

instance ReadableFromBluespec Word8 where
  readFromBluespec = read

instance ReadableFromBluespec Word16 where
  readFromBluespec = read

instance ReadableFromBluespec Word32 where
  readFromBluespec = read

instance ReadableFromBluespec Word64 where
  readFromBluespec = read

-- We print out floating-point values in hexadecimal (see `hexFloatDisplay`
-- above), so we parse them accordingly here.

instance ReadableFromBluespec Float where
  readFromBluespec s = castWord32ToFloat $ read $ "0x" ++ s

instance ReadableFromBluespec Double where
  readFromBluespec s = castWord64ToDouble $ read $ "0x" ++ s

instance (KnownNat n, ReadableFromBluespec a) => ReadableFromBluespec (Array n a) where
  readFromBluespec s0
    | Just s1 <- stripPrefix "<V" s0
    , Just s2 <- stripSuffix ">" s1
    = array $ map readFromBluespec $ words s2
    | otherwise
    = error $ "Unexpected Vector fshow output: " ++ s0

instance ReadableFromBluespec MyStruct where
  readFromBluespec str =
    case readsEither (readsStruct minPrec) str of
      Left err -> error err
      Right ms -> ms

-- | Attempt to read a value of type @a@. If successful, return 'Right' with
-- the read value. Otherwise, return @'Left' err@, where @err@ is an error
-- message describing what went wrong.
readsEither :: ReadS a -> String -> Either String a
readsEither readIt s =
  case [ x | (x,"") <- readIt s ] of
    [x] -> Right x
    []  -> Left $ "readsEither: no parse: " ++ s
    _   -> Left $ "readsEither: ambiguous parse: " ++ s

-- ** Orphan instances for Arrays

instance Eq a => Eq (Array n a) where
  a1 == a2 = arrayElems a1 == arrayElems a2

instance AEq a => AEq (Array n a) where
  a1 === a2 = arrayElems a1 === arrayElems a2

-- ** A simple struct definition for unit testing purposes

data MyStruct = MyStruct
  { myStruct1 :: Field "myStruct1" Int8
  , myStruct2 :: Field "myStruct2" Int8
  }

-- | Like a derived @Eq@ instance, except that this looks through 'Field's.
instance Eq MyStruct where
  MyStruct (Field f1a) (Field f2a) == MyStruct (Field f1b) (Field f2b) =
    f1a == f1b && f2a == f2b
instance AEq MyStruct

-- | Like a derived @Read@ instance, except that this adds 'Field' wrappers as
-- needed.
readsStruct :: Int -> ReadS MyStruct
readsStruct p = readParen (p > 10) $ \s -> do
  ("MyStruct", s1) <- lex s
  ("{", s2) <- lex s1
  ("myStruct1", s3) <- lex s2
  ("=", s4) <- lex s3
  (f1, s5) <- readsPrec 0 s4
  (";", s6) <- lex s5
  ("myStruct2", s7) <- lex s6
  ("=", s8) <- lex s7
  (f2, s9) <- readsPrec 0 s8
  ("}", s10) <- lex s9
  pure (MyStruct (Field f1) (Field f2), s10)

instance Struct MyStruct where
  typeName _ = "MyStruct"
  toValues ms = [ Value Int8 (myStruct1 ms)
                , Value Int8 (myStruct2 ms)
                ]

instance Typed MyStruct where
  typeOf = Struct (MyStruct (Field 0) (Field 0))

-- | Unwrap a 'Field' to obtain the underlying value.
unField :: Field s t -> t
unField (Field val) = val