import std/[
  collections/sequtils,
  sugar,
]
import fp/[
  option,
  resultM,
]
import ./org_types
import ./org_builder_api
import ./org_builder_link.nim
import ../parser/parser

# let lineTokenizer = (builder: OrgInlineBuilder) => tryTokenize(
#     builder = builder,
#     builderFns = styledTextTokenizers,
#     defaultTokenizerFn = tryTokenizeRawText,
#   )

# OrgDocucment

# -> Seq [Builder -> Builder]

# One of OrgBlock

# @[

#     OrgBuilderResult -> OrgBuilderResult
# ]
# with default OrgBuilder -> OrgBuilder
# until Eol

let listTypesParser = choice(@[
  ch('-'),
  ch('+'),
  choice(@[letter, digit]) + choice(@[ch('.'), ch(')')]),
])

let listStartParser = manyUntil(space, listTypesParser)
let listTypeParser = listTypesParser + ignore(space)
let listContentParser = anyUntil(newlineOrEol) + ignore(newlineOrEol)

proc buildListItem(builder: OrgBuilder): OrgBuilderResult =

  let (parser, tree) = builder

  # let initialParser = ParserResult.ok(parser)

  let beforeSpaces = ParserResult.ok(parser)
  .flatMap(listStartParser)
  .map(flattenTokens)

  let listType = beforeSpaces
  .map(emptyTokens)
  .flatMap(listTypeParser)
  .map(flattenTokens)

  let listContent = listType
  .map(emptyTokens)
  .flatMap(listContentParser)
  .map(flattenTokens)

  echo listContent

  builder.ok()

discard initOrgBuilder("  1. foo bar").map(buildListItem)


# proc buildParagraph*(
#   builder: OrgBuilder,
#   builderFns: seq[tuple[
#     builderFn: OrgBuilder -> OrgBuilderResult,
#     concatFn: OrgBuilder -> OrgBuilder,
#   ]],
#   stopAtParserFn = endOfStream,
# ): OrgBuilderResult =

#   var builderAcc = OrgBuilderResult.ok(builder)

#   while builderAcc.isOk() and builderAcc.applyParser(stopAtParserFn).isErr():
#     var found = false

#     for fn in builderFns:
#       let builderResult = builderAcc.flatMap(fn)

#       if builderResult.isOk():
#         found = true

#         builderAcc = builderAcc.map((x: OrgBuilder) => x.concat(builderResult.unsafeGet()))
#         break

# when isMainModule:
#   block testParsers:
#     proc testParser(str: string, parser: parserFnT): string =
#       initParserResult(str).flatMap(parser).tokensToString()

#     assert testParser("- List item", listItemParser) == "- List item"
#     assert testParser("  - List item", listItemParser) == "  - List item"