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 tokenizeInlineTokens*(kind: orgInlineBlockKind): seq[ParserToken] -> seq[OrgInlineBuilderT] =
  return func(tokens: seq[ParserToken]): seq[OrgInlineBuilderT] =
    return @[
      OrgInlineBuilderT(
        kind: kind,
        content: tokens.tokensToString(),
      )
    ]

func tokenizeRawText*(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)