import std/[nre, strtabs, strutils]
import zero_functional

type
  ChordChartMetadata* = object
    title*: string
    key*: ChordChartChord
    optionalProps: StringTableRef

  ChordChart* = ref object
    rawContent*: string
    metadata*: ChordChartMetadata
    nodes*: seq[ChordChartNode]

  ChordChartNodeKind* = enum
    ccnkSection,
    ccnkLine,
    ccnkWord,
    ccnkNote,
    ccnkColBreak,
    ccnkPageBreak,
    ccnkTransposeKey,
    ccnkRedefineKey,
    ccnkNone

  ChordChartPitch* = enum Af, A, Bf, B, C, Df, D, Ef, E, F, Fs, G

  ChordChartChord* = object
    original*: Option[string]
    rootPitch*: ChordChartPitch
    flavor*: Option[string]
    bassPitch*: Option[ChordChartPitch]

  ChordChartNode* = ref object
    case kind: ChordChartNodeKind
    of ccnkSection:
      sectionName*: string
      remainingSectionLine*: Option[string]
      sectionContents*: seq[ChordChartNode]
    of ccnkLine:
      line*: seq[ChordChartNode]
    of ccnkWord:
      spaceBefore*: bool
      spaceAfter*: bool
      chord*: Option[ChordChartChord]
      word*: Option[string]
    of ccnkNote:
      note*: string
      inclInLyrics*: bool
    of ccnkColBreak: discard
    of ccnkPageBreak: discard
    of ccnkTransposeKey:
      transposeSteps*: int
    of ccnkRedefineKey:
      newKey*: ChordChartPitch
    of ccnkNone: discard

  ParserContext = ref object
    lines: seq[string]
    curKeyCenter: ChordChartPitch
    curLineNum: int
    curSection: ChordChartNode
    unparsedLineParts: seq[string]

let EMPTY_CHORD_CHART_NODE* = ChordChartNode(kind: ccnkNone)

func `[]`*(ccmd: ChordChartMetadata, key: string): string =
  ccmd.optionalProps[key]

func contains*(ccmd: ChordChartMetadata, key: string): bool =
  return key == "title" or key == "key" or ccmd.optionalProps.contains(key)

iterator pairs*(ccmd: ChordChartMetadata): tuple[key, value: string] =
  yield ("title", ccmd.title)
  yield ("key", $ccmd.key)
  for p in ccmd.optionalProps.pairs: yield p

func kind*(ccn: ChordChartNode): ChordChartNodeKind = ccn.kind

func `$`*(pitch: ChordChartPitch): string =
  case pitch
  of Af: "Ab"
  of A: "A"
  of Bf: "Bb"
  of B: "B"
  of C: "C"
  of Df: "Db"
  of D: "D"
  of Ef: "Eb"
  of E: "E"
  of F: "F"
  of Fs: "F#"
  of G: "G"

func `+`*(pitch: ChordChartPitch, steps: int): ChordChartPitch =
  cast[ChordChartPitch]((ord(pitch) + steps) mod 12)

func `-`*(a, b: ChordChartPitch): int =
  result = ord(a) - ord(b)
  if result < 0: result += 12

func dump*(m: ChordChartMetadata, indent = ""): string =
  return indent & "Metadata\p" & join(m.pairs --> map(indent & "  " & it.key & ": " & it.value), "\p")

func dump*(ccn: ChordChartNode, indent = ""): string =
  case ccn.kind

  of ccnkSection:
    let formattedChildren = ccn.sectionContents --> map(dump(it, indent & "  "))
    result = indent & "Section -- " & ccn.sectionName & "\p" &
      formattedChildren.join("\p")

  of ccnkColBreak: result = indent & "Column Break"
  of ccnkPageBreak: result = indent & "Page Break"

  of ccnkTransposeKey:
    result = indent & "Transpose key by " & $ccn.transposeSteps

  of ccnkRedefineKey:
    result = indent & "Redefine key to " & $ccn.newKey

  of ccnkLine:
    result = indent & "Line  "
    for child in ccn.line:
      let formattedChild = dump(child, indent)
      if child.kind == ccnkWord: result &= formattedChild
      else: result &= formattedChild & "\p"

  of ccnkWord:
    result = ""
    if ccn.spaceBefore: result &= " "

    if ccn.chord.isSome:
      let chord = ccn.chord.get
      result &= "["
      if chord.original.isSome and chord.flavor.isNone and
         chord.bassPitch.isNone:
        result &= chord.original.get
      else:
        result &= $chord.rootPitch
        if chord.flavor.isSome:
          result &= "_" & chord.flavor.get
        if chord.bassPitch.isSome:
          result &= "/" & $chord.bassPitch.get
      result &= "]"

    if ccn.word.isSome: result &= ccn.word.get
    if ccn.spaceAfter: result &= " "

  of ccnkNote:
    result = indent & "Note "
    if not ccn.inclInLyrics: result &= "(chords only) "
    result &= ccn.note

  of ccnkNone:
    result &= indent & "NONE"

func `$`*(cc: ChordChart): string =
  result = "ChordChart\p" &
    dump(cc.metadata, "  ") & "\p" &
    join(cc.nodes --> map(dump(it, "  ")), "\p")

# -----------------------------------------------------------------------------
#                                 PARSER
# -----------------------------------------------------------------------------

func hasNextLine(ctx: ParserContext): bool =
  ctx.unparsedLineParts.len > 1 or
  ctx.curLineNum + 1 < ctx.lines.len

func nextLine(ctx: var ParserContext): string =
  if ctx.unparsedLineParts.len > 0:
    result = ctx.unparsedLineParts[0]
    ctx.unparsedLineParts.delete(0)
  else:
    ctx.curLineNum += 1
    result = ctx.lines[ctx.curLineNum]

func pushPartialsToParse(ctx: var ParserContext, parts: varargs[string]): void =
  ctx.unparsedLineParts &= parts

template makeError(ctx: ParserContext, msg: string): untyped =
  newException(ValueError,
    "error parsing input at line " & $ctx.curLineNum & ":\p\t" & msg)

template addToCurSection(n: ChordChartNode): untyped =
  if ctx.curSection.kind == ccnkSection: ctx.curSection.sectionContents.add(n)
  else: result.add(n)

proc parsePitch*(ctx: ParserContext, keyValue: string): ChordChartPitch =
  let normK = keyValue.strip.toLower
  case normK
  of "gs", "gis", "g#", "ab", "a♭", "af", "aes": return ChordChartPitch.Af
  of "g𝄪", "a", "a♮", "b𝄫": return ChordChartPitch.A
  of "as", "ais", "a#", "bf", "bb", "b♭", "bes", "c𝄫": return ChordChartPitch.Bf
  of "a𝄪", "b", "cb", "ces", "cf": return ChordChartPitch.B
  of "bs", "bis", "b#", "c", "d𝄫": return ChordChartPitch.C
  of "b𝄪", "cs", "cis", "c#", "df", "db", "des": return ChordChartPitch.Df
  of "c𝄪", "d", "e𝄫": return ChordChartPitch.D
  of "ds", "dis", "d#", "ef", "eb", "ees", "f𝄫": return ChordChartPitch.Ef
  of "d𝄪", "e", "fes", "ff": return ChordChartPitch.E
  of "es", "eis", "e#", "f", "g𝄫": return ChordChartPitch.F
  of "e𝄪", "fs", "fis", "f#", "gf", "gb", "ges": return ChordChartPitch.Fs
  of "f𝄪", "g", "a𝄫": return ChordChartPitch.G
  of "1": return ctx.curKeyCenter
  of "2": return ctx.curKeyCenter + 2
  of "3": return ctx.curKeyCenter + 4
  of "4": return ctx.curKeyCenter + 5
  of "5": return ctx.curKeyCenter + 7
  of "6": return ctx.curKeyCenter + 9
  of "7": return ctx.curKeyCenter + 11
  else: raise ctx.makeError(keyValue.strip & " is not a recognized key.")

# see regexr.com/70nv1
let CHORD_REGEX =
  "([A-G1-7][b#♭♮𝄫𝄪]?)" &               #      chord root
  "(([mM1-9#b♭♮𝄫𝄪Δ+oøoø][0-9]?|min|maj|aug|dim|sus|6\\/9|\\([1-9#b♭]+\\))*)" &  # chord flavor/type
  "(\\/([A-G1-7][b#♭♮𝄫𝄪]?))?"             # optional bass
let CHORD_PAT = re(CHORD_REGEX)

proc parseChord*(
    ctx: ParserContext, chordValue: string
  ): Option[ChordChartChord] =

  let m = chordValue.match(CHORD_PAT)
  if m.isNone: none[ChordChartChord]()
  else:
    let flavor =
      if m.get.captures.contains(1) and m.get.captures[1].len > 0:
        some(m.get.captures[1])
      else: none[string]()

    let bassPitch =
      if m.get.captures.contains(4) and m.get.captures[4].len > 0:
        some(ctx.parsePitch(m.get.captures[4]))
      else: none[ChordChartPitch]()

    return some(ChordChartChord(
      original: some(chordValue),
      rootPitch: ctx.parsePitch(m.get.captures[0]),
      flavor: flavor,
      bassPitch: bassPitch))

let METADATA_LINE_PAT = re"^([^:]+):(.*)$"
let METADATA_END_PAT = re"^-+$"
proc parseMetadata(ctx: var ParserContext): ChordChartMetadata =

  var title = "MISSING"
  var optProps = newStringTable()
  var songKey: Option[ChordChartChord]

  while ctx.curLineNum < ctx.lines.len:
    let line = ctx.nextLine

    if line.match(METADATA_END_PAT).isSome:
      break

    let m = line.match(METADATA_LINE_PAT)
    if m.isNone:
      raise ctx.makeError("expected metadata property or ending marker")

    let key = m.get.captures[0].strip.tolower
    let value = m.get.captures[1].strip
    if key == "title": title = value
    elif key == "key":
      songKey = ctx.parseChord(value)
      if songKey.isNone:
        raise ctx.makeError("unrecognized key: " & value)
    else: optProps[key] = value

  if title == "MISSING":
    raise ctx.makeError("metadata is missing the 'title' property")

  if songKey.isNone:
    raise ctx.makeError("metadata is missing the 'key' property")

  result = ChordChartMetadata(
    title: title,
    key: songKey.get,
    optionalProps: optProps)

const KNOWN_SECTION_NAMES = [
  "chorus", "verse", "bridge", "breakdown", "vamp", "intstrumental",
  "interlude", "intro", "outtro", "ending", "end", "tag", "prechorus",
  "pre-chorus", "pre chorus"
]

let SECTION_LINE_PAT = re(
  "^((" & "((?i)" &                               # case insensitive
  KNOWN_SECTION_NAMES.join("|") & ")" &           # known names
  "|[[:upper:]]{3,}" &                            # all upper-case words
  ") ?\\d*)" &                                    # numeric suffix (Verse 2)

  # Allow notes or other text to follow on the same line
  "(.*)$"
)
let COL_BREAK_PAT = re"\s*COLUMN_BREAK\s*$"
let PAGE_BREAK_PAT = re"\s*PAGE_BREAK\s*$"
let TRANSPOSE_PAT = re"\s*TRANSPOSE KEY ([+-]\d+)\s*$"
let REDEFINE_KEY_PAT = re"\s*REDEFINE KEY ([+-]\d+)\s*$"
#let NOTE_PAT = re"^(.*)({{[^}]+}}|{[^}]+})(.*)$"
let NOTE_START_PAT = re"{{"
let NOTE_END_PAT = re"}}"
let SPACE_PAT = re"\s"
let CHORD_IN_LYRICS_PAT = re"(\w+)(\[.+)"
let CHORD_AND_LYRICS_PAT = re"^\[([^\]]+)\]([^\s\[]+)(.*)$"
let BRACED_CHORD_PAT = re"^\[([^\]]+)\]$"
let NAKED_CHORDS_ONLY_PAT = re("^(" & CHORD_REGEX & "\\s*\\|*\\s*)+$")

proc parseLineParts(ctx: ParserContext, parts: varargs[string]): seq[ChordChartNode] =
  result = @[]
  for p in parts:
    var m = p.match(SPACE_PAT)
    if m.isSome:
      result &= ctx.parseLineParts(p.splitWhitespace)
      continue

    m = p.match(CHORD_IN_LYRICS_PAT)
    if m.isSome:
      result &= ctx.parseLineParts(m.get.captures[0], m.get.captures[1])
      continue

    m = p.match(CHORD_AND_LYRICS_PAT)
    if m.isSome:
      result.add(ChordChartNode(
        kind: ccnkWord,
        spaceAfter: true, #FIXME
        spaceBefore: true, #FIXME
        chord: ctx.parseChord(m.get.captures[0]),
        word: some(m.get.captures[1])))
      result &= ctx.parseLineParts(m.get.captures[2])
      continue

    m = p.match(BRACED_CHORD_PAT)
    if m.isSome:
      result.add(ChordChartNode(
        kind: ccnkWord,
        spaceAfter: false, #FIXME
        spaceBefore: false, #FIXME
        chord: ctx.parseChord(m.get.captures[0]),
        word: none[string]()))
      continue

    if p.len > 0:
      result.add(ChordChartNode(
        kind: ccnkWord,
          spaceAfter: true, #FIXME
          spaceBefore: true, #FIXME
          chord: none[ChordChartChord](),
          word: some(p)))

proc parseLine(ctx: ParserContext, line: string): ChordChartNode =
  result = ChordChartNode(kind: ccnkLine)

  let m = line.match(NAKED_CHORDS_ONLY_PAT)
  if m.isSome:
    result.line = line.splitWhitespace --> map(
      ChordChartNode(
        kind: ccnkWord,
        spaceAfter: false, #FIXME
        spaceBefore: false, #FIXME
        chord: ctx.parseChord(it.strip),
        word: none[string]()))

  else: result.line = ctx.parseLineParts(line.splitWhitespace)

proc readNote(ctx: var ParserContext, endPat: Regex): string =
  let startLineNum = ctx.curLineNum
  result = ""

  while ctx.lines.len > ctx.curLineNum and ctx.hasNextLine:
    let line = ctx.nextLine
    let m = line.find(endPat)
    if m.isSome:
      result &= line[0..<m.get.matchBounds.a]
      ctx.pushPartialsToParse(line[m.get.matchBounds.b..^1])
      break
    else: result &= line

  if not ctx.hasNextLine:
    raise ctx.makeError("a note section was started on line " &
      $startLineNum & " and never closed")

proc parseBody(ctx: var ParserContext): seq[ChordChartNode] =
  result = @[]
  while ctx.hasNextLine:
    var line = ctx.nextLine

    var m = line.find(NOTE_START_PAT)
    if m.isSome:
      if m.get.matchBounds.a > 0:
        # if this is not the first character of the line then let's split the
        # line and continue to parse
        ctx.pushPartialsToParse(
          line[0..<m.get.matchBounds.a],
          line[m.get.matchBounds.a..^1])
        continue

      else:
        # if this is the first character of the line, then let's parse the note
        result.add(ChordChartNode(
          kind: ccnkNote,
          inclInLyrics: m.get.match.len < 2,
          note: ctx.readNote(NOTE_END_PAT)))

    m = line.match(TRANSPOSE_PAT)
    if m.isSome:
      addToCurSection(ChordChartNode(
        kind: ccnkTransposeKey,
        transposeSteps: parseInt(m.get.captures[0])))
      continue

    m = line.match(REDEFINE_KEY_PAT)
    if m.isSome:
      let newKeyInt = (
          cast[int](ctx.curKeyCenter) +
          parseInt(m.get.captures[0])
        ) mod 12

      addToCurSection(ChordChartNode(
        kind: ccnkRedefineKey,
        newKey: cast[ChordChartPitch](newKeyInt)))
      continue

    m = line.match(COL_BREAK_PAT)
    if m.isSome:
      result.add(ChordChartNode(kind: ccnkColBreak))
      continue

    m = line.match(PAGE_BREAK_PAT)
    if m.isSome:
      result.add(ChordChartNode(kind: ccnkPageBreak))
      continue

    m = line.match(SECTION_LINE_PAT)
    if m.isSome:
      let captures = m.get.captures.toSeq
      ctx.curSection = ChordChartNode(
        kind: ccnkSection,
        sectionName:
          if captures[0].isSome: captures[0].get.strip
          else: raise ctx.makeError("unknown error parsing section header: " & line),
        remainingSectionLine:
          if captures[3].isSome: some(captures[3].get.strip)
          else: none[string](),
        sectionContents: @[])
      result.add(ctx.curSection)
      continue

    else:
      addToCurSection(ctx.parseLine(line))
      continue


proc parseChordChart*(s: string): ChordChart =
  var parserCtx = ParserContext(
    lines: s.splitLines,
    curLineNum: -1,
    curSection: EMPTY_CHORD_CHART_NODE,
    unparsedLineParts: @[])

  let metadata = parseMetadata(parserCtx)
  parserCtx.curKeyCenter = metadata.key.rootPitch

  result = ChordChart(
    rawContent: s,
    metadata: metadata,
    nodes: parseBody(parserCtx))