module Main where

import           Control.Lens (view)
import           Control.Monad.Trans.Resource (runResourceT, ResourceT(..), MonadResource)
import           Data.ByteString.Streaming as BSS
import           Data.ByteString.Streaming.Char8 as S8
import           Data.ByteString.Streaming.Internal (ByteString(..))
import           Data.Functor.Of
import           Data.Void
import           Prelude as P
import qualified Data.ByteString.Char8 as BS
import qualified Data.ByteString.Lazy.Char8 as BL8
import qualified Data.Text as T
import qualified Data.Text.Encoding as T
import qualified Test.Tasty.Golden as Golden
import           Streaming as S
import           Streaming.Prelude as SP
import           System.FilePath (takeBaseName, replaceExtension)
import           Test.Tasty
import           Test.Tasty.HUnit
import           Test.Tasty.QuickCheck as QC
import           Test.Tasty.TH

import           Biobase.Types.BioSequence
import           Biobase.Types.Strand

import           Biobase.Fasta.Streaming
import           Biobase.Fasta.Strict



-- -- * golden tests
-- 
-- eachFasta (HeaderSize h) (OverlapSize o) (CurrentSize c p) = SP.yield (h,o,c)
-- 
-- readFastaFile ∷ FilePath → IO [(BS.ByteString,BS.ByteString,BS.ByteString)]
-- readFastaFile f = do
--   let s = 1000000
--   xs :> r ← runResourceT
--           $ SP.toList
--           $ streamingFasta (HeaderSize s) (OverlapSize 0) (CurrentSize s) eachFasta
--           $ S8.readFile f
--   return xs
-- 
-- lazyFastaOut = BL8.concat . P.map go
--   where go (h,o,c) = BL8.concat
--           [ BL8.fromStrict h
--           , BL8.pack "\n"
--           , BL8.fromStrict o
--           , BL8.pack "\n"
--           , BL8.fromStrict c
--           , BL8.pack "\n"
--           ]
-- 
-- goldenTests ∷ IO TestTree
-- goldenTests = do
--   fastaFiles ← Golden.findByExtension [".fa"] "./tests/"
--   return $ testGroup "readFastaFile golden tests"
--     [ Golden.goldenVsString
--         (takeBaseName fastaFile) -- test name
--         goldenFile -- golden file path
--         (lazyFastaOut <$> readFastaFile fastaFile) -- action whose result is tested
--     | fastaFile <- fastaFiles
--     , let goldenFile = replaceExtension fastaFile ".fa-golden"
--     ]

-- * unit tests

smallInlineFasta = P.unlines
  [ ">Aaaa"
  , "123"
  , ">Bbbb"
  , "4567"
  , ">Cccc"
  , "890"
  ]

smallTest ∷ Int → Int → Int → Of [BioSequenceWindow Void Void 1] ()
smallTest h o c = runIdentity
         . toList
--         . SP.map (view windowedFasta)
         . streamingFasta (HeaderSize h) (OverlapSize o) (CurrentSize c)
         . S8.fromStrict
         $ BS.pack smallInlineFasta
  where go (HeaderSize h) (OverlapSize o) (CurrentSize c) = yield (h,o,c)

smallTest333 = testCase "3/3/3" $ do
  let res :> r = smallTest 3 3 3
  assertEqual "return is null" () r
  assertEqual "length is 4" 4 (P.length res)
  assertEqual "!!0" (BioSequenceWindow "Aaa" ""    "123" "" PlusStrand 1) (res!!0)
  assertEqual "!!1" (BioSequenceWindow "Bbb" ""    "456" "" PlusStrand 1) (res!!1)
  assertEqual "!!2" (BioSequenceWindow "Bbb" "456" "7"   "" PlusStrand 4) (res!!2)
  assertEqual "!!3" (BioSequenceWindow "Ccc" ""    "890" "" PlusStrand 1) (res!!3)
  --
  assertEqual "!!0/Fasta" (Fasta "Aaa" "123") (view windowedFasta $ res!!0)
  assertEqual "!!1/Fasta" (Fasta "Bbb" "456") (view windowedFasta $ res!!1)
  assertEqual "!!2/Fasta" (Fasta "Bbb" "7"  ) (view windowedFasta $ res!!2)
  assertEqual "!!3/Fasta" (Fasta "Ccc" "890") (view windowedFasta $ res!!3)

main :: IO ()
main = do
--   gs ← goldenTests
   defaultMain $ testGroup "all tests"
--     [ testGroup "Golden" [gs]
     [ testGroup "unit tests" [smallTest333]
     ]