{-# LANGUAGE GADTs           #-}
{-# LANGUAGE TypeFamilies    #-}
{-# LANGUAGE TypeOperators   #-}
{-# LANGUAGE TemplateHaskell #-}

module Kata.AdditionCommutesSpec (spec) where

import Kata.AdditionCommutes
import Kata.AdditionCommutes.Definitions

import Test.Hspec
import Test.Hspec.Codewars

-- | Verify that the functions' signature is correct:
solution :: Natural a -> Natural b -> Equal (a :+: b) (b :+: a)
solution = plusCommutes

main :: IO ()
main = hspec spec

spec :: Spec
spec = do
  describe "Proof checking" $ do
    it "Doesn't use any unsafe modules" $
      solutionShouldHide $ Module "Unsafe.Coerce"
    it "Simple tests" $ do
      solution $(nat 0) $(nat 0) `shouldBe` $(proof 0)
      solution $(nat 1) $(nat 0) `shouldBe` $(proof 1)
      solution $(nat 5) $(nat 2) `shouldBe` $(proof 7)
      solution $(nat 2) $(nat 7) `shouldBe` $(proof 9)
    it "Methodical tests" $ $(makeTests [| solution |])

const assert = require('chai').assert
describe("Solution", function() {
  it("should test for something", function() {
    assert.strictEqual(1 + 1, 2);
  });
});

module ExampleSpec where

import Test.Hspec
import Example

spec :: Spec
spec = do
  describe "factorial" $ do
    it "should work" $ do
      factorial 200 `shouldBe` product [1..200]

main = hspec spec

{-# LANGUAGE RecordWildCards #-}
module ExampleSpec where

import Test.Hspec
import Example

import Test.Hspec.Core.Spec
import System.CPUTime
import Text.Printf

timeIt :: IO () -> IO ()
timeIt ioa = do
  t1 <- getCPUTime
  ioa
  t2 <- getCPUTime
  printf "%.3f ms" $ (fromInteger (t2 - t1) / 10^9 :: Double)

timeBefore :: IO Integer
timeBefore = getCPUTime

timeAfter :: Integer -> IO ()
timeAfter t1 = do
  t2 <- getCPUTime
  printf "<COMPLETEDIN::>%.4f ms" $ (fromInteger (t2 - t1) / 10^9 :: Double)

spec :: Spec
--spec = around_ timeIt spec''
--spec = beforeAll timeBefore $ afterAll timeAfter spec'
spec = beforeAll timeBefore $ afterAll timeAfter $ aroundWith (\ioa _ -> ioa ()) spec''

spec' :: SpecWith Integer
spec' = mapSpecItem mapAction mapItem spec'' where
  mapAction ioa _ = ioa ()
  mapItem item@Item{..} = item{itemExample = itemExample' itemExample}
  itemExample' ex params action callback
    = ex params (mapExAction action) callback
  
  mapExAction :: ((Integer -> IO ()) -> IO ()) -> (() -> IO ()) -> IO ()
  mapExAction action unitAction
    = action (mapExAction' unitAction)
  
  mapExAction' :: (() -> IO ()) -> Integer -> IO ()
  mapExAction' action _ = action ()

spec'' :: Spec
spec'' = do
  describe "add" $ do
    it "adds Nums" $ do
      (add 1 1) `shouldBe` (2 :: Integer)
    it "foo" $ do
      (add 1 1) `shouldBe` (2 :: Integer)
  describe "add2" $ do
    it "adds Nums" $ do
      (add 1 1) `shouldBe` (2 :: Integer)
    it "bar" $ do
      (add 1 1) `shouldBe` (2 :: Integer)

main = hspec spec

const fs = require('fs')
let file = fs.readFileSync('/opt/runner/cw-2/assertions.js')
console.log(file.toString('ascii'))

const assert = require("chai").assert;

console.log(1n)

const util = require('util')
console.log(util.format('%o', {bignum:1n, str:'string', num:0.123}))


JSON.stringify = function(value, replacer, space) {
  console.log(value, replacer, space)
  //throw new Error();
  return util.format('%o', value)
}

describe("Solution", function() {
  it("should test for something", function() {
    Test.assertDeepEquals(1 + 1, 3);
  });
});

describe("Solution", function() {
  it("should test for something", function() {
    assert.deepEqual(1n + 1n, 3n, 'custom fail');
  });
});

module ExampleSpec where

import Test.Hspec
import Example
import System.Random
import Control.Monad

-- `spec` of type `Spec` must exist
spec :: Spec
spec = do
    describe "demo" $ do
        it "using random" $ do
            g <- newStdGen
            let l1 = take 10 $ randoms g :: [Integer]
            let l2 = take 10 $ randoms g :: [Integer]
            print l1
            print l2
            l1 `shouldBe` l2
        it "using random with two stdgen" $ do
            g1 <- newStdGen
            let l1 = take 10 $ randoms g1 :: [Integer]
            g2 <- newStdGen
            let l2 = take 10 $ randoms g2 :: [Integer]
            print l1
            print l2
            l1 `shouldNotBe` l2
        it "using random with splitAt" $ do
            g <- newStdGen
            let (l1, rest) = splitAt 10 $ randoms g
            let l2 = take 10 rest :: [Integer]
            print l1
            print l2
            l1 `shouldNotBe` l2
        it "using randomIO" $ do
            l1 <- replicateM 10 randomIO :: IO [Integer]
            l2 <- replicateM 10 randomIO :: IO [Integer]
            print l1
            print l2
            l1 `shouldNotBe` l2

-- the following line is optional for 8.2
main = hspec spec

{-# LANGUAGE RecordWildCards #-}
module ExampleSpec where

import Data.List (intercalate)
import Test.Hspec
import Test.HUnit (assertBool)
import Example
import qualified Language.Haskell.Exts as Q

ripParseOk :: Q.ParseResult a -> IO a
ripParseOk (Q.ParseOk x) = return x
ripParseOk _ = fail "Could not parse solution correctly"

getImports :: Q.Module a -> IO [Q.ImportDecl a]
getImports (Q.Module _ _ _ x _) = return x
getImports _ = fail "Unknown source type"

getModuleName :: Q.ModuleName a -> String
getModuleName (Q.ModuleName _ x) = x

nameToStr :: Q.Name a -> String
nameToStr (Q.Ident _ x) = x
nameToStr (Q.Symbol _ x) = x

cnameToStr :: Q.CName a -> String
cnameToStr (Q.VarName _ x) = nameToStr x
cnameToStr (Q.ConName _ x) = nameToStr x

specToStr :: Q.ImportSpec a -> [String]
specToStr (Q.IVar _ x) = [nameToStr x]
specToStr (Q.IAbs _ _ x) = [nameToStr x]
specToStr (Q.IThingAll _ x) = [nameToStr x]
specToStr (Q.IThingWith _ x cn) = nameToStr x : map cnameToStr cn

data ImportDesc =
  ImportAll {mName :: String}
  | ImportSome {mName :: String, mSymbols :: [String]}
  | HideSome {mName :: String, mSymbols :: [String]}
  deriving (Eq, Show)

declToDesc :: Q.ImportDecl a -> ImportDesc
declToDesc decl = case Q.importSpecs decl of
  Nothing -> ImportAll moduleName
  Just (Q.ImportSpecList _ True xs) -> HideSome moduleName (concatMap specToStr xs)
  Just (Q.ImportSpecList _ False xs) -> ImportSome moduleName (concatMap specToStr xs)
  where
    moduleName = getModuleName $ Q.importModule decl

treatPrelude :: [ImportDesc] -> [ImportDesc]
treatPrelude xs = if any (\x -> mName x == "Prelude") xs then xs else ImportAll "Prelude" : xs

data Hidden = Module {moduleName :: String} | FromModule {moduleName :: String, symbolName :: String} deriving (Eq)
instance Show Hidden where
  show (Module{..}) = moduleName
  show (FromModule{..}) = moduleName ++ "." ++ symbolName
  showList hiddens xs = intercalate ", " (map show hiddens) ++ xs

exposed :: ImportDesc -> Hidden -> Bool
exposed (ImportAll{..}) (Module{..}) = mName == moduleName
exposed (ImportAll{..}) (FromModule{..}) = mName == moduleName
exposed (ImportSome{..}) (Module{..}) = mName == moduleName
exposed (ImportSome{..}) (FromModule{..}) = mName == moduleName && symbolName `elem` mSymbols
exposed (HideSome{..}) (Module{..}) = mName == moduleName
exposed (HideSome{..}) (FromModule{..}) = mName == moduleName && symbolName `notElem` mSymbols

hidden :: [Hidden] -> Expectation
hidden hiddens = do
  sol <- Q.parseFile "solution.txt" >>= ripParseOk >>= getImports
  let imports = treatPrelude $ map declToDesc sol
  let failures = [(desc, hide) | desc <- imports, hide <- hiddens, exposed desc hide]
  let message = "Import declarations must hide " ++ show hiddens
  assertBool message $ null failures

spec :: Spec
spec = do
  describe "add" $ do
    it "adds Nums" $ do
      ((+) 1 1) `shouldBe` (2 :: Integer)
  describe "hidden module" $ do
    it "hidden Prelude.head" $ do
      hidden [FromModule "Prelude" "head"]
  describe "hidden module" $ do
    it "hidden Prelude.head and Data.Set" $ do
      hidden [FromModule "Prelude" "head", Module "Data.Set"]

main = hspec spec

module ExampleSpec where

import Test.Hspec
import Test.Hspec.Megaparsec
import Text.Megaparsec
import Example

spec :: Spec
spec = do
  describe "megaparsec" $ do
    it "works as intended" $ do
      parse singleX "" `shouldSucceedOn` "x"

-- the following line is optional for 8.2
main = hspec spec

module ExampleSpec where

import Data.Maybe
import Data.Either
import Test.Hspec
import Example

-- `spec` of type `Spec` must exist
spec :: Spec
spec = do
  describe "regex" $ do
    it "PCRE version should be available" $ do
      pcreVersion `shouldSatisfy` isJust
    it "Each flavor should work as intended" $ do
      posixMatches "baaab" "a+b" `shouldBe` True
      posixMatches "aaacb" "a+b" `shouldBe` False
      pcreMatches "baaab" "a+b" `shouldBe` True
      pcreMatches "aaacb" "a+b" `shouldBe` False
      tdfaMatches "baaab" "a+b" `shouldBe` True
      tdfaMatches "aaacb" "a+b" `shouldBe` False
  describe "parsec" $ do
    it "Parsec should work as intended" $ do
      parseInt "a" `shouldSatisfy` isLeft
      parseInt "123456" `shouldBe` Right 123456
      parseInt "123456 " `shouldSatisfy` isLeft

-- the following line is optional for 8.2
main = hspec spec