import std/[
  collections/sequtils,
  strformat,
  strutils,
  sugar,
]
import fp/[
  resultM,
]
import ./org_types
import ./org_builder
import ../parser/parser
# import ./org_text_link
# import ../utils/fp
# import ../parser/parser_internals
# import ../parser/parser_types
# import ../parser/builder_api

# -- Parsers

let boldParser* =               anyBetweenPair(ch('*'))
let italicParser* =             anyBetweenPair(ch('/'))
let underlineParser* =          anyBetweenPair(ch('_'))
let verbatimParser* =           anyBetweenPair(ch('='))
let codeParser* =               anyBetweenPair(ch('~'))
let strikeThroughParser* =      anyBetweenPair(ch('+'))

# let rawTokenizer* =           rawTextTokenizer(orgRawText)
# let boldTokenizer* =          textTokenizer(orgBoldText)
# let italicTokenizer* =        textTokenizer(orgItalicText)
# let underlineTokenizer* =     textTokenizer(orgUnderlineText)
# let verbatimTokenizer* =      textTokenizer(orgVerbatimText)
# let codeTokenizer* =          textTokenizer(orgCodeText)
# let strikeThroughTokenizer* = textTokenizer(orgStrikeThroughText)

# let tok = linkTokenizerSeq

# let orgStyledTextBuilders = @[
#   (boldParser,          boldTokenizer),
#   (italicParser,        italicTokenizer),
#   (underlineParser,     underlineTokenizer),
#   (verbatimParser,      verbatimTokenizer),
#   (codeParser,          codeTokenizer),
#   (strikeThroughParser, strikeThroughTokenizer),
#   (linkParser,          linkTokenizerSeq),
# ]

# proc makeRawTokenOrEmpty(tokens: seq[ParserToken]): seq[OrgInlineBuilderT] =
#   ## Merge all parser `tokens` into a string to tokenize for the builder.
#   ## Unless the string is empty, in this case return an empty list.
#   let str = tokens.foldl(a & b.tokenStringValue(), "")
#   if str.len == 0: @[]
#   else: @[rawTokenizer(str)]

# proc tryBuildInline*(content: string): OrgInlineBuilderResult =
#   initOrgInlineBuilder(content)
#   .flatMap((builder: OrgInlineBuilder) => tryParseBuild(
#     builder = builder,
#     builderFns = orgStyledTextBuilders,
#     defaultBuilderFn = makeRawTokenOrEmpty,
#   ))

# when isMainModule:
#   let test = tryBuildInline(
#     "Regular *bold* [[placeholder.com]] /italic/ _underline_ =verbatim= ~code~ +strikethrough+ [[https://placeholder.com][title]]"
#   )

#   echo test

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

    assert testParser("*bold*", boldParser) == "bold"
    assert testParser("/italic/", italicParser) == "italic"
    assert testParser("_underline_", underlineParser) == "underline"
    assert testParser("=verbatim=", verbatimParser) == "verbatim"
    assert testParser("~code~", codeParser) == "code"
    assert testParser("+strikeThrough+", strikeThroughParser) == "strikeThrough"