import std/[
  collections/sequtils,
  sugar,
]
import fp/[
  resultM,
]
import ./org_types
import ../parser/parser

# -- OrgInlineBlock.Builder.Type

type OrgInlineBuilderT* = OrgInlineBlock
type OrgInlineBuilder* = Builder[OrgInlineBuilderT]
type OrgInlineBuilderResult* = BuilderResult[OrgInlineBuilderT]

# -- OrgInlineBlock.Builder.Initializers

func initOrgInlineBuilder*(content: string): OrgInlineBuilderResult =
  return OrgInlineBuilderResult.ok(OrgInlineBuilder((
    parser: initParser(content),
    tree: newSeq[OrgInlineBuilderT](),
  )))

func convertTokens*(kind: orgInlineBlockKind): seq[ParserToken] -> seq[OrgInlineBuilderT] =
  return func(tokens: seq[ParserToken]): seq[OrgInlineBuilderT] =
    return @[
      OrgInlineBuilderT(
        kind: kind,
        content: tokens.tokensToString(),
      )
    ]

# func rawTextTokenizer*(kind: orgInlineBlockKind): string -> OrgInlineBuilderT =
#   return func(content: string): OrgInlineBuilderT =
#     return OrgInlineBuilderT(
#       kind: kind,
#       content: content,
#     )

# ## Blocks
# type OrgBuilderT* = OrgBlock
# type OrgBuilder* = Builder[OrgBuilderT]
# type OrgBuilderResult* = BuilderResult[OrgBuilderT]

# func initOrgBuilder*(content: string): OrgBuilderResult =
#   return OrgBuilderResult.ok(OrgBuilder((
#     parser: initParser(content),
#     tree: newSeq[OrgBuilderT](),
#   )))

# # proc orgBuilderConcat*(typeInfo: OrgBuilderT, concatFn: (ParserToken, OrgBuilderT) -> OrgBuilderT):
# #                       (seq[ParserToken], OrgBuilderT) -> OrgBuilderT =
# #   return proc(xs: seq[ParserToken], builder: OrgBuilderT): OrgBuilderT =
# #     return xs.foldl(concatFn(b, a), typeInfo)


# proc orgBuilderApply*(concatFn: (ParserToken, OrgBuilderT) -> OrgBuilderT):
#   (seq[ParserToken], OrgBuilderT) -> OrgBuilderT =
#     return proc(tokens: seq[ParserToken], builder: OrgBuilderT): OrgBuilderT =
#       tokens.foldl(concatFn(b, a), builder)