using @moonbitlang/core/ref { type Ref }

type TransitionResult[TR, S, O] = Result[(TR, S, O?), RuleRecognizerError]

pub trait DebugLogger {
  fn info(Self, String) -> Unit
  fn error(Self, String) -> Unit
  fn warn(Self, String) -> Unit
}

pub trait ErrOut {
  fn message(self : Self) -> String
  fn err_kind(self : Self) -> String
}

pub trait IriComponents {
  fn query(self : Self) -> String?
  fn is_absolute(self : Self) -> Bool
  fn scheme(self : Self) -> String?
  fn authority(self : Self) -> String?
  fn path(self : Self) -> String?
  fn fragment(self : Self) -> String?
}

pub trait RuleRecognizer {
  fn error_recovery_state(Self) -> Self
  fn recognize_next(Self, token : LocatedTokenOrLineJump, context : RdfContext, results : Array[RdfOut]) -> Self
  fn recognize_end(Self, context : RdfContext, results : Array[RdfOut]) -> Unit
  fn lexer_options(context : RdfContext) -> LexerOptions?
  fn[DL : DebugLogger] debug_logger(Self, debug_logger : DL) -> Unit
}

pub trait StateMachine {
  fn initial_state(Self) -> RdfState
  fn transition(Self, state : RdfState, event : LocatedTokenOrLineJump, context : RdfContext) -> Result[(Self, RdfState, RdfOut?), RuleRecognizerError]
  fn current_state(Self) -> RdfState
  fn step(Self, event : LocatedTokenOrLineJump) -> Self
  fn reset(Self) -> Self
  fn is_accepting(Self) -> Bool
  fn context(Self) -> RdfContext
  fn set_context(Self, RdfContext) -> Self
  fn[ST : StateWrapper] set_current_state(Self, state : ST) -> Self
  fn error_recovery_statemachine(Self) -> Self
}

pub trait StateWrapper {
  fn as_state_enum(Self) -> RdfState
}

pub trait StringRepr {
  fn as_stringview(self : Self) -> StringView
  fn into_string(self : Self) -> String
}

pub trait TokenRecognizer {
  fn recognize_next_token(Self, data : ArrayView[Byte], is_ending : Bool, options : LexerOptions?, location_ctx : SourcePos) -> (Int, Result[LocatedTokenOrLineJump, TokenRecognizerError])?
}

pub(all) suberror IriError {
  NoScheme
  Expected(Char, Int)
  InvalidIriCodePoint(Char, Int)
  InvalidPercentEncoding(Int)
  InvalidHostCharacter(Char, Int)
  InvalidHostIp(String, Int)
  InvalidPortCharacter(Char, Int)
  PathStartingWithTwoSlashes(Int)
  RelativePathSegment(Char, Int)
  InvalidErrMessage(String)
}

pub(all) suberror LanguageTagParseError {
  TagParseErr(TagParseErr)
}

pub(all) suberror LexerError {
  OutOfMemory(String)
  IoReadError(String)
  SyntaxError(String)
}

pub(all) suberror RuleRecognizerError {
  SyntaxError(String, Range)
  BlankNodeOrIriError
  PredicateNotAnIRI
  LiteralDatatypeError
  TripleMissingDot
  InvalidLanguageTag
  BlankNodePropertyListMissingEndBracket
}

pub(all) suberror TagParseErr {
  EmptyExtension
  EmptyPrivateUse
  ForbiddenChar
  InvalidSubtag
  InvalidLanguage
  SubtagTooLong
  EmptySubtag
  TooManyExtlangs
  InvalidLanguageLength
}

pub(all) suberror TokenRecognizerError {
  Invalid
  InvalidFormat(ArrayView[Byte], Range)
  InvalidToken(ArrayView[Byte], Range)
  InvalidCharacter(ArrayView[Byte], Range)
  IncompleteEscapeSequence(ArrayView[Byte], Range)
  InvalidEscapeSequence(ArrayView[Byte], Range)
  UnsupportedFeature(ArrayView[Byte], Range)
  IriTruncated(ArrayView[Byte], Range)
  IriParsingError(String, Range)
  UnexpectedEndOfInput(ArrayView[Byte], Range)
  InvalidErrMessage(ArrayView[Byte], Range, String)
}

pub(all) suberror TurtleError {
  TurtleParseError(String, Range)
  TurtleSyntaxError(String, Range)
  InvalidEscapeSequence
  InvalidCharacter(String)
  InvalidToken(SourcePos, String)
} derive(
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct Anonymous {
  id : UInt64
  str : String
} derive(Eq, Hash, 
@moonbitlang/core/debug.Debug
Debug)

pub struct AsyncReaderIterator[TR, RR] {
  reader : &
@moonbitlang/async/io.Reader
Reader
  parser : Parser[TR, RR]
}

pub struct AsyncReaderN3Parser[RL] {
  inner : AsyncReaderIterator[RL, N3Recognizer]
}

pub struct AsyncReaderNQuadsParser[RL] {
  inner : AsyncReaderIterator[RL, NQuadsRecognizer]
}

pub struct AsyncReaderNTriplesParser[RL] {
  inner : AsyncReaderIterator[RL, NQuadsRecognizer]
}

pub struct AsyncReaderTriGParser[RL] {
  inner : AsyncReaderIterator[RL, TriGRecognizer]
}

pub struct AsyncReaderTurtleParser[RL] {
  inner : AsyncReaderIterator[RL, TriGRecognizer]
}

pub struct AsyncWriterNQuadsSerializer[W] {
  buffer_writer : 
@moonbitlang/async/io.BufferedWriter
BufferedWriter[W]
  low_level_writer : LowLevelNQuadsSerializer
}

pub struct AsyncWriterNTriplesSerializer[W] {
  buffer_writer : 
@moonbitlang/async/io.BufferedWriter
BufferedWriter[W]
  low_level_writer : LowLevelNTriplesSerializer
}

pub struct AsyncWriterTriGSerializer[W] {
  buffer_writer : 
@moonbitlang/async/io.BufferedWriter
BufferedWriter[W]
  low_level_writer : LowLevelTriGSerializer
}

pub struct AsyncWriterTurtleSerializer[W] {
  buffer_writer : 
@moonbitlang/async/io.BufferedWriter
BufferedWriter[W]
  low_level_writer : LowLevelTriGSerializer
}

pub(all) enum BaseDirection {
  Ltr
  Rtl
} derive(Eq, Hash, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum BlankNode {
  Named(String)
  Anonymous(Anonymous)
} derive(Eq, Hash, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum BlankNodeRef {
  Named(StringView)
  Anonymous(Anonymous)
} derive(Eq, Hash, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum Command {
  ParseQuad(NamedOrBlankNodeRef, NamedNodeRef, TermRef, GraphNameRef)
  ParseTriple(NamedOrBlankNodeRef, NamedNodeRef, TermRef)
  ParseLiteralQuad(NamedOrBlankNodeRef, NamedNodeRef, String, String, GraphNameRef)
  ParseTypedLiteral(NamedOrBlankNodeRef, NamedNodeRef, String, NamedNodeRef, GraphNameRef)
  ParseBlankSubject(BlankNodeRef, NamedNodeRef, TermRef, GraphNameRef)
  ParseBlankObject(NamedOrBlankNodeRef, NamedNodeRef, BlankNodeRef, GraphNameRef)
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

type ConsoleLogger

pub(all) struct ExtensionsIterator {
  input : String
  subtags : Array[String]
  index : Int
}

pub(all) struct GenericStateMachine[M] {
  machine : M
  context : RdfContext
  outputs : Array[RdfOut]
}