module HaskellWorks.Data.Json.Simple.Value where

import Data.Maybe
import HaskellWorks.Data.Json.Simple.Cursor
import HaskellWorks.Data.Positioning
import HaskellWorks.Data.RankSelect.Base.Select1
import HaskellWorks.Data.RankSelect.CsPoppy

import qualified Data.ByteString                           as BS
import qualified HaskellWorks.Data.BalancedParens          as BP
import qualified HaskellWorks.Data.BalancedParens.RangeMin as RM

data JsonValue
  = JsonValues JsonValues
  | JsonNull
  | JsonNumber Double
  | JsonString String
  | JsonBoolean Bool
  deriving (JsonValue -> JsonValue -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: JsonValue -> JsonValue -> Bool
$c/= :: JsonValue -> JsonValue -> Bool
== :: JsonValue -> JsonValue -> Bool
$c== :: JsonValue -> JsonValue -> Bool
Eq, Int -> JsonValue -> ShowS
[JsonValue] -> ShowS
JsonValue -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [JsonValue] -> ShowS
$cshowList :: [JsonValue] -> ShowS
show :: JsonValue -> String
$cshow :: JsonValue -> String
showsPrec :: Int -> JsonValue -> ShowS
$cshowsPrec :: Int -> JsonValue -> ShowS
Show)

data JsonValues
  = JsonArray  [JsonValue]
  | JsonObject [(String, JsonValue)]
  deriving (JsonValues -> JsonValues -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: JsonValues -> JsonValues -> Bool
$c/= :: JsonValues -> JsonValues -> Bool
== :: JsonValues -> JsonValues -> Bool
$c== :: JsonValues -> JsonValues -> Bool
Eq, Int -> JsonValues -> ShowS
[JsonValues] -> ShowS
JsonValues -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [JsonValues] -> ShowS
$cshowList :: [JsonValues] -> ShowS
show :: JsonValues -> String
$cshow :: JsonValues -> String
showsPrec :: Int -> JsonValues -> ShowS
$cshowsPrec :: Int -> JsonValues -> ShowS
Show)

snippetPos :: JsonCursor BS.ByteString CsPoppy (RM.RangeMin CsPoppy) -> (Count, Count)
snippetPos :: JsonCursor ByteString CsPoppy (RangeMin CsPoppy) -> (Count, Count)
snippetPos JsonCursor ByteString CsPoppy (RangeMin CsPoppy)
k = (Count
kpa, Count
kpz)
  where kpa :: Count
kpa   = forall v. Select1 v => v -> Count -> Count
select1 CsPoppy
kib Count
kta forall a. Num a => a -> a -> a
+ Count
km
        kpz :: Count
kpz   = forall v. Select1 v => v -> Count -> Count
select1 CsPoppy
kib Count
ktz forall a. Num a => a -> a -> a
- Count
km
        kib :: CsPoppy
kib   = forall t v w. JsonCursor t v w -> v
interests JsonCursor ByteString CsPoppy (RangeMin CsPoppy)
k
        kbp :: RangeMin CsPoppy
kbp   = forall t v w. JsonCursor t v w -> w
balancedParens JsonCursor ByteString CsPoppy (RangeMin CsPoppy)
k
        kra :: Count
kra   = forall t v w. JsonCursor t v w -> Count
cursorRank JsonCursor ByteString CsPoppy (RangeMin CsPoppy)
k
        krz :: Count
krz   = forall a. a -> Maybe a -> a
fromMaybe forall a. Bounded a => a
maxBound (forall v. FindClose v => v -> Count -> Maybe Count
BP.findClose RangeMin CsPoppy
kbp Count
kra)
        ksa :: Count
ksa   = Count
kra forall a. Num a => a -> a -> a
+ Count
1
        ksz :: Count
ksz   = Count
krz forall a. Num a => a -> a -> a
+ Count
1
        kta :: Count
kta   = Count
ksa forall a. Integral a => a -> a -> a
`div` Count
2
        ktz :: Count
ktz   = Count
ksz forall a. Integral a => a -> a -> a
`div` Count
2
        km :: Count
km    = Count
ksa forall a. Integral a => a -> a -> a
`mod` Count
2

snippet :: JsonCursor BS.ByteString CsPoppy (RM.RangeMin CsPoppy) -> BS.ByteString
snippet :: JsonCursor ByteString CsPoppy (RangeMin CsPoppy) -> ByteString
snippet JsonCursor ByteString CsPoppy (RangeMin CsPoppy)
k = let (Count
a, Count
z) = JsonCursor ByteString CsPoppy (RangeMin CsPoppy) -> (Count, Count)
snippetPos JsonCursor ByteString CsPoppy (RangeMin CsPoppy)
k in Int -> ByteString -> ByteString
BS.take (forall a b. (Integral a, Num b) => a -> b
fromIntegral (Count
z forall a. Num a => a -> a -> a
- Count
a forall a. Num a => a -> a -> a
+ Count
1)) (Int -> ByteString -> ByteString
BS.drop (forall a b. (Integral a, Num b) => a -> b
fromIntegral (Count
a forall a. Num a => a -> a -> a
- Count
1)) ByteString
kt)
  where kt :: ByteString
kt    = forall t v w. JsonCursor t v w -> t
cursorText JsonCursor ByteString CsPoppy (RangeMin CsPoppy)
k