import qualified Database.Bolty as Bolt
import           Data.Default   (def)

main :: IO ()
main = do
  let cfg = def{ Bolt.scheme = Bolt.Basic "neo4j" "password", Bolt.use_tls = False }
  case Bolt.validateConfig cfg of
    Failure errs -> mapM_ putStrLn errs
    Success vc   -> do
      conn <- Bolt.connect vc
      result <- Bolt.runBolt conn $
        Bolt.queryWith (Bolt.field "greeting" Bolt.text) "RETURN 'hello' AS greeting" mempty
      print result  -- Right (Vector ["hello"])
      Bolt.close conn

import Data.Default (def)

cfg = def
  { host    = "db.example.com"
  , port    = 7687
  , scheme  = Basic "neo4j" "s3cret"
  , use_tls = True
  , timeout = 5000  -- ms
  }

case validateConfig cfg of
  Failure errs -> error (show errs)
  Success vc   -> connect vc >>= ...

None                          -- no auth
Basic "user" "pass"           -- username/password
Bearer "jwt-token"            -- SSO / JWT token
Kerberos "base64-ticket"      -- Kerberos
Custom "scheme" credentials   -- custom auth provider

runBolt :: Connection -> BoltM a -> IO a

-- Auto-decode via FromBolt (returns Either DecodeError (Vector a))
query :: FromBolt a => Text -> HashMap Text Ps -> BoltM (Either DecodeError (Vector a))

-- Explicit decoder
queryWith :: RowDecoder a -> Text -> HashMap Text Ps -> BoltM (Either DecodeError (Vector a))

-- Raw result set (field names + records)
queryResult :: Text -> HashMap Text Ps -> BoltM ResultSet

-- Side-effects only, discard results
execute :: Text -> HashMap Text Ps -> BoltM ()

import Data.PackStream.Ps (Ps(..))
import qualified Data.HashMap.Lazy as H

queryWith decoder "MATCH (p:Person) WHERE p.age > $minAge RETURN p.name AS name"
  (H.singleton "minAge" (PsInteger 21))

bool   :: Decode Bool
int    :: Decode Int         -- may lose precision from Int64
int64  :: Decode Int64
float  :: Decode Double
text   :: Decode Text
bytes  :: Decode ByteString

data Person = Person { pName :: Text, pAge :: Int64 }

personDecoder :: RowDecoder Person
personDecoder = Person
  <$> field "name" text
  <*> field "age"  int64

result <- runBolt conn $
  queryWith personDecoder "MATCH (p:Person) RETURN p.name AS name, p.age AS age" mempty

data Person = Person { name :: Text, age :: Int64 }

personDecoder :: RowDecoder Person
personDecoder = do
  n <- field "p" node
  pure $ Person
    <$> nodeProperty "name" text n
    <*> nodeProperty "age"  int64 n

nullable :: Decode a -> Decode (Maybe a)    -- NULL-safe
list     :: Decode a -> Decode (Vector a)   -- list values
dict     :: Decode (HashMap Text Bolt)      -- raw dictionary
node     :: Decode Node                     -- graph node
relationship :: Decode Relationship         -- graph relationship
path     :: Decode Path                     -- graph path
uuid     :: Decode UUID                     -- UUID from string
utcTime  :: Decode UTCTime                  -- DateTime → UTCTime
day      :: Decode Day                      -- Date → Day
timeOfDay :: Decode TimeOfDay               -- LocalTime → TimeOfDay
aesonValue :: Decode Aeson.Value            -- Bolt → aeson Value

rs <- runBolt conn $ queryResult "MATCH (p:Person) RETURN p.name AS name, p.age AS age" mempty

-- Decode all rows
people <- either throwIO pure $ decodeResultSet personDecoder rs

-- Decode just the first row
first <- either throwIO pure $ decodeHead personDecoder rs

-- Group by a key field (consecutive grouping)
groups <- either throwIO pure $ groupByField (field "dept" (nullable text)) rs

withTransaction conn $ \txConn -> do
  runBolt txConn $ execute "CREATE (p:Person {name: 'Alice'})" mempty
  runBolt txConn $ execute "CREATE (p:Person {name: 'Bob'})" mempty
-- auto-commits on success, rolls back on exception

withRetryTransaction defaultRetryConfig conn $ \txConn ->
  runBolt txConn $ execute "CREATE (p:Person {name: 'Alice'})" mempty
-- retries up to 5 times with exponential backoff on transient Neo4j errors

pool <- createPool validatedConfig defaultPoolConfig
-- defaultPoolConfig: 10 max connections, 60s idle timeout, PingIfIdle 30s

withConnection pool $ \conn ->
  runBolt conn $ query @Person "MATCH (p:Person) RETURN p" mempty

-- Convenience: pool + retry transaction in one call
withTransaction' pool $ \conn ->
  runBolt conn $ execute "CREATE (n:Test)" mempty

destroyPool pool

AlwaysPing      -- send RESET before every use (safest)
PingIfIdle 30   -- only ping if idle > 30 seconds (default, good balance)
NeverPing       -- skip health check (fastest, use in trusted environments)

let cfg = def{ scheme = Basic "neo4j" "pass", routing = EnableRouting Nothing }

routingPool <- createRoutingPool validatedConfig defaultRoutingPoolConfig

-- Writes go to a writer server, reads to a reader
withRoutingTransaction routingPool WriteAccess $ \conn ->
  runBolt conn $ execute "CREATE (n:Test)" mempty

withRoutingTransaction routingPool ReadAccess $ \conn ->
  runBolt conn $ queryWith decoder "MATCH (n) RETURN n" mempty

destroyRoutingPool routingPool

session <- createSession pool defaultSessionConfig

-- Each transaction's bookmark is automatically passed to the next
writeTransaction session $ \conn ->
  runBolt conn $ execute "CREATE (p:Person {name: 'Alice'})" mempty

readTransaction session $ \conn ->
  runBolt conn $ queryWith decoder "MATCH (p:Person) RETURN p" mempty
-- ↑ guaranteed to see Alice because of bookmark chaining

bookmarks <- getLastBookmarks session

(result, meta) <- runBolt conn $ queryMetaWith decoder cypher params
-- meta :: QueryMeta contains:
--   parsedNotifications :: [Notification]  -- warnings, deprecations
--   parsedStats :: Maybe QueryStats         -- nodes/rels created/deleted
--   parsedPlan :: Maybe PlanNode            -- EXPLAIN plan
--   parsedProfile :: Maybe ProfileNode      -- PROFILE with execution stats
--   bookmark, db, tFirst, tLast             -- timing and metadata

-- EXPLAIN a query without executing it
plan <- runBolt conn $ queryExplain "MATCH (n) RETURN n" mempty

-- PROFILE a query with actual execution statistics
(rows, profile) <- runBolt conn $ queryProfile "MATCH (n) RETURN n" mempty

let cfg = def{ queryLogger = Just $ \ql meta -> do
      putStrLn $ "Query: " <> show (qlCypher ql)
      putStrLn $ "Rows:  " <> show (qlRowCount ql)
      putStrLn $ "Time:  " <> show (qlClientTime ql) <> "ns"
    }

-- Check if an error is transient (safe to retry)
isTransient :: Error -> Bool

-- Check if an error is a routing error (server unreachable, etc.)
isRoutingError :: Error -> Bool