module HaskellWorks.Data.Xml.Succinct.Cursor.Create
  ( byteStringAsFastCursor
  , byteStringAsSlowCursor
  ) where

import Data.Coerce
import HaskellWorks.Data.BalancedParens.RangeMin2
import HaskellWorks.Data.BalancedParens.Simple
import HaskellWorks.Data.Bits.BitShown
import HaskellWorks.Data.RankSelect.CsPoppy1
import HaskellWorks.Data.Vector.Storable
import HaskellWorks.Data.Xml.Succinct.Cursor
import HaskellWorks.Data.Xml.Succinct.Cursor.BlankedXml
import HaskellWorks.Data.Xml.Succinct.Cursor.Types

import qualified Data.ByteString                         as BS
import qualified HaskellWorks.Data.Xml.Internal.ToIbBp64 as I

byteStringAsSlowCursor :: BS.ByteString -> SlowCursor
byteStringAsSlowCursor :: ByteString -> SlowCursor
byteStringAsSlowCursor ByteString
bs = XmlCursor :: forall t v w. t -> v -> w -> Count -> XmlCursor t v w
XmlCursor
  { cursorText :: ByteString
cursorText      = ByteString
bs
  , interests :: BitShown (Vector Count)
interests       = Vector Count -> BitShown (Vector Count)
forall a. a -> BitShown a
BitShown Vector Count
ib
  , balancedParens :: SimpleBalancedParens (Vector Count)
balancedParens  = Vector Count -> SimpleBalancedParens (Vector Count)
forall a. a -> SimpleBalancedParens a
SimpleBalancedParens Vector Count
bp
  , cursorRank :: Count
cursorRank      = Count
1
  }
  where blankedXml :: BlankedXml
blankedXml  = ByteString -> BlankedXml
bsToBlankedXml ByteString
bs
        bsLen :: Int
bsLen       = ByteString -> Int
BS.length ByteString
bs
        idxLen :: Int
idxLen      = (Int
bsLen Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
7) Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
8
        (Vector Count
ib, Vector Count
bp)    = Int -> [(ByteString, ByteString)] -> (Vector Count, Vector Count)
construct64UnzipN Int
idxLen (BlankedXml -> [(ByteString, ByteString)]
I.toIbBp64 BlankedXml
blankedXml)

byteStringAsFastCursor :: BS.ByteString -> FastCursor
byteStringAsFastCursor :: ByteString -> FastCursor
byteStringAsFastCursor ByteString
bs = ByteString -> CsPoppy1 -> RangeMin2 CsPoppy1 -> Count -> FastCursor
forall t v w. t -> v -> w -> Count -> XmlCursor t v w
XmlCursor ByteString
bs CsPoppy1
ibCsPoppy RangeMin2 CsPoppy1
rangeMinMax Count
r
  where XmlCursor ByteString
_ BitShown (Vector Count)
ib SimpleBalancedParens (Vector Count)
bp Count
r = ByteString -> SlowCursor
byteStringAsSlowCursor ByteString
bs
        bpCsPoppy :: CsPoppy1
bpCsPoppy           = Vector Count -> CsPoppy1
makeCsPoppy (SimpleBalancedParens (Vector Count) -> Vector Count
coerce SimpleBalancedParens (Vector Count)
bp)
        rangeMinMax :: RangeMin2 CsPoppy1
rangeMinMax         = CsPoppy1 -> RangeMin2 CsPoppy1
forall a. AsVector64 a => a -> RangeMin2 a
mkRangeMin2 CsPoppy1
bpCsPoppy
        ibCsPoppy :: CsPoppy1
ibCsPoppy           = Vector Count -> CsPoppy1
makeCsPoppy (BitShown (Vector Count) -> Vector Count
coerce BitShown (Vector Count)
ib)