module Data.JLD.NodeMap (NodeMap, BNMParams (..)) where

import Data.JLD.Prelude

import Data.JLD.Control.Monad.RES (REST, execREST, runREST, withEnvRES, withErrorRES, withErrorRES', withStateRES)
import Data.JLD.Error (JLDError (..))
import Data.JLD.Model.ActiveContext (ActiveContext (..), containsProtectedTerm, lookupTerm, newActiveContext)
import Data.JLD.Model.Direction (Direction (..))
import Data.JLD.Model.IRI (CompactIRI (..), endsWithGenericDelim, isBlankIri, parseCompactIri)
import Data.JLD.Model.Keyword (Keyword (..), allKeywords, isKeyword, isKeywordLike, isNotKeyword, parseKeyword)
import Data.JLD.Model.Language (Language (..))
import Data.JLD.Model.TermDefinition (TermDefinition (..), newTermDefinition)
import Data.JLD.Model.URI (parseUri, uriToIri)
import Data.JLD.Options (ContextCache, Document (..), DocumentCache, DocumentLoader (..), JLDVersion (..))
import Data.JLD.Util (flattenSingletonArray, valueContains, valueContainsAny, valueIsTrue, valueToArray)

import Control.Monad.Except (MonadError (..))
import Data.Aeson (Object, Value (..))
import Data.Aeson.Key qualified as K (fromText, toText)
import Data.Aeson.KeyMap qualified as KM (delete, keys, lookup, member, size)
import Data.Map.Strict qualified as M (delete, insert, lookup)
import Data.RDF (parseIRI, parseRelIRI, resolveIRI, serializeIRI, validateIRI)
import Data.Set qualified as S (insert, member, notMember, size)
import Data.Text qualified as T (drop, dropEnd, elem, findIndex, isPrefixOf, null, take, toLower)
import Data.Vector qualified as V (length)
import Text.URI (URI, isPathAbsolute, relativeTo)
import Text.URI qualified as U (render)

type NodeMap = Map (Text, Text, Text) Value

type BNMT e m = REST BNMEnv (JLDError e) BNMState m

data BNMEnv = BNMEnv
    { bnmEnvDocument :: Value
    , bnmEnvActiveGraph :: Text
    , bnmEnvActiveSubject :: Maybe Text
    , bnmEnvActiveProperty :: Maybe Text
    }
    deriving (Show)

newtype BNMState = BNMState
    { bnmStateNodeMap :: NodeMap
    }
    deriving (Show, Eq)

data BNMParams = BNMParams
    { bnmParamsNodeMap :: NodeMap
    , bnmParamsActiveGraph :: Text
    , bnmParamsActiveSubject :: Maybe Text
    , bnmParamsActiveProperty :: Maybe Text
    , bnmParamsList :: Map Text Value
    }
    deriving (Show, Eq)

bnmModifyNodeMap :: Monad m => (NodeMap -> NodeMap) -> BNMT e m ()
bnmModifyNodeMap fn = modify \s -> s{bnmStateNodeMap = fn (bnmStateNodeMap s)}

buildNodeMap' :: Monad m => BNMT e m ()
buildNodeMap' = do
    pure ()

buildNodeMap :: Monad m => Value -> (BNMParams -> BNMParams) -> m NodeMap
buildNodeMap document paramsFn = do
    BNMState{..} <- buildNodeMap' |> execREST env st
    pure bnmStateNodeMap
  where
    BNMParams{..} =
        paramsFn
            BNMParams
                { bnmParamsNodeMap = mempty
                , bnmParamsActiveGraph = show KeywordDefault
                , bnmParamsActiveSubject = Nothing
                , bnmParamsActiveProperty = Nothing
                , bnmParamsList = mempty
                }

    env =
        BNMEnv
            { bnmEnvDocument = document
            , bnmEnvActiveGraph = bnmParamsActiveGraph
            , bnmEnvActiveSubject = bnmParamsActiveSubject
            , bnmEnvActiveProperty = bnmParamsActiveProperty
            }

    st =
        BNMState
            { bnmStateNodeMap = bnmParamsNodeMap
            }