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
(JsonValue -> JsonValue -> Bool)
-> (JsonValue -> JsonValue -> Bool) -> Eq JsonValue
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JsonValue -> JsonValue -> Bool
== :: JsonValue -> JsonValue -> Bool
$c/= :: JsonValue -> JsonValue -> Bool
/= :: JsonValue -> JsonValue -> Bool
Eq, Int -> JsonValue -> ShowS
[JsonValue] -> ShowS
JsonValue -> String
(Int -> JsonValue -> ShowS)
-> (JsonValue -> String)
-> ([JsonValue] -> ShowS)
-> Show JsonValue
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> JsonValue -> ShowS
showsPrec :: Int -> JsonValue -> ShowS
$cshow :: JsonValue -> String
show :: JsonValue -> String
$cshowList :: [JsonValue] -> ShowS
showList :: [JsonValue] -> ShowS
Show)

data JsonValues
  = JsonArray  [JsonValue]
  | JsonObject [(String, JsonValue)]
  deriving (JsonValues -> JsonValues -> Bool
(JsonValues -> JsonValues -> Bool)
-> (JsonValues -> JsonValues -> Bool) -> Eq JsonValues
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JsonValues -> JsonValues -> Bool
== :: JsonValues -> JsonValues -> Bool
$c/= :: JsonValues -> JsonValues -> Bool
/= :: JsonValues -> JsonValues -> Bool
Eq, Int -> JsonValues -> ShowS
[JsonValues] -> ShowS
JsonValues -> String
(Int -> JsonValues -> ShowS)
-> (JsonValues -> String)
-> ([JsonValues] -> ShowS)
-> Show JsonValues
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> JsonValues -> ShowS
showsPrec :: Int -> JsonValues -> ShowS
$cshow :: JsonValues -> String
show :: JsonValues -> String
$cshowList :: [JsonValues] -> ShowS
showList :: [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   = CsPoppy -> Count -> Count
forall v. Select1 v => v -> Count -> Count
select1 CsPoppy
kib Count
kta Count -> Count -> Count
forall a. Num a => a -> a -> a
+ Count
km
        kpz :: Count
kpz   = CsPoppy -> Count -> Count
forall v. Select1 v => v -> Count -> Count
select1 CsPoppy
kib Count
ktz Count -> Count -> Count
forall a. Num a => a -> a -> a
- Count
km
        kib :: CsPoppy
kib   = JsonCursor ByteString CsPoppy (RangeMin CsPoppy) -> CsPoppy
forall t v w. JsonCursor t v w -> v
interests JsonCursor ByteString CsPoppy (RangeMin CsPoppy)
k
        kbp :: RangeMin CsPoppy
kbp   = JsonCursor ByteString CsPoppy (RangeMin CsPoppy)
-> RangeMin CsPoppy
forall t v w. JsonCursor t v w -> w
balancedParens JsonCursor ByteString CsPoppy (RangeMin CsPoppy)
k
        kra :: Count
kra   = JsonCursor ByteString CsPoppy (RangeMin CsPoppy) -> Count
forall t v w. JsonCursor t v w -> Count
cursorRank JsonCursor ByteString CsPoppy (RangeMin CsPoppy)
k
        krz :: Count
krz   = Count -> Maybe Count -> Count
forall a. a -> Maybe a -> a
fromMaybe Count
forall a. Bounded a => a
maxBound (RangeMin CsPoppy -> Count -> Maybe Count
forall v. FindClose v => v -> Count -> Maybe Count
BP.findClose RangeMin CsPoppy
kbp Count
kra)
        ksa :: Count
ksa   = Count
kra Count -> Count -> Count
forall a. Num a => a -> a -> a
+ Count
1
        ksz :: Count
ksz   = Count
krz Count -> Count -> Count
forall a. Num a => a -> a -> a
+ Count
1
        kta :: Count
kta   = Count
ksa Count -> Count -> Count
forall a. Integral a => a -> a -> a
`div` Count
2
        ktz :: Count
ktz   = Count
ksz Count -> Count -> Count
forall a. Integral a => a -> a -> a
`div` Count
2
        km :: Count
km    = Count
ksa Count -> Count -> Count
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 (Count -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Count
z Count -> Count -> Count
forall a. Num a => a -> a -> a
- Count
a Count -> Count -> Count
forall a. Num a => a -> a -> a
+ Count
1)) (Int -> ByteString -> ByteString
BS.drop (Count -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Count
a Count -> Count -> Count
forall a. Num a => a -> a -> a
- Count
1)) ByteString
kt)
  where kt :: ByteString
kt    = JsonCursor ByteString CsPoppy (RangeMin CsPoppy) -> ByteString
forall t v w. JsonCursor t v w -> t
cursorText JsonCursor ByteString CsPoppy (RangeMin CsPoppy)
k