import results
import fusion/matching
import ../utils/fp
import ../parser/parser_internals
import ../parser/parser_types

{.experimental: "caseStmtMacros".}

let propertiesKeyParser* = ignore(ch(':')) + anyUntil(choice(@[str(": "), str(":") + newline, newline]))
let propertiesValueParser* = ignore(str(":") + optional(ch(' '))) + optional(anyUntil(newline)) + ignore(newline)

let propertiesParser* = proc(parser: Parser): ParserResult {.closure.} =
  let tokens = parser.tokens

  let keyTokenParser = parser
  .emptyTokens()
  .propertiesKeyParser()
  .flatMap(flattenParserTokens)

  let valueTokenParser = keyTokenParser
  .map(emptyTokens)
  .flatMap(propertiesValueParser)
  .flatMap(flattenParserTokens)

  case (keyTokenParser, valueTokenParser):
    of (Some(@key), Some(@value)):
      ok(Parser(
        state: value.state,
        tokens: tokens & @[
          key.tokens[0],
          value.tokens[0],
        ]
      ))
    else: valueTokenParser

let propertiesStartParser* = str(":PROPERTIES:") + newline
let propertiesEndParser* = str(":PROPERTIES_END:") + newline

let parseProperties* = @[
  ignore(propertiesStartParser),
  manyUntil(
    propertiesParser,
    propertiesEndParser,
  ),
  ignore(propertiesEndParser),
]