## :License: MIT
##
## Introduction
## ============
## This module implements a TOML parser that is compliant with v0.5.0 of its spec.
##
## Source
## ======
## `Repo link <https://github.com/NimParsers/parsetoml>`_
##

# Copyright (c) 2015 Maurizio Tomasi and contributors
#
# Permission is hereby granted, free of charge, to any person
# obtaining a copy of this software and associated documentation files
# (the "Software"), to deal in the Software without restriction,
# including without limitation the rights to use, copy, modify, merge,
# publish, distribute, sublicense, and/or sell copies of the Software,
# and to permit persons to whom the Software is furnished to do so,
# subject to the following conditions:
#
# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.

import math
import streams
import strutils
import tables
import unicode
from parseutils import parseFloat

export tables

when (NimMajor, NimMinor, NimPatch) < (1, 4, 0):
  type
    IndexDefect* = IndexError
    OverflowDefect* = OverflowError

type
  Sign* = enum None, Pos, Neg

  TomlValueKind* {.pure.} = enum
    None
    Int,
    Float,
    Bool,
    Datetime,
    Date,
    Time,
    String,
    Array,
    Table

  TomlDate* = object
    year*: int
    month*: int
    day*: int

  TomlTime* = object
    hour*: int
    minute*: int
    second*: int
    subsecond*: int

  TomlDateTime* = object
    date*: TomlDate
    time*: TomlTime
    case shift*: bool
    of true:
      isShiftPositive*: bool
      zoneHourShift*: int
      zoneMinuteShift*: int
    of false: nil

  TomlTable* = OrderedTable[string, TomlValueRef]
  TomlTableRef* = ref TomlTable

  TomlValueRef* = ref TomlValue
  TomlValue* = object
    case kind*: TomlValueKind
    of TomlValueKind.None: nil
    of TomlValueKind.Int: intVal*: int64
    of TomlValueKind.Float:
      floatVal*: float64
      forcedSign*: Sign
    of TomlValueKind.Bool: boolVal*: bool
    of TomlValueKind.Datetime: dateTimeVal*: TomlDateTime
    of TomlValueKind.Date: dateVal*: TomlDate
    of TomlValueKind.Time: timeVal*: TomlTime
    of TomlValueKind.String: stringVal*: string
    of TomlValueKind.Array: arrayVal*: seq[TomlValueRef]
    of TomlValueKind.Table: tableVal*: TomlTableRef

  ParserState = object
    fileName*: string
    line*: int
    column*: int
    pushback: char
    stream*: streams.Stream
    curTableRef*: TomlTableRef

  TomlError* = object of ValueError
    location*: ParserState

  NumberBase = enum
    base10, base16, base8, base2

  StringType {.pure.} = enum
    Basic,  # Enclosed within double quotation marks
    Literal # Enclosed within single quotation marks

const
  defaultStringCapacity = 256
  ctrlChars = {'\x00' .. '\x08', '\x0A' .. '\x1F', '\x7F'} # '\x09' - TAB is not counted as control char
  ctrlCharsExclCrLf = ctrlChars - {'\x0A', '\x0D'}

proc newTomlError(location: ParserState, msg: string): ref TomlError =
  result = newException(TomlError, location.fileName & "(" & $location.line &
                        ":" & $location.column & ")" & " " & msg)
  result.location = location

proc getNextChar(state: var ParserState): char =
  # Return the next available char from the stream associate with
  # the parser state, or '\0' if there are no characters left.

  if state.pushback != '\0':
    # If we've just read a character without having interpreted
    # it, just return it
    result = state.pushback
    state.pushback = '\0'
  else:
    if state.stream.atEnd():
      return '\0'

    result = state.stream.readChar()

    # Update the line and column number
    if result == '\l':
      inc(state.line)
      state.column = 1
    elif result != '\r':
      inc(state.column)

proc pushBackChar(state: var ParserState, c: char) {.inline.} =
  state.pushback = c

type
  LfSkipMode = enum
    skipLf, skipNoLf

proc getNextNonWhitespace(state: var ParserState,
                          skip: LfSkipMode): char =
  # Note: this procedure does *not* consider a newline as a
  # "whitespace". Since newlines are often mandatory in TOML files
  # (e.g. after a key/value specification), we do not want to miss
  # them...

  let whitespaces = (case skip
                     of skipLf: {' ', '\t', '\r', '\l'}
                     of skipNoLf: {' ', '\t', '\r'})

  var nextChar: char
  while true:
    nextChar = state.getNextChar()
    if nextChar == '#':
      # Skip the comment up to the newline, but do not jump over it
      while nextChar != '\l' and nextChar != '\0':
        nextChar = state.getNextChar()
        # https://toml.io/en/v1.0.0#comment
        # Control characters other than tab (U+0009) are not permitted in comments.
        # Invalid control characters: U+0000 to U+0008, U+000A to U+001F, U+007F
        if nextChar in ctrlCharsExclCrLf:
          raise newTomlError(state, "invalid control char 0x$# found in a comment" % [nextChar.ord.toHex(2)])

    if nextChar notin whitespaces: break

  result = nextChar

proc charToInt(c: char, base: NumberBase): int {.inline, noSideEffect.} =
  case base
  of base10, base8, base2: result = int(c) - int('0')
  of base16:
    if c in strutils.Digits:
      result = charToInt(c, base10)
    else:
      result = 10 + int(toUpperAscii(c)) - int('A')

type
  LeadingChar {.pure.} = enum
    AllowZero, DenyZero

proc parseInt(state: var ParserState,
              base: NumberBase,
              leadingChar: LeadingChar): int64 =
  var
    nextChar: char
    firstPos = true
    negative = false
    wasUnderscore = false

  let
    baseNum = (case base
               of base2: 2
               of base8: 8
               of base10: 10
               of base16: 16)
    digits = (case base
              of base2: {'0', '1'}
              of base8: {'0', '1', '2', '3', '4', '5', '6', '7'}
              of base10: strutils.Digits
              of base16: strutils.HexDigits)

  result = 0
  while true:
    wasUnderscore = nextChar == '_'
    nextChar = state.getNextChar()
    if nextChar == '_':
      if firstPos or wasUnderscore:
        raise(newTomlError(state,
                           "underscore must be surrounded by digit"))
      continue

    if nextChar in {'+', '-'} and firstPos:
      firstPos = false
      if nextChar == '-': negative = true
      continue

    if nextChar == '0' and firstPos and leadingChar == LeadingChar.DenyZero:
      # TOML specifications forbid this
      var upcomingChar = state.getNextChar()
      if upcomingChar in Digits:
        raise(newTomlError(state,
                           "leading zeroes are not allowed in integers"))
      else:
        state.pushBackChar(upcomingChar)

    if nextChar notin digits:
      if wasUnderscore:
        raise(newTomlError(state,
                           "underscore must be surrounded by digit"))
      state.pushBackChar(nextChar)
      break

    try:
      result = result * baseNum - charToInt(nextChar, base)
    except OverflowDefect:
      raise(newTomlError(state,
                         "integer numbers wider than 64 bits not allowed"))

    firstPos = false

  if not negative:
    try:
      result = -result
    except OverflowDefect:
      raise(newTomlError(state,
                         "integer numbers wider than 64 bits not allowed"))

proc parseEncoding(state: var ParserState): TomlValueRef =
  let nextChar = state.getNextChar()
  case nextChar:
    of 'b':
      return TomlValueRef(kind: TomlValueKind.Int, intVal: parseInt(state, base2, LeadingChar.AllowZero))
    of 'o':
      return TomlValueRef(kind: TomlValueKind.Int, intVal: parseInt(state, base8, LeadingChar.AllowZero))
    of 'x':
      return TomlValueRef(kind: TomlValueKind.Int, intVal: parseInt(state, base16, LeadingChar.AllowZero))
    else: raise newTomlError(state, "illegal character")

proc parseDecimalPart(state: var ParserState): float64 =
  var
    nextChar: char
    firstPos = true
    wasUnderscore = false
    decimalPartStr = "0."

  while true:
    wasUnderscore = nextChar == '_'
    nextChar = state.getNextChar()
    if nextChar == '_':
      if firstPos or wasUnderscore:
        raise(newTomlError(state,
                           "underscore must be surrounded by digit"))
      continue
    if nextChar notin strutils.Digits:
      if wasUnderscore:
        raise(newTomlError(state,
                           "underscore must be surrounded by digit"))
      state.pushBackChar(nextChar)
      if firstPos:
        raise newTomlError(state, "decimal part empty")
      break

    decimalPartStr.add(nextChar)

    firstPos = false
  doAssert decimalPartStr.len > 2 # decimalPartStr shouldn't still be "0." at this point
  discard parseutils.parseFloat(decimalPartStr, result)

proc stringDelimiter(kind: StringType): char {.inline, noSideEffect.} =
  result = (case kind
            of StringType.Basic: '\"'
            of StringType.Literal: '\'')

proc parseUnicode(state: var ParserState): string =
  let
    escapeKindChar = state.getNextChar()
    oldState = (column: state.column, line: state.line)
    code = parseInt(state, base16, LeadingChar.AllowZero)
  if state.line != oldState.line:
    raise newTomlError(state, "invalid Unicode codepoint, can't span lines")
  if escapeKindChar == 'u' and state.column - 5 != oldState.column:
    raise newTomlError(state, "invalid Unicode codepoint, 'u' must have " &
                       "four character value")
  if escapeKindChar == 'U' and state.column - 9 != oldState.column:
    raise newTomlError(state, "invalid Unicode codepoint, 'U' must have " &
                       "eight character value")
  if code notin 0'i64..0xD7FF and code notin 0xE000'i64..0x10FFFF:
    raise(newTomlError(state, "invalid Unicode codepoint, " &
                       "must be a Unicode scalar value"))

  return unicode.toUTF8(Rune(code))

proc parseEscapeChar(state: var ParserState, escape: char): string =
  case escape
  of 'b': result = "\b"
  of 't': result = "\t"
  of 'n': result = "\l"
  of 'f': result = "\f"
  of 'r': result = "\r"
  of '\'': result = "\'"
  of '\"': result = "\""
  of '\\': result = "\\"
  of 'u', 'U':
    state.pushBackChar(escape)
    result = parseUnicode(state)
  else:
    raise(newTomlError(state,
                       "unknown escape " &
                       "sequence \"\\" & escape & "\""))

proc parseSingleLineString(state: var ParserState, kind: StringType): string =
  # This procedure parses strings enclosed within single/double
  # quotation marks. It assumes that the quotation mark has already
  # been consumed by the "state" variable, which therefore is ready
  # to read the first character of the string.

  result = newStringOfCap(defaultStringCapacity)

  let delimiter = stringDelimiter(kind)

  var nextChar: char
  while true:
    nextChar = state.getNextChar()
    if nextChar == delimiter:
      break

    if nextChar == '\0':
      raise(newTomlError(state, "unterminated string"))

    # https://toml.io/en/v1.0.0#string
    # Any Unicode character may be used except those that must be escaped:
    # quotation mark, backslash, and the control characters other than tab
    # (U+0000 to U+0008, U+000A to U+001F, U+007F).
    if nextChar in ctrlChars:
      raise(newTomlError(state, "invalid character in string: 0x$#" % nextChar.ord.toHex(2)))

    if nextChar == '\\' and kind == StringType.Basic:
      nextChar = state.getNextChar()
      result.add(state.parseEscapeChar(nextChar))
      continue

    result.add(nextChar)

proc parseMultiLineString(state: var ParserState, kind: StringType): string =
  # This procedure parses strings enclosed within three consecutive
  # sigle/double quotation marks. It assumes that all the quotation
  # marks have already been consumed by the "state" variable, which
  # therefore is ready to read the first character of the string.

  result = newStringOfCap(defaultStringCapacity)
  let delimiter = stringDelimiter(kind)
  var
    isFirstChar = true
    nextChar: char
  while true:
    nextChar = state.getNextChar()

    # Skip the first newline, if it comes immediately after the
    # quotation marks
    if isFirstChar and (nextChar == '\l'):
      isFirstChar = false
      continue

    if nextChar == delimiter:
      # Are we done?
      nextChar = state.getNextChar()
      if nextChar == delimiter:
        nextChar = state.getNextChar()
        if nextChar == delimiter:
          # Done with this string
          return
        else:
          # Just got a double delimiter
          result.add(delimiter & delimiter)
          state.pushBackChar(nextChar)
          continue
      else:
        # Just got a lone delimiter
        result.add(delimiter)
        state.pushBackChar(nextChar)
        continue

    if nextChar == '\\' and kind == StringType.Basic:
      # This can either be an escape sequence or a end-of-line char
      nextChar = state.getNextChar()
      if nextChar in {'\l', '\r', ' '}:
        # We're at the end of a line: skip everything till the
        # next non-whitespace character
        while nextChar in {'\l', '\r', ' ', '\t'}:
          nextChar = state.getNextChar()

        state.pushBackChar(nextChar)
        continue
      else:
        # This is just an escape sequence (like "\t")
        #nextChar = state.getNextChar()
        result.add(state.parseEscapeChar(nextChar))
        continue

    if nextChar == '\0':
      raise(newTomlError(state, "unterminated string"))

    # https://toml.io/en/v1.0.0#string
    # Any Unicode character may be used except those that must be
    # escaped: backslash and the control characters other than tab,
    # line feed, and carriage return (U+0000 to U+0008, U+000B,
    # U+000C, U+000E to U+001F, U+007F).
    if nextChar in ctrlCharsExclCrLf:
      raise(newTomlError(state, "invalid character in string: 0x$#" % nextChar.ord.toHex(2)))

    result.add(nextChar)
    isFirstChar = false

proc parseString(state: var ParserState, kind: StringType): string =
  ## This function assumes that "state" has already consumed the
  ## first character (either \" or \', which is passed in the
  ## "openChar" parameter).

  let delimiter = stringDelimiter(kind)
  var nextChar: char = state.getNextChar()
  if nextChar == delimiter:
    # We have two possibilities here: (1) the empty string, or (2)
    # "long" multi-line strings.
    nextChar = state.getNextChar()
    if nextChar == delimiter:
      return parseMultiLineString(state, kind)
    else:
      # Empty string. This was easy!
      state.pushBackChar(nextChar)
      return ""
  else:
    state.pushBackChar(nextChar)
    return parseSingleLineString(state, kind)

# Forward declaration
proc parseValue(state: var ParserState): TomlValueRef
proc parseInlineTable(state: var ParserState): TomlValueRef

proc parseArray(state: var ParserState): seq[TomlValueRef] =
  # This procedure assumes that "state" has already consumed the '['
  # character

  result = newSeq[TomlValueRef](0)

  while true:
    var nextChar: char = state.getNextNonWhitespace(skipLf)
    case nextChar
    of ']':
      return
    of ',':
      if len(result) == 0:
        # This happens with "[, 1, 2]", for instance
        raise(newTomlError(state, "first array element missing"))

      # Check that this is not a terminating comma (like in
      #  "[b,]")
      nextChar = state.getNextNonWhitespace(skipLf)
      if nextChar == ']':
        return

      state.pushBackChar(nextChar)
    else:
      let oldState = state # Saved for error messages
      var newValue: TomlValueRef
      if nextChar != '{':
        state.pushBackChar(nextChar)
        newValue = parseValue(state)
      else:
        newValue = parseInlineTable(state)

      if len(result) > 0:
        # Check that the type of newValue is compatible with the
        # previous ones
        if newValue.kind != result[low(result)].kind:
          raise(newTomlError(oldState,
                             "array members with incompatible types"))

      result.add(newValue)

proc parseStrictNum(state: var ParserState,
                    minVal: int,
                    maxVal: int,
                    count: Slice[int],
                    msg: string): int =
  var
    nextChar: char
    parsedChars = 0

  result = 0
  while true:
    nextChar = state.getNextChar()

    if nextChar notin strutils.Digits:
      state.pushBackChar(nextChar)
      break

    try:
      result = result * 10 + charToInt(nextChar, base10)
      parsedChars += 1
    except OverflowDefect:
      raise(newTomlError(state,
                         "integer numbers wider than 64 bits not allowed"))

  if parsedChars notin count:
    raise(newTomlError(state,
                       "too few or too many characters in digit, expected " &
                       $count & " got " & $parsedChars))

  if result < minVal or result > maxVal:
    raise(newTomlError(state, msg & " (" & $result & ")"))

template parseStrictNum(state: var ParserState,
                    minVal: int,
                    maxVal: int,
                    count: int,
                    msg: string): int =
  parseStrictNum(state, minVal, maxVal, (count..count), msg)

proc parseTimePart(state: var ParserState, val: var TomlTime) =
  var
    nextChar: char
    curLine = state.line

  # Parse the minutes
  val.minute = parseStrictNum(state, minVal = 0, maxVal = 59, count = 2,
                                   "number out of range for minutes")
  if curLine != state.line:
    raise(newTomlError(state, "invalid date field, stopped in or after minutes field"))

  nextChar = state.getNextChar()
  if nextChar != ':':
    raise(newTomlError(state,
                       "\":\" expected after the number of seconds"))

  # Parse the second. Note that seconds=60 *can* happen (leap second)
  val.second = parseStrictNum(state, minVal = 0, maxVal = 60, count = 2,
                                   "number out of range for seconds")

  nextChar = state.getNextChar()
  if nextChar == '.':
    val.subsecond = parseInt(state, base10, LeadingChar.AllowZero).int
  else:
    state.pushBackChar(nextChar)

proc parseDateTimePart(state: var ParserState,
                       dateTime: var TomlDateTime): bool =

  # This function is called whenever a datetime object is found. They follow
  # an ISO convention and can use one of the following format:
  #
  # - YYYY-MM-DDThh:mm:ss[+-]hh:mm
  # - YYYY-MM-DDThh:mm:ssZ
  #
  # where the "T" and "Z" letters are literals, [+-] indicates
  # *either* "+" or "-", YYYY is the 4-digit year, MM is the 2-digit
  # month, DD is the 2-digit day, hh is the 2-digit hour, mm is the
  # 2-digit minute, and ss is the 2-digit second. The hh:mm after
  # the +/- character is the timezone; a literal "Z" indicates the
  # local timezone.

  # This function assumes that the "YYYY-" part has already been
  # parsed (this happens because during parsing, finding a 4-digit
  # number like "YYYY" might just indicate the presence of an
  # integer or a floating-point number; it's the following "-" that
  # tells the parser that the value is a datetime). As a consequence
  # of this, we assume that "dateTime.year" has already been set.

  var
    nextChar: char
    curLine = state.line

  # Parse the month
  dateTime.date.month = parseStrictNum(state, minVal = 1, maxVal = 12, count = 2,
                                  "number out of range for the month")
  if curLine != state.line:
    raise(newTomlError(state, "invalid date field, stopped in or after month field"))

  nextChar = state.getNextChar()
  if nextChar != '-':
    raise(newTomlError(state, "\"-\" expected after the month number"))

  # Parse the day
  dateTime.date.day = parseStrictNum(state, minVal = 1, maxVal = 31, count = 2,
                                "number out of range for the day")
  if curLine != state.line:
    return false
  else:
    nextChar = state.getNextChar()
    if nextChar notin {'t', 'T', ' '}:
      raise(newTomlError(state, "\"T\", \"t\", or space expected after the day number"))

    # Parse the hour
    dateTime.time.hour = parseStrictNum(state, minVal = 0, maxVal = 23, count = 2,
                                   "number out of range for the hours")
    if curLine != state.line:
      raise(newTomlError(state, "invalid date field, stopped in or after hours field"))

    nextChar = state.getNextChar()
    if nextChar != ':':
      raise(newTomlError(state, "\":\" expected after the number of hours"))

    # Parse the minutes
    dateTime.time.minute = parseStrictNum(state, minVal = 0, maxVal = 59, count = 2,
                                     "number out of range for minutes")
    if curLine != state.line:
      raise(newTomlError(state, "invalid date field, stopped in or after minutes field"))

    nextChar = state.getNextChar()
    if nextChar != ':':
      raise(newTomlError(state,
                         "\":\" expected after the number of seconds"))

    # Parse the second. Note that seconds=60 *can* happen (leap second)
    dateTime.time.second = parseStrictNum(state, minVal = 0, maxVal = 60, count = 2,
                                     "number out of range for seconds")

    nextChar = state.getNextChar()
    if nextChar == '.':
      dateTime.time.subsecond = parseInt(state, base10, LeadingChar.AllowZero).int
    else:
      state.pushBackChar(nextChar)

    nextChar = state.getNextChar()
    case nextChar
    of 'z', 'Z':
      dateTime = TomlDateTime(
        time: dateTime.time,
        date: dateTime.date,
        shift: true,
        isShiftPositive: true,
        zoneHourShift: 0,
        zoneMinuteShift: 0
      )
    of '+', '-':
      dateTime = TomlDateTime(
        time: dateTime.time,
        date: dateTime.date,
        shift: true,
        isShiftPositive: (nextChar == '+')
      )
      dateTime.zoneHourShift =
        parseStrictNum(state, minVal = 0, maxVal = 23, count = 2,
                               "number out of range for shift hours")
      if curLine != state.line:
        raise(newTomlError(state, "invalid date field, stopped in or after shift hours field"))

      nextChar = state.getNextChar()
      if nextChar != ':':
        raise(newTomlError(state,
                           "\":\" expected after the number of shift hours"))

      dateTime.zoneMinuteShift =
        parseStrictNum(state, minVal = 0, maxVal = 59, count = 2,
                               "number out of range for shift minutes")
    else:
      if curLine == state.line:
        raise(newTomlError(state, "unexpected character " & escape($nextChar) &
                           " instead of the time zone"))
      else: # shift is automatically initialized to false
        state.pushBackChar(nextChar)

    return true

proc parseDateOrTime(state: var ParserState, digits: int, yearOrHour: int): TomlValueRef =
  var
    nextChar: char
    yoh = yearOrHour
    d = digits
  while true:
    nextChar = state.getNextChar()
    case nextChar:
      of ':':
        if d != 2:
          raise newTomlError(state, "wrong number of characters for hour")
        var val: TomlTime
        val.hour = yoh

        parseTimePart(state, val)
        return TomlValueRef(kind: TomlValueKind.Time, timeVal: val)
      of '-':
        if d != 4:
          raise newTomlError(state, "wrong number of characters for year")
        var val: TomlDateTime
        val.date.year = yoh
        let fullDate = parseDateTimePart(state, val)

        if fullDate:
          return TomlValueRef(kind: TomlValueKind.DateTime,
                                dateTimeVal: val)
        else:
          return TomlValueRef(kind: TomlValueKind.Date,
                                dateVal: val.date)
      of strutils.Digits:
        if d == 4:
          raise newTomlError(state, "leading zero not allowed")
        try:
          yoh *= 10
          yoh += ord(nextChar) - ord('0')
          d += 1
        except OverflowDefect:
          raise newTomlError(state, "number larger than 64 bits wide")
        continue
      of strutils.Whitespace:
        raise newTomlError(state, "leading zero not allowed")
      else: raise newTomlError(state, "illegal character")
    break

proc parseFloat(state: var ParserState, intPart: int, forcedSign: Sign): TomlValueRef =
  var
    decimalPart = parseDecimalPart(state)
    nextChar = state.getNextChar()
    exponent: int64 = 0
  if nextChar in {'e', 'E'}:
    exponent = parseInt(state, base10, LeadingChar.AllowZero)
  else:
    state.pushBackChar(nextChar)

  let value =
    if intPart <= 0:
      pow(10.0, exponent.float64) * (float64(intPart) - decimalPart)
    else:
      pow(10.0, exponent.float64) * (float64(intPart) + decimalPart)
  return TomlValueRef(kind: TomlValueKind.Float, floatVal: if forcedSign != Neg: -value else: value, forcedSign: forcedSign)

proc parseNumOrDate(state: var ParserState): TomlValueRef =
  var
    nextChar: char
    forcedSign: Sign = None

  while true:
    nextChar = state.getNextChar()
    case nextChar:
      of '0':
        nextChar = state.getNextChar()
        if forcedSign == None:
          if nextChar in {'b', 'x', 'o'}:
            state.pushBackChar(nextChar)
            return parseEncoding(state)
          else:
            # This must now be a float or a date/time, or a sole 0
            case nextChar:
              of '.':
                return parseFloat(state, 0, forcedSign)
              of strutils.Whitespace:
                state.pushBackChar(nextChar)
                return TomlValueRef(kind: TomlValueKind.Int, intVal: 0)
              of strutils.Digits:
                # This must now be a date/time
                return parseDateOrTime(state, digits = 2, yearOrHour = ord(nextChar) - ord('0'))
              else:
                # else is a sole 0
                return TomlValueRef(kind: TomlValueKind.Int, intVal: 0)
        else:
          # This must now be a float, or a sole 0
          case nextChar:
            of '.':
              return parseFloat(state, 0, forcedSign)
            of strutils.Whitespace:
              state.pushBackChar(nextChar)
              return TomlValueRef(kind: TomlValueKind.Int, intVal: 0)
            else:
              # else is a sole 0
              return TomlValueRef(kind: TomlValueKind.Int, intVal: 0)
      of strutils.Digits - {'0'}:
        # This might be a date/time, or an int or a float
        var
          digits = 1
          curSum = ord('0') - ord(nextChar)
          wasUnderscore = false
        while true:
          nextChar = state.getNextChar()
          if wasUnderscore and nextChar notin strutils.Digits:
            raise newTomlError(state, "underscores must be surrounded by digits")
          case nextChar:
            of ':':
              if digits != 2:
                raise newTomlError(state, "wrong number of characters for hour")
              var val: TomlTime
              val.hour = -curSum
              parseTimePart(state, val)
              return TomlValueRef(kind: TomlValueKind.Time, timeVal: val)
            of '-':
              if digits != 4:
                raise newTomlError(state, "wrong number of characters for year")
              var val: TomlDateTime
              val.date.year = -curSum
              let fullDate = parseDateTimePart(state, val)
              if fullDate:
                return TomlValueRef(kind: TomlValueKind.DateTime,
                                      dateTimeVal: val)
              else:
                return TomlValueRef(kind: TomlValueKind.Date,
                                      dateVal: val.date)
            of '.':
              return parseFloat(state, curSum, forcedSign)
            of 'e', 'E':
              var exponent = parseInt(state, base10, LeadingChar.AllowZero)
              let value = pow(10.0, exponent.float64) * float64(curSum)
              return TomlValueRef(kind: TomlValueKind.Float, floatVal: if forcedSign != Neg: -value else: value)
            of strutils.Digits:
              try:
                curSum *= 10
                curSum += ord('0') - ord(nextChar)
                digits += 1
              except OverflowDefect:
                raise newTomlError(state, "number larger than 64 bits wide")
              wasUnderscore = false
              continue
            of '_':
              wasUnderscore = true
              continue
            of strutils.Whitespace:
              state.pushBackChar(nextChar)
              return TomlValueRef(kind: TomlValueKind.Int, intVal: if forcedSign != Neg: -curSum else: curSum)
            else:
              state.pushBackChar(nextChar)
              return TomlValueRef(kind: TomlValueKind.Int, intVal: if forcedSign != Neg: -curSum else: curSum)
          break
      of '+', '-':
        forcedSign = if nextChar == '+': Pos else: Neg
        continue
      of 'i':
        #  Is this "inf"?
        let oldState = state
        if state.getNextChar() != 'n' or
           state.getNextChar() != 'f':
            raise(newTomlError(oldState, "unknown identifier"))
        return TomlValueRef(kind: TomlValueKind.Float, floatVal: if forcedSign == Neg: NegInf else: Inf, forcedSign: forcedSign)

      of 'n':
        #  Is this "nan"?
        let oldState = state
        if state.getNextChar() != 'a' or
           state.getNextChar() != 'n':
            raise(newTomlError(oldState, "unknown identifier"))
        return TomlValueRef(kind: TomlValueKind.Float, floatVal: NaN, forcedSign: forcedSign)
      else:
        raise newTomlError(state, "illegal character " & escape($nextChar))
    break

proc parseValue(state: var ParserState): TomlValueRef =
  var nextChar: char

  nextChar = state.getNextNonWhitespace(skipNoLf)
  case nextChar
  of strutils.Digits, '+', '-', 'i', 'n':
    state.pushBackChar(nextChar)
    return parseNumOrDate(state)
  of 't':
    # Is this "true"?
    let oldState = state # Only used for error messages
    if state.getNextChar() != 'r' or
       state.getNextChar() != 'u' or
       state.getNextChar() != 'e':
        raise(newTomlError(oldState, "unknown identifier"))
    result = TomlValueRef(kind: TomlValueKind.Bool, boolVal: true)

  of 'f':
    # Is this "false"?
    let oldState = state # Only used for error messages
    if state.getNextChar() != 'a' or
       state.getNextChar() != 'l' or
       state.getNextChar() != 's' or
       state.getNextChar() != 'e':
        raise(newTomlError(oldState, "unknown identifier"))
    result = TomlValueRef(kind: TomlValueKind.Bool, boolVal: false)

  of '\"':
    # A basic string (accepts \ escape codes)
    result = TomlValueRef(kind: TomlValueKind.String,
                          stringVal: parseString(state, StringType.Basic))

  of '\'':
    # A literal string (does not accept \ escape codes)
    result = TomlValueRef(kind: TomlValueKind.String,
                          stringVal: parseString(state, StringType.Literal))

  of '[':
    # An array
    result = TomlValueRef(kind: TomlValueKind.Array,
                          arrayVal: parseArray(state))
  else:
    raise(newTomlError(state,
                       "unexpected character " & escape($nextChar)))

proc parseName(state: var ParserState): string =
  # This parses the name of a key or a table
  result = newStringOfCap(defaultStringCapacity)

  var nextChar = state.getNextNonWhitespace(skipNoLf)
  if nextChar == '\"':
    return state.parseString(StringType.Basic)
  elif nextChar == '\'':
    return state.parseString(StringType.Literal)
  state.pushBackChar(nextChar)
  while true:
    nextChar = state.getNextChar()
    if (nextChar in {'=', '.', '[', ']', '\0', ' ', '\t'}):
      # Any of the above characters marks the end of the name
      state.pushBackChar(nextChar)
      break
    elif (nextChar notin {'a'..'z', 'A'..'Z', '0'..'9', '_', '-'}):
      raise(newTomlError(state,
        "bare key has illegal character: " & escape($nextChar)))
    else:
      result.add(nextChar)

type
  BracketType {.pure.} = enum
    single, double

proc parseTableName(state: var ParserState,
                    brackets: BracketType): seq[string] =
  # This code assumes that '[' has already been consumed
  result = newSeq[string](0)

  while true:
    #let partName = state.parseName(SpecialChars.AllowNumberSign)
    var
      nextChar = state.getNextChar()
      partName: string
    if nextChar == '"':
      partName = state.parseString(StringType.Basic)
    else:
      state.pushBackChar(nextChar)
      partName = state.parseName()
    result.add(partName)

    nextChar = state.getNextNonWhitespace(skipNoLf)
    case nextChar
    of ']':
      if brackets == BracketType.double:
        nextChar = state.getNextChar()
        if nextChar != ']':
          raise(newTomlError(state,
                             "\"]]\" expected"))

      # We must check that there is nothing else in this line
      nextChar = state.getNextNonWhitespace(skipNoLf)
      if nextChar notin {'\l', '\0'}:
        raise(newTomlError(state,
                           "unexpected character " & escape($nextChar)))

      break

    of '.': continue
    else:
      raise(newTomlError(state,
                         "unexpected character " & escape($nextChar)))

proc setEmptyTableVal(val: var TomlValueRef) =
  val = TomlValueRef(kind: TomlValueKind.Table)
  new(val.tableVal)
  val.tableVal[] = initOrderedTable[string, TomlValueRef]()

proc parseInlineTable(state: var ParserState): TomlValueRef =
  new(result)
  setEmptyTableVal(result)
  var firstComma = true
  while true:
    var nextChar = state.getNextNonWhitespace(skipNoLf)
    case nextChar
    of '}':
      return
    of ',':
      if firstComma:
        raise(newTomlError(state, "first inline table element missing"))
      # Check that this is not a terminating comma (like in
      #  "[b,]")
      nextChar = state.getNextNonWhitespace(skipNoLf)
      if nextChar == '}':
        return

      state.pushBackChar(nextChar)
    of '\n':
      raise(newTomlError(state, "inline tables cannot contain newlines"))
    else:
      firstComma = false
      state.pushBackChar(nextChar)
      var key = state.parseName()

      nextChar = state.getNextNonWhitespace(skipNoLf)
      var curTable = result.tableVal
      while nextChar == '.':
        var deepestTable = new(TomlTableRef)
        deepestTable[] = initOrderedTable[string, TomlValueRef]()
        curTable[key] = TomlValueRef(kind: TomlValueKind.Table, tableVal: deepestTable)
        curTable = deepestTable
        key = state.parseName()
        nextChar = state.getNextNonWhitespace(skipNoLf)

      if nextChar != '=':
        raise(newTomlError(state,
                           "key names cannot contain spaces"))
      nextChar = state.getNextNonWhitespace(skipNoLf)
      if nextChar == '{':
        curTable[key] = state.parseInlineTable()
      else:
        state.pushBackChar(nextChar)
        curTable[key] = state.parseValue()

proc createTableDef(state: var ParserState,
                    tableNames: seq[string],
                    dotted = false)

proc parseKeyValuePair(state: var ParserState) =
  var
    tableKeys: seq[string]
    key: string
    nextChar: char
    oldTableRef = state.curTableRef

  while true:
    let subkey = state.parseName()

    nextChar = state.getNextNonWhitespace(skipNoLf)
    if nextChar == '.':
      tableKeys.add subkey
    else:
      if tableKeys.len != 0:
        createTableDef(state, tableKeys, dotted = true)
      key = subkey
      break

  if nextChar != '=':
    raise(newTomlError(state,
                       "key names cannot contain character \"" & nextChar & "\""))

  nextChar = state.getNextNonWhitespace(skipNoLf)
  # Check that this is a regular value and not an inline table
  if nextChar != '{':
    state.pushBackChar(nextChar)
    let value = state.parseValue()

    # We must check that there is nothing else in this line
    nextChar = state.getNextNonWhitespace(skipNoLf)
    if nextChar != '\l' and nextChar != '\0':
      raise(newTomlError(state,
                         "unexpected character " & escape($nextChar)))

    if state.curTableRef.hasKey(key):
      raise(newTomlError(state,
                         "duplicate key, \"" & key & "\" already in table"))
    state.curTableRef[key] = value
  else:
    #createTableDef(state, @[key])
    if key.len == 0:
      raise newTomlError(state, "empty key not allowed")
    if state.curTableRef.hasKey(key):
      raise newTomlError(state, "duplicate table key not allowed")
    state.curTableRef[key] = parseInlineTable(state)

  state.curTableRef = oldTableRef

proc newParserState(s: streams.Stream,
                    fileName: string = ""): ParserState =
  result = ParserState(fileName: fileName, line: 1, column: 1, stream: s)

proc setArrayVal(val: var TomlValueRef, numOfElems: int = 0) =
  val = TomlValueRef(kind: TomlValueKind.Array)
  val.arrayVal = newSeq[TomlValueRef](numOfElems)

proc advanceToNextNestLevel(state: var ParserState,
                            tableName: string) =
  let target = state.curTableRef[tableName]
  case target.kind
  of TomlValueKind.Table:
    state.curTableRef = target.tableVal
  of TomlValueKind.Array:
    let arr = target.arrayVal[high(target.arrayVal)]
    if arr.kind != TomlValueKind.Table:
      raise(newTomlError(state, "\"" & tableName &
                         "\" elements are not tables"))
    state.curTableRef = arr.tableVal
  else:
    raise(newTomlError(state, "\"" & tableName &
                       "\" is not a table"))

# This function is called by the TOML parser whenever a
# "[[table.name]]" line is encountered in the parsing process. Its
# purpose is to make sure that all the parent nodes in "table.name"
# exist and are tables, and that a terminal node of the correct type
# is created.
#
# Starting from "curTableRef" (which is usually the root object),
# traverse the object tree following the names in "tableNames" and
# create a new TomlValueRef object of kind "TomlValueKind.Array" at
# the terminal node. This array is going to be an array of tables: the
# function will create an element and will make "curTableRef"
# reference it. Example: if tableNames == ["a", "b", "c"], the code
# will look for the "b" table that is child of "a", and then it will
# check if "c" is a child of "b". If it is, it must be an array of
# tables, and a new element will be appended. Otherwise, a new "c"
# array is created, and an empty table element is added in "c". In
# either cases, curTableRef will refer to the last element of "c".

proc createOrAppendTableArrayDef(state: var ParserState,
                                 tableNames: seq[string]) =
  # This is a table array entry (e.g. "[[entry]]")
  for idx, tableName in tableNames:
    if tableName.len == 0:
      raise(newTomlError(state,
                         "empty key not allowed"))
    let lastTableInChain = idx == high(tableNames)

    var newValue: TomlValueRef
    if not state.curTableRef.hasKey(tableName):
      # If this element does not exist, create it
      new(newValue)

      # If this is the last name in the chain (e.g.,
      # "c" in "a.b.c"), its value should be an
      # array of tables, otherwise just a table
      if lastTableInChain:
        setArrayVal(newValue, 1)

        new(newValue.arrayVal[0])
        setEmptyTableVal(newValue.arrayVal[0])

        state.curTableRef[tableName] = newValue
        state.curTableRef = newValue.arrayVal[0].tableVal
      else:
        setEmptyTableVal(newValue)

        # Add the newly created object to the current table
        state.curTableRef[tableName] = newValue

        # Update the pointer to the current table
        state.curTableRef = newValue.tableVal
    else:
      # The element exists: is it of the right type?
      let target = state.curTableRef[tableName]

      if lastTableInChain:
        if target.kind != TomlValueKind.Array:
          raise(newTomlError(state, "\"" & tableName &
                                    "\" is not an array"))

        var newValue: TomlValueRef
        new(newValue)
        setEmptyTableVal(newValue)
        target.arrayVal.add(newValue)
        state.curTableRef = newValue.tableVal
      else:
        advanceToNextNestLevel(state, tableName)

# Starting from "curTableRef" (which is usually the root object),
# traverse the object tree following the names in "tableNames" and
# create a new TomlValueRef object of kind "TomlValueKind.Table" at
# the terminal node. Example: if tableNames == ["a", "b", "c"], the
# code will look for the "b" table that is child of "a" and it will
# create a new table "c" which is "b"'s children.

proc createTableDef(state: var ParserState,
                    tableNames: seq[string],
                    dotted = false) =
  var newValue: TomlValueRef

  # This starts a new table (e.g. "[table]")
  for i, tableName in tableNames:
    if tableName.len == 0:
      raise(newTomlError(state,
                         "empty key not allowed"))
    if not state.curTableRef.hasKey(tableName):
      new(newValue)
      setEmptyTableVal(newValue)

      # Add the newly created object to the current table
      state.curTableRef[tableName] = newValue

      # Update the pointer to the current table
      state.curTableRef = newValue.tableVal
    else:
      if i == tableNames.high and state.curTableRef.hasKey(tableName) and
        state.curTableRef[tableName].kind == TomlValueKind.Table:
        if state.curTableRef[tableName].tableVal.len == 0:
          raise newTomlError(state, "duplicate table key not allowed")
        elif not dotted:
          for value in state.curTableRef[tableName].tableVal.values:
            if value.kind != TomlValueKind.Table:
              raise newTomlError(state, "duplicate table key not allowed")
      advanceToNextNestLevel(state, tableName)

proc parseStream*(inputStream: streams.Stream,
                  fileName: string = ""): TomlValueRef =
  ## Parses a stream of TOML formatted data into a TOML table. The optional
  ## filename is used for error messages.
  if inputStream == nil:
    raise newException(IOError,
      "Unable to read from the stream created from: \"" & fileName & "\", " &
      "possibly a missing file")
  var state = newParserState(inputStream, fileName)
  result = TomlValueRef(kind: TomlValueKind.Table)
  new(result.tableVal)
  result.tableVal[] = initOrderedTable[string, TomlValueRef]()

  # This pointer will always point to the table that should get new
  # key/value pairs found in the TOML file during parsing
  state.curTableRef = result.tableVal

  # Unlike "curTableRef", this pointer never changes: it always
  # points to the uppermost table in the tree
  let baseTable = result.tableVal

  var nextChar: char
  while true:
    nextChar = state.getNextNonWhitespace(skipLf)
    case nextChar
    of '[':
      # A new section/table begins. We'll have to start again
      # from the uppermost level, so let's rewind curTableRef to
      # the root node
      state.curTableRef = baseTable

      # First, decompose the table name into its part (e.g.,
      # "a.b.c" -> ["a", "b", "c"])
      nextChar = state.getNextChar()
      let isTableArrayDef = nextChar == '['
      var tableNames: seq[string]
      if isTableArrayDef:
        tableNames = state.parseTableName(BracketType.double)
      else:
        state.pushBackChar(nextChar)
        tableNames = state.parseTableName(BracketType.single)

      # Now create the proper (empty) data structure: either a
      # table or an array of tables. Note that both functions
      # update the "curTableRef" variable: they have to, since
      # the TOML specification says that any "key = value"
      # statement that follows is a child of the table we're
      # defining right now, and we use "curTableRef" as a
      # reference to the table that gets every next key/value
      # definition.
      if isTableArrayDef:
        createOrAppendTableArrayDef(state, tableNames)
      else:
        createTableDef(state, tableNames)

    of '=':
      raise(newTomlError(state, "key name missing"))
    of '#', '.', ']':
      raise(newTomlError(state,
                         "unexpected character " & escape($nextChar)))
    of '\0': # EOF
      return
    else:
      # Everything else marks the presence of a "key = value" pattern
      state.pushBackChar(nextChar)
      parseKeyValuePair(state)

proc parseString*(tomlStr: string, fileName: string = ""): TomlValueRef =
  ## Parses a string of TOML formatted data into a TOML table. The optional
  ## filename is used for error messages.
  let strStream = newStringStream(tomlStr)
  try:
    result = parseStream(strStream, fileName)
  finally:
    strStream.close()

proc parseFile*(f: File, fileName: string = ""): TomlValueRef =
  ## Parses a file of TOML formatted data into a TOML table. The optional
  ## filename is used for error messages.
  let fStream = newFileStream(f)
  try:
    result = parseStream(fStream, fileName)
  finally:
    fStream.close()

proc parseFile*(fileName: string): TomlValueRef =
  ## Parses the file found at fileName with TOML formatted data into a TOML
  ## table.
  let fStream = newFileStream(fileName, fmRead)
  if not isNil(fStream):
    try:
      result = parseStream(fStream, fileName)
    finally:
      fStream.close()
  else:
    raise newException(IOError, "cannot open: " & fileName)


proc `$`*(val: TomlDate): string =
  ## Converts the TOML date object into the ISO format read by the parser
  result = ($val.year).align(4, '0') & "-" & ($val.month).align(2, '0') & "-" &
    ($val.day).align(2, '0')

proc `$`*(val: TomlTime): string =
  ## Converts the TOML time object into the ISO format read by the parser
  result = ($val.hour).align(2, '0') & ":" &
    ($val.minute).align(2, '0') & ":" & ($val.second).align(2, '0') &
    (if val.subsecond > 0: ("." & $val.subsecond) else: "")

proc `$`*(val: TomlDateTime): string =
  ## Converts the TOML date-time object into the ISO format read by the parser
  result = $val.date & "T" & $val.time &
    (if not val.shift: "" else: (
      (if val.zoneHourShift == 0 and val.zoneMinuteShift == 0: "Z" else: (
        ((if val.isShiftPositive: "+" else: "-") &
        ($val.zoneHourShift).align(2, '0') & ":" &
        ($val.zoneMinuteShift).align(2, '0'))
      ))
    ))

proc toTomlString*(value: TomlValueRef): string

proc `$`*(val: TomlValueRef): string =
  ## Turns whatever value into a regular Nim value representtation
  case val.kind
  of TomlValueKind.None:
    result = "nil"
  of TomlValueKind.Int:
    result = $val.intVal
  of TomlValueKind.Float:
    result = $val.floatVal
  of TomlValueKind.Bool:
    result = $val.boolVal
  of TomlValueKind.Datetime:
    result = $val.dateTimeVal
  of TomlValueKind.Date:
    result = $val.dateVal
  of TomlValueKind.Time:
    result = $val.timeVal
  of TomlValueKind.String:
    result = $val.stringVal
  of TomlValueKind.Array:
    result = ""
    for elem in val.arrayVal:
      result.add($(elem[]))
  of TomlValueKind.Table:
    result = val.toTomlString

proc `$`*(val: TomlValue): string =
  ## Turns whatever value into a type and value representation, used by ``dump``
  case val.kind
  of TomlValueKind.None:
    result = "none()"
  of TomlValueKind.Int:
    result = "int(" & $val.intVal & ")"
  of TomlValueKind.Float:
    result = "float(" & $val.floatVal & ")"
  of TomlValueKind.Bool:
    result = "boolean(" & $val.boolVal & ")"
  of TomlValueKind.Datetime:
    result = "datetime(" & $val.dateTimeVal & ")"
  of TomlValueKind.Date:
    result = "date(" & $val.dateVal & ")"
  of TomlValueKind.Time:
    result = "time(" & $val.timeVal & ")"
  of TomlValueKind.String:
    result = "string(\"" & $val.stringVal & "\")"
  of TomlValueKind.Array:
    result = "array("
    for elem in val.arrayVal:
      result.add($(elem[]))
    result.add(")")
  of TomlValueKind.Table:
    result = "table(" & $(len(val.tableVal)) & " elements)"

proc dump*(table: TomlTableRef, indentLevel: int = 0) =
  ## Dump out the entire table as it was parsed. This procedure is mostly
  ## useful for debugging purposes
  let space = spaces(indentLevel)
  for key, val in pairs(table):
    if val.kind == TomlValueKind.Table:
      echo space & key & " = table"
      dump(val.tableVal, indentLevel + 4)
    elif (val.kind == TomlValueKind.Array and
        val.arrayVal[0].kind == TomlValueKind.Table):
      for idx, val in val.arrayVal:
        echo space & key & "[" & $idx & "] = table"
        dump(val.tableVal, indentLevel + 4)
    else:
      echo space & key & " = " & $(val[])

import json, sequtils

proc toJson*(value: TomlValueRef): JsonNode

proc toJson*(table: TomlTableRef): JsonNode =
  ## Converts a TOML table to a JSON node. This uses the format specified in
  ## the validation suite for it's output:
  ## https://github.com/BurntSushi/toml-test#example-json-encoding
  result = newJObject()
  for key, value in pairs(table):
    result[key] = value.toJson

proc toJson*(value: TomlValueRef): JsonNode =
  ## Converts a TOML value to a JSON node. This uses the format specified in
  ## the validation suite for it's output:
  ## https://github.com/BurntSushi/toml-test#example-json-encoding
  case value.kind:
    of TomlValueKind.Int:
      %*{"type": "integer", "value": $value.intVal}
    of TomlValueKind.Float:
      if classify(value.floatVal) == fcNan:
        if value.forcedSign != Pos:
          %*{"type": "float", "value": $value.floatVal}
        else:
          %*{"type": "float", "value": "+" & $value.floatVal}
      else:
        %*{"type": "float", "value": $value.floatVal}
    of TomlValueKind.Bool:
      %*{"type": "bool", "value": $value.boolVal}
    of TomlValueKind.Datetime:
      if value.dateTimeVal.shift == false:
        %*{"type": "datetime-local", "value": $value.dateTimeVal}
      else:
        %*{"type": "datetime", "value": $value.dateTimeVal}
    of TomlValueKind.Date:
      %*{"type": "date", "value": $value.dateVal}
    of TomlValueKind.Time:
      %*{"type": "time", "value": $value.timeVal}
    of TomlValueKind.String:
      %*{"type": "string", "value": newJString(value.stringVal)}
    of TomlValueKind.Array:
      if value.arrayVal.len == 0:
        when defined(newtestsuite):
          %[]
        else:
          %*{"type": "array", "value": []}
      elif value.arrayVal[0].kind == TomlValueKind.Table:
        %value.arrayVal.map(toJson)
      else:
        when defined(newtestsuite):
          %*value.arrayVal.map(toJson)
        else:
          %*{"type": "array", "value": value.arrayVal.map(toJson)}
    of TomlValueKind.Table:
      value.tableVal.toJson
    of TomlValueKind.None:
      %*{"type": "ERROR"}

proc toKey(str: string): string =
  for c in str:
    if (c notin {'a'..'z', 'A'..'Z', '0'..'9', '_', '-'}):
      return "\"" & str & "\""
  str


proc toTomlString*(value: TomlTableRef, parents = ""): string =
  ## Converts a TOML table to a TOML formatted string for output to a file.
  result = ""
  var subtables: seq[tuple[key: string, value: TomlValueRef]] = @[]
  for key, value in pairs(value):
    block outer:
      if value.kind == TomlValueKind.Table:
        subtables.add((key: key, value: value))
      elif value.kind == TomlValueKind.Array and
           value.arrayVal.len > 0 and
           value.arrayVal[0].kind == TomlValueKind.Table:
        let tables = value.arrayVal.map(toTomlString)
        for table in tables:
          result = result & "[[" & key & "]]\n" & table & "\n"
      else:
        result = result & key.toKey & " = " & toTomlString(value) & "\n"
  for kv in subtables:
    let fullKey = (if parents.len > 0: parents & "." else: "") & kv.key.toKey
    block outer:
      for ikey, ivalue in pairs(kv.value.tableVal):
        if ivalue.kind != TomlValueKind.Table:
          result = result & "[" & fullKey & "]\n" &
            kv.value.tableVal.toTomlString(fullKey) & "\n"
          break outer
      result = result & kv.value.tableVal.toTomlString(fullKey)

proc toTomlString*(value: TomlValueRef): string =
  ## Converts a TOML value to a TOML formatted string for output to a file.
  case value.kind:
  of TomlValueKind.Int: $value.intVal
  of TomlValueKind.Float: $value.floatVal
  of TomlValueKind.Bool: $value.boolVal
  of TomlValueKind.Datetime: $value.dateTimeVal
  of TomlValueKind.String: "\"" & value.stringVal & "\""
  of TomlValueKind.Array:
    if value.arrayVal.len == 0:
      "[]"
    elif value.arrayVal[0].kind == TomlValueKind.Table:
      value.arrayVal.map(toTomlString).join("\n")
    else:
      "[" & value.arrayVal.map(toTomlString).join(", ") & "]"
  of TomlValueKind.Table: value.tableVal.toTomlString
  else:
    "UNKNOWN"

proc newTString*(s: string): TomlValueRef =
  ## Creates a new `TomlValueKind.String TomlValueRef`.
  TomlValueRef(kind: TomlValueKind.String, stringVal: s)

proc newTInt*(n: int64): TomlValueRef =
  ## Creates a new `TomlValueKind.Int TomlValueRef`.
  TomlValueRef(kind: TomlValueKind.Int, intVal: n)

proc newTFloat*(n: float): TomlValueRef =
  ## Creates a new `TomlValueKind.Float TomlValueRef`.
  TomlValueRef(kind: TomlValueKind.Float, floatVal: n)

proc newTBool*(b: bool): TomlValueRef =
  ## Creates a new `TomlValueKind.Bool TomlValueRef`.
  TomlValueRef(kind: TomlValueKind.Bool, boolVal: b)

proc newTNull*(): TomlValueRef =
  ## Creates a new `JNull TomlValueRef`.
  TomlValueRef(kind: TomlValueKind.None)

proc newTTable*(): TomlValueRef =
  ## Creates a new `TomlValueKind.Table TomlValueRef`
  result = TomlValueRef(kind: TomlValueKind.Table)
  new(result.tableVal)
  result.tableVal[] = initOrderedTable[string, TomlValueRef](4)

proc newTArray*(): TomlValueRef =
  ## Creates a new `TomlValueKind.Array TomlValueRef`
  TomlValueRef(kind: TomlValueKind.Array, arrayVal: @[])

proc getStr*(n: TomlValueRef, default: string = ""): string =
  ## Retrieves the string value of a `TomlValueKind.String TomlValueRef`.
  ##
  ## Returns ``default`` if ``n`` is not a ``TomlValueKind.String``, or if ``n`` is nil.
  if n.isNil or n.kind != TomlValueKind.String: return default
  else: return n.stringVal

proc getInt*(n: TomlValueRef, default: int = 0): int =
  ## Retrieves the int value of a `TomlValueKind.Int TomlValueRef`.
  ##
  ## Returns ``default`` if ``n`` is not a ``TomlValueKind.Int``, or if ``n`` is nil.
  if n.isNil or n.kind != TomlValueKind.Int: return default
  else: return int(n.intVal)

proc getBiggestInt*(n: TomlValueRef, default: int64 = 0): int64 =
  ## Retrieves the int64 value of a `TomlValueKind.Int TomlValueRef`.
  ##
  ## Returns ``default`` if ``n`` is not a ``TomlValueKind.Int``, or if ``n`` is nil.
  if n.isNil or n.kind != TomlValueKind.Int: return default
  else: return n.intVal

proc getFloat*(n: TomlValueRef, default: float = 0.0): float =
  ## Retrieves the float value of a `TomlValueKind.Float TomlValueRef`.
  ##
  ## Returns ``default`` if ``n`` is not a ``TomlValueKind.Float`` or ``TomlValueKind.Int``, or if ``n`` is nil.
  if n.isNil: return default
  case n.kind
  of TomlValueKind.Float: return n.floatVal
  of TomlValueKind.Int: return float(n.intVal)
  else: return default

proc getBool*(n: TomlValueRef, default: bool = false): bool =
  ## Retrieves the bool value of a `TomlValueKind.Bool TomlValueRef`.
  ##
  ## Returns ``default`` if ``n`` is not a ``TomlValueKind.Bool``, or if ``n`` is nil.
  if n.isNil or n.kind != TomlValueKind.Bool: return default
  else: return n.boolVal

proc getTable*(n: TomlValueRef, default = new(TomlTableRef)): TomlTableRef =
  ## Retrieves the key, value pairs of a `TomlValueKind.Table TomlValueRef`.
  ##
  ## Returns ``default`` if ``n`` is not a ``TomlValueKind.Table``, or if ``n`` is nil.
  if n.isNil or n.kind != TomlValueKind.Table: return default
  else: return n.tableVal

proc getElems*(n: TomlValueRef, default: seq[TomlValueRef] = @[]): seq[TomlValueRef] =
  ## Retrieves the int value of a `TomlValueKind.Array TomlValueRef`.
  ##
  ## Returns ``default`` if ``n`` is not a ``TomlValueKind.Array``, or if ``n`` is nil.
  if n.isNil or n.kind != TomlValueKind.Array: return default
  else: return n.arrayVal

proc add*(father, child: TomlValueRef) =
  ## Adds `child` to a TomlValueKind.Array node `father`.
  assert father.kind == TomlValueKind.Array
  father.arrayVal.add(child)

proc add*(obj: TomlValueRef, key: string, val: TomlValueRef) =
  ## Sets a field from a `TomlValueKind.Table`.
  assert obj.kind == TomlValueKind.Table
  obj.tableVal[key] = val

proc `?`*(s: string): TomlValueRef =
  ## Generic constructor for TOML data. Creates a new `TomlValueKind.String TomlValueRef`.
  TomlValueRef(kind: TomlValueKind.String, stringVal: s)

proc `?`*(n: int64): TomlValueRef =
  ## Generic constructor for TOML data. Creates a new `TomlValueKind.Int TomlValueRef`.
  TomlValueRef(kind: TomlValueKind.Int, intVal: n)

proc `?`*(n: float): TomlValueRef =
  ## Generic constructor for TOML data. Creates a new `TomlValueKind.Float TomlValueRef`.
  TomlValueRef(kind: TomlValueKind.Float, floatVal: n)

proc `?`*(b: bool): TomlValueRef =
  ## Generic constructor for TOML data. Creates a new `TomlValueKind.Bool TomlValueRef`.
  TomlValueRef(kind: TomlValueKind.Bool, boolVal: b)

proc `?`*(keyVals: openArray[tuple[key: string, val: TomlValueRef]]): TomlValueRef =
  ## Generic constructor for TOML data. Creates a new `TomlValueKind.Table TomlValueRef`
  if keyVals.len == 0: return newTArray()
  result = newTTable()
  for key, val in items(keyVals): result.tableVal[key] = val

template `?`*(j: TomlValueRef): TomlValueRef = j

proc `?`*[T](elements: openArray[T]): TomlValueRef =
  ## Generic constructor for TOML data. Creates a new `TomlValueKind.Array TomlValueRef`
  result = newTArray()
  for elem in elements: result.add(?elem)

when false:
  # For 'consistency' we could do this, but that only pushes people further
  # into that evil comfort zone where they can use Nim without understanding it
  # causing problems later on.
  proc `?`*(elements: set[bool]): TomlValueRef =
    ## Generic constructor for TOML data. Creates a new `TomlValueKind.Table TomlValueRef`.
    ## This can only be used with the empty set ``{}`` and is supported
    ## to prevent the gotcha ``%*{}`` which used to produce an empty
    ## TOML array.
    result = newTTable()
    assert false notin elements, "usage error: only empty sets allowed"
    assert true notin elements, "usage error: only empty sets allowed"

proc `?`*(o: object): TomlValueRef =
  ## Generic constructor for TOML data. Creates a new `TomlValueKind.Table TomlValueRef`
  result = newTTable()
  for k, v in o.fieldPairs: result[k] = ?v

proc `?`*(o: ref object): TomlValueRef =
  ## Generic constructor for TOML data. Creates a new `TomlValueKind.Table TomlValueRef`
  if o.isNil:
    result = newTNull()
  else:
    result = ?(o[])

proc `?`*(o: enum): TomlValueRef =
  ## Construct a TomlValueRef that represents the specified enum value as a
  ## string. Creates a new ``TomlValueKind.String TomlValueRef``.
  result = ?($o)

import macros

proc toToml(x: NimNode): NimNode {.compileTime.} =
  case x.kind
  of nnkBracket: # array
    if x.len == 0: return newCall(bindSym"newTArray")
    result = newNimNode(nnkBracket)
    for i in 0 ..< x.len:
      result.add(toToml(x[i]))
    result = newCall(bindSym("?", brOpen), result)
  of nnkTableConstr: # object
    if x.len == 0: return newCall(bindSym"newTTable")
    result = newNimNode(nnkTableConstr)
    for i in 0 ..< x.len:
      x[i].expectKind nnkExprColonExpr
      result.add newTree(nnkExprColonExpr, x[i][0], toToml(x[i][1]))
    result = newCall(bindSym("?", brOpen), result)
  of nnkCurly: # empty object
    x.expectLen(0)
    result = newCall(bindSym"newTTable")
  of nnkNilLit:
    result = newCall(bindSym"newTNull")
  else:
    result = newCall(bindSym("?", brOpen), x)

macro `?*`*(x: untyped): untyped =
  ## Convert an expression to a TomlValueRef directly, without having to specify
  ## `?` for every element.
  result = toToml(x)
  echo result.repr

proc toTomlValue(x: NimNode): NimNode {.compileTime.} =
  newCall(bindSym("?", brOpen), x)

proc toTomlNew(x: NimNode): NimNode {.compileTime.} =
  echo x.treeRepr
  var
    i = 0
    curTable: NimNode = nil
  while i < x.len:
    echo x[i].kind
    case x[i].kind:
    of nnkAsgn:
      if curTable.isNil:
        curTable = newNimNode(nnkTableConstr)
        result = curTable
      curTable.add newTree(nnkExprColonExpr, newLit($x[i][0]), toTomlValue(x[i][1]))
    of nnkBracket:
      if curTable.isNil:
        curTable = newNimNode(nnkTableConstr)
        result = curTable
      else:
        var table = newNimNode(nnkTableConstr)
        result.add newTree(nnkExprColonExpr, newLit($x[i][0]), newCall(bindSym("?", brOpen), table))
        curTable = table
    else: discard
    i += 1
  result = newCall(bindSym("?", brOpen), result)

macro `parseToml`*(x: untyped): untyped =
  ## Convert an expression to a TomlValueRef directly, without having to specify
  ## `?` for every element.
  result = toTomlNew(x)
  echo result.repr

func `==`* (a, b: TomlValueRef): bool =
  ## Check two nodes for equality
  if a.isNil:
    if b.isNil: return true
    return false
  elif b.isNil or a.kind != b.kind:
    return false
  else:
    case a.kind
    of TomlValueKind.String:
      result = a.stringVal == b.stringVal
    of TomlValueKind.Int:
      result = a.intVal == b.intVal
    of TomlValueKind.Float:
      result = a.floatVal == b.floatVal
    of TomlValueKind.Bool:
      result = a.boolVal == b.boolVal
    of TomlValueKind.None:
      result = true
    of TomlValueKind.Array:
      result = a.arrayVal == b.arrayVal
    of TomlValueKind.Table:
      # we cannot use OrderedTable's equality here as
      # the order does not matter for equality here.
      if a.tableVal.len != b.tableVal.len: return false
      for key, val in a.tableVal:
        if not b.tableVal.hasKey(key): return false
        {.noSideEffect.}:
          if b.tableVal[key] != val: return false
      result = true
    of TomlValueKind.DateTime:
      result =
        a.dateTimeVal.date.year == b.dateTimeVal.date.year and
        a.dateTimeVal.date.month == b.dateTimeVal.date.month and
        a.dateTimeVal.date.day == b.dateTimeVal.date.day and
        a.dateTimeVal.time.hour == b.dateTimeVal.time.hour and
        a.dateTimeVal.time.minute == b.dateTimeVal.time.minute and
        a.dateTimeVal.time.second == b.dateTimeVal.time.second and
        a.dateTimeVal.time.subsecond == b.dateTimeVal.time.subsecond and
        a.dateTimeVal.shift == b.dateTimeVal.shift and
        (a.dateTimeVal.shift == true and
          (a.dateTimeVal.isShiftPositive == b.dateTimeVal.isShiftPositive and
          a.dateTimeVal.zoneHourShift == b.dateTimeVal.zoneHourShift and
          a.dateTimeVal.zoneMinuteShift == b.dateTimeVal.zoneMinuteShift)) or
        a.dateTimeVal.shift == false
    of TomlValueKind.Date:
      result =
        a.dateVal.year == b.dateVal.year and
        a.dateVal.month == b.dateVal.month and
        a.dateVal.day == b.dateVal.day
    of TomlValueKind.Time:
      result =
        a.timeVal.hour == b.timeVal.hour and
        a.timeVal.minute == b.timeVal.minute and
        a.timeVal.second == b.timeVal.second and
        a.timeVal.subsecond == b.timeVal.subsecond

import hashes

proc hash*(n: OrderedTable[string, TomlValueRef]): Hash {.noSideEffect.}

proc hash*(n: TomlValueRef): Hash {.noSideEffect.} =
  ## Compute the hash for a TOML node
  case n.kind
  of TomlValueKind.Array:
    result = hash(n.arrayVal)
  of TomlValueKind.Table:
    result = hash(n.tableVal[])
  of TomlValueKind.Int:
    result = hash(n.intVal)
  of TomlValueKind.Float:
    result = hash(n.floatVal)
  of TomlValueKind.Bool:
    result = hash(n.boolVal.int)
  of TomlValueKind.String:
    result = hash(n.stringVal)
  of TomlValueKind.None:
    result = Hash(0)
  of TomlValueKind.DateTime:
    result = hash($n.dateTimeVal)
  of TomlValueKind.Date:
    result = hash($n.dateVal)
  of TomlValueKind.Time:
    result = hash($n.timeVal)

proc hash*(n: OrderedTable[string, TomlValueRef]): Hash =
  for key, val in n:
    result = result xor (hash(key) !& hash(val))
  result = !$result

proc len*(n: TomlValueRef): int =
  ## If `n` is a `TomlValueKind.Array`, it returns the number of elements.
  ## If `n` is a `TomlValueKind.Table`, it returns the number of pairs.
  ## Else it returns 0.
  case n.kind
  of TomlValueKind.Array: result = n.arrayVal.len
  of TomlValueKind.Table: result = n.tableVal.len
  else: discard

proc `[]`*(node: TomlValueRef, name: string): TomlValueRef {.inline.} =
  ## Gets a field from a `TomlValueKind.Table`, which must not be nil.
  ## If the value at `name` does not exist, raises KeyError.
  assert(not isNil(node))
  assert(node.kind == TomlValueKind.Table)
  result = node.tableVal[name]

proc `[]`*(node: TomlValueRef, index: int): TomlValueRef {.inline.} =
  ## Gets the node at `index` in an Array. Result is undefined if `index`
  ## is out of bounds, but as long as array bound checks are enabled it will
  ## result in an exception.
  assert(not isNil(node))
  assert(node.kind == TomlValueKind.Array)
  return node.arrayVal[index]

proc hasKey*(node: TomlValueRef, key: string): bool =
  ## Checks if `key` exists in `node`.
  assert(node.kind == TomlValueKind.Table)
  result = node.tableVal.hasKey(key)

proc contains*(node: TomlValueRef, key: string): bool =
  ## Checks if `key` exists in `node`.
  assert(node.kind == TomlValueKind.Table)
  node.tableVal.hasKey(key)

proc contains*(node: TomlValueRef, val: TomlValueRef): bool =
  ## Checks if `val` exists in array `node`.
  assert(node.kind == TomlValueKind.Array)
  find(node.arrayVal, val) >= 0

proc existsKey*(node: TomlValueRef, key: string): bool {.deprecated.} = node.hasKey(key)
  ## Deprecated for `hasKey`

proc `[]=`*(obj: TomlValueRef, key: string, val: TomlValueRef) {.inline.} =
  ## Sets a field from a `TomlValueKind.Table`.
  assert(obj.kind == TomlValueKind.Table)
  obj.tableVal[key] = val

proc `{}`*(node: TomlValueRef, keys: varargs[string]): TomlValueRef =
  ## Traverses the node and gets the given value. If any of the
  ## keys do not exist, returns ``nil``. Also returns ``nil`` if one of the
  ## intermediate data structures is not an object.
  result = node
  for key in keys:
    if isNil(result) or result.kind != TomlValueKind.Table:
      return nil
    result = result.tableVal.getOrDefault(key)

proc getOrDefault*(node: TomlValueRef, key: string): TomlValueRef =
  ## Gets a field from a `node`. If `node` is nil or not an object or
  ## value at `key` does not exist, returns nil
  if not isNil(node) and node.kind == TomlValueKind.Table:
    result = node.tableVal.getOrDefault(key)

template simpleGetOrDefault*{`{}`(node, [key])}(node: TomlValueRef, key: string): TomlValueRef = node.getOrDefault(key)

proc `{}=`*(node: TomlValueRef, keys: varargs[string], value: TomlValueRef) =
  ## Traverses the node and tries to set the value at the given location
  ## to ``value``. If any of the keys are missing, they are added.
  var node = node
  for i in 0..(keys.len-2):
    if not node.hasKey(keys[i]):
      node[keys[i]] = newTTable()
    node = node[keys[i]]
  node[keys[keys.len-1]] = value

proc delete*(obj: TomlValueRef, key: string) =
  ## Deletes ``obj[key]``.
  assert(obj.kind == TomlValueKind.Table)
  if not obj.tableVal.hasKey(key):
    raise newException(IndexDefect, "key not in object")
  obj.tableVal.del(key)

proc copy*(p: TomlValueRef): TomlValueRef =
  ## Performs a deep copy of `a`.
  case p.kind
  of TomlValueKind.String:
    result = newTString(p.stringVal)
  of TomlValueKind.Int:
    result = newTInt(p.intVal)
  of TomlValueKind.Float:
    result = newTFloat(p.floatVal)
  of TomlValueKind.Bool:
    result = newTBool(p.boolVal)
  of TomlValueKind.None:
    result = newTNull()
  of TomlValueKind.Table:
    result = newTTable()
    for key, val in pairs(p.tableVal):
      result.tableVal[key] = copy(val)
  of TomlValueKind.Array:
    result = newTArray()
    for i in items(p.arrayVal):
      result.arrayVal.add(copy(i))
  of TomlValueKind.DateTime:
    new(result)
    result[] = p[]
  of TomlValueKind.Date:
    new(result)
    result[] = p[]
  of TomlValueKind.Time:
    new(result)
    result[] = p[]