import std/[httpclient, json, jsonutils, net, os, random, sequtils, strutils,
  tables]
import ../cirrus


type
  GrammarCode* = tuple
    code: string
    grammar: string
    handler: string
    allowOverwrite: bool

  GrammarCodes* = seq[GrammarCode]

  Grammar* = OrderedTable[string, JsonNode]

  Grammars* = seq[tuple[code: string, grammar: Grammar]]


var
  grammarDir = ircConfigDir & "grammar/"
  codeFile = ircConfigDir & "codes.json"
  grammars*: Grammars
  grammarCodes*: GrammarCodes
  reservedCodes* = @["help", "forget", "learn", "unlearn"]
  pasteUrls* = @["https://ttm.sh"]


# Set the grammar and code file location.
proc setGrammarDir*(configDir = ircConfigDir, gramDir = grammarDir,
  codes = codeFile): void =
  ircConfigDir = configDir
  grammarDir = gramDir
  codeFile = codes


# Download a url and save to a file path. Return true if successful or false
# otherwise.
proc fetchUrl*(url: string, file: string): bool =
  var 
    cl = newHttpClient(userAgent = defUserAgent,
      sslContext = newContext(verifyMode = CVerifyPeer))
    data: string
  try:
    data = cl.getContent(url)
  except OSError:
    debug("fetchUrl", "error: cannot fetch url " & url)
  except ValueError:
    debug("fetchUrl", "error: no uri scheme found for " & url)
  if data != "":
    try:
      writeFile(unixToNativePath(file), data)
      return true
    except IOError:
      debug("fetchUrl", "error: could not write to file " & file)
      return false
  else:
    debug("fetchUrl", "error: file saved from " & url & " has no contents")
    return false


# Upload a grammar JSON file to a pastebin and return the paste url. 
proc postGrammar*(file: string): string =
  var 
    cl = newHttpClient(userAgent = defUserAgent,
      sslContext = newContext(verifyMode = CVerifyPeer))
    data = newMultiPartData()
    res: string
  cl.headers = newHttpHeaders({"Content-Type": "application/json"})
  randomize()
  var host = sample(pasteUrls)
  try:
    data.addFiles({"file": file})
    res = cl.postContent(host, multipart = data)
  except OSError:
    debug("postGrammar", "error: cannot post file " & file)
  if res != "":
    return strip(res)
  else:
    debug("postGrammar", "error: no response received from " & host)
    return ""


# Load and return the grammar given a grammar JSON file path.
proc loadGrammar*(file: string): Grammar =
  var gram: Grammar
  try:
    gram = getFields(parseFile(unixToNativePath(file)))
  except IOError:
    debug("loadGrammar", "error: could not read JSON file " & file)
  except JsonParsingError:
    debug("loadGrammar", "error: invalid JSON in file " & file)
  return gram


# Check whether a code is writable. Return true if writable or false otherwise.
proc checkWritable*(name: string, codes = grammarCodes): bool =
  # Check if the code is a reserved keyword
  for c in reservedCodes:
    if name == c:
      return false
  # Check if the code allows overwriting
  for c in codes:
    if name == c.code and c.allowOverwrite == false:
      return false
  return true


# Return the aliases of a given code name as a sequence and their indices, or
# the code name given an alias and its index. Return an empty sequence if none
# are found. Aliases are code names sharing the same grammar file or handler
# name.
proc lookupAliases*(name: string, ty = "aliases", codes = grammarCodes):
  seq[(string, int)] =
  var
    grammar: string
    handler: string
    res: seq[(string, int)]
    count = 0
    tyCount = 0
  for c in codes:
    if name == c.code:
      grammar = c.grammar
      handler = c.handler
      break
    count += 1
  case ty
  of "aliases":
    for c in codes:
      if grammar != "" and grammar == c.grammar and c.code != name:
        add(res, (c.code, tyCount))
      elif handler != "" and handler == c.handler and c.code != name:
        add(res, (c.code, tyCount))
      tyCount += 1
  else:
    if grammar != "":
      res = @[(split(grammar, ".")[0], count)]
    else:
      for c in codes:
        # Take the first result found
        if handler != "" and handler == c.handler and c.code != name:
          add(res, (c.code, tyCount))
          break
        tyCount += 1
  return res


# Return a list of service code names given the code prefix.
proc getGrammarNames*(prefix: string, codes = grammarCodes): seq[string] =
  return map(grammarCodes, proc(c: GrammarCode): string = prefix & c.code)


# Given a service code name and grammars, return the associated grammar and the
# index of the grammar. If no grammar is found for the code, return an empty
# grammar and -1.
proc lookupGrammar*(code: string, grams = grammars): (Grammar, int) =
  var 
    gram: Grammar
    found = false
    count = 0
  for g in grams:
    if g.code == code:
      gram = g.grammar
      found = true
      break
    count += 1
  if found:
    return (gram, count)
  else:
    return (gram, -1)


# Return a random origin string from a grammar. If the grammar origin array is
# empty, return an empty string.
proc getOrigin*(gram: Grammar): string =
  if getOrDefault(gram, "origin") != nil:
    var 
      line = getStr(sample(getElems(getOrDefault(gram, "origin"))))
      spliced = false
      by = "#"
      check: seq[bool]
      splice: string
      word: string
      exp: string
      sub: seq[string]
    # Convert splices to random selections from their respective blocks
    while not spliced:
      check = @[]
      for w in split(line):
        # Splices need to be at least 3 characters long, e.g. "#s#"
        if w.len() >= 3:
          # Allow for punctuation after a splice, e.g. "#block#,"
          if rfind(w, by) == w.len() - 2:
            splice = w[0..(w.len() - 2)]
            word = w[1..(w.len() - 3)]
          else:
            splice = w[0..(w.len() - 1)]
            word = w[1..(w.len() - 2)]
          if find(w, by) == 0 and (rfind(w, by) == (w.len() - 1) or 
            rfind(w, by) == (w.len() - 2)):
            if getOrDefault(gram, word) != nil:
              randomize()
              exp = getStr(sample(getElems(getOrDefault(gram, word))))
              sub = split(line, splice, 1)
              line = join([sub[0], exp, sub[1]])
      # Confirm all splices have been expanded
      for w in split(line):
        if (find(w, by) != 0 and (rfind(w, by) != 0 or rfind(w, by) != 1)) or
          w.len() <= 2:
          add(check, true)
        else:
          add(check, false)
      if find(check, false) == -1:
        spliced = true
    return line
  else:
    return ""


# Load JSON service code file to global variable `grammarCodes`.
proc loadGrammarCodes*(file = codeFile): void =
  if fileExists(unixToNativePath(file)):
    var 
      nodes: JsonNode
      grammar: OrderedTable[string, JsonNode]
    try:
      nodes = parseFile(unixToNativePath(file))
    except IOError:
      debug("loadGrammar", "error: could not read file " & file)
    try:
      grammarCodes = to(nodes, GrammarCodes)
    # Show error if the code index file is missing fields
    except KeyError:
      debug("loadGrammarCodes", "error: invalid code file " & file)

    # Fetch the grammar for each code and add it to the grammars tuple. A code
    # can have either grammar or handler, not both. If both are defined, the
    # grammar will be selected (see `listenCodes()`).
    for c in grammarCodes:
      if fileExists(unixToNativePath(grammarDir & c.grammar)):
        grammar = loadGrammar(grammarDir & c.grammar)
        add(grammars, (code: c.code, grammar: grammar))
        for a in lookupAliases(c.code):
          add(grammars, (code: a[0], grammar: grammar))
      else:
        debug("loadGrammarCodes", "warning: code " & c.code &
          " not added, no grammar file or handler found")
  else:
    debug("loadGrammarCodes", "error: cannot find service codes file")


# Write service codes to a JSON file.
proc saveGrammarCodes*(codes: GrammarCodes, file = codeFile): void =
  try:
    writeFile(unixToNativePath(file), pretty(toJson(codes)))
  except IOError:
    debug("saveGrammarCodes", "error: could not write to file " & file)


# Add new grammar.
proc addGrammar*(sock: Socket, msg: Message): void =
  if msg.codeParams.len() >= 2:
    var nameSplit = split(msg.codeParams[0], ",")
    if not checkWritable(nameSplit[0]):
      message(sock, msg.replyTo, "Sorry, " & nameSplit[0] &
        " is not writable. Please use another code.")
      return

    var
      aliases: seq[string]
      file = grammarDir & nameSplit[0] & ".json"
      urlFetched = fetchUrl(msg.codeParams[1], file)
      grammar = loadGrammar(file)
      origin = getOrigin(grammar)
    if nameSplit.len() > 1:
      var aliasesLen = nameSplit.len() - 1
      aliases = nameSplit[1..aliasesLen]

    # Add to the global codes and grammar tuples and save to the codes file
    if origin != "" and urlFetched:
      add(grammarCodes, (code: nameSplit[0], grammar: nameSplit[0] & ".json",
        handler: "", allowOverwrite: true))
      add(grammars, (code: nameSplit[0], grammar: grammar))
      # Add aliases
      for a in aliases:
        if lookupGrammar(a)[1] == -1:
          add(grammarCodes, (code: a, grammar: nameSplit[0] & ".json",
            handler: "", allowOverwrite: true))
          add(grammars, (code: a, grammar: grammar))
      saveGrammarCodes(grammarCodes)
      message(sock, msg.replyTo, "Learned.")
    else:
      message(sock, msg.replyTo, "Sorry, I didn't get that. " &
        "The grammar file may be empty or invalid.")
      # Remove the grammar file if the grammar is invalid
      removeFile(unixToNativePath(file))
  else:
    message(sock, msg.replyTo, "Sorry, I didn't get that. " &
      "Please provide a code name and JSON url.")


# Remove grammar. Only codes that are writable can be removed.
proc removeGrammar*(sock: Socket, msg: Message): void =
  if msg.codeParams.len() >= 1:
    # Alias entries will follow the writable status of the code name entry
    # since the aliases depend on the same grammar file, which can be removed
    # if the code name entry is writable.
    if lookupAliases(msg.codeParams[0], "code").len() == 0:
      message(sock, msg.replyTo, "Sorry, I don't remember learning that.")
      return
    var name = lookupAliases(msg.codeParams[0], "code")[0][0]
    if not checkWritable(name) and name != msg.codeParams[0]:
      message(sock, msg.replyTo, join(["Sorry, ", msg.codeParams[0],
        " (alias of ", name, ") cannot be removed", "because ", name,
        " is not writable."]))
      return
    # Remove from the global codes and grammars tuples, save to the codes file
    # and remove the grammar json
    var aliases = lookupAliases(name)
    for a in aliases:
      delete(grammars, lookupGrammar(a[0])[1])
      delete(grammarCodes, a[1])
    delete(grammars, lookupGrammar(name)[1])
    delete(grammarCodes, lookupAliases(name, "code")[0][1])
    saveGrammarCodes(grammarCodes)
    removeFile(unixToNativePath(grammarDir & name & ".json"))
    message(sock, msg.replyTo, msg.codeParams[0] & "? What's that?")
  else:
    message(sock, msg.replyTo, "Sorry, I didn't get that. " &
      "Please provide a code.")


# Show the paste url of a grammar code.
proc showGrammar*(sock: Socket, msg: Message): void =
  var reply: string
  if msg.codeParams.len() > 0:
    var 
      names = map(grammarCodes, proc(c: GrammarCode): string = c.code)
      files = map(grammarCodes, proc(c: GrammarCode): string = c.grammar)
      url: string
      file: string
    for p in msg.codeParams:
      if find(names, p) != -1:
        file = files[find(names, p)]
        if file != "":
          url = postGrammar(grammarDir & file)
          if url != "":
            message(sock, msg.replyTo, url)
        else:
          reply = "No grammar linked to " & p
          message(sock, msg.replyTo, reply)
      else:
        reply = "No grammar found for " & p
        message(sock, msg.replyTo, reply)
  else:
    reply = "Please provide a code." 
    message(sock, msg.replyTo, reply)


# Send a grammar response to the server.
proc runGrammar*(gram: Grammar, sock: Socket, msg: Message): void =
  var origin = getOrigin(gram)
  if origin != "":
    message(sock, msg.replyTo, origin)
  else:
    debug("runGrammar", "warning: no origin found in grammar")


# Parse message strings received and pass them to handlers.
proc listenGrammarCodes*(st: ServerState, str: string): void =
  var msg = parseMessage(st.codePrefix, str)
  for c in grammarCodes:
    if msg.code == c.code:
      if lookupGrammar(c.code)[1] != -1:
        runGrammar(lookupGrammar(c.code)[0], st.sock, msg)
      else:
        runHandler(c.handler, st, msg)
      break


# Initialise a loop and add listeners to respond to service codes.
proc listenGrammar*(states: seq[ServerState]): void =
  while true:
    var
      statesBuf = states
      count = 0
    for st in statesBuf:
      try:
        var recv = recvServer(st.sock)
        sendPong(st.sock, recv)
        listenGrammarCodes(st, recv)
      except AssertionDefect:
        # Remove server from the states sequence
        delete(statesBuf, count)
        # Exit if there was only one server connection
        if states.len() == 1:
          quit()
      count += 1


# Handlers
# ----------------------------------------------------------------------------

proc hdlGrammarHelp*(st: ServerState, msg: Message): void =
  var 
    names = getGrammarNames(st.codePrefix)
    help = "Hello, I'm a tracery-inspired grammar bot. " &
    "I respond to the following service codes: " & join(names, ", ")
  message(st.sock, msg.replyTo, help)


proc hdlGrammarLearn*(st: ServerState, msg: Message): void =
  addGrammar(st.sock, msg)


proc hdlGrammarShow*(st: ServerState, msg: Message): void =
  showGrammar(st.sock, msg)


proc hdlGrammarUnlearn*(st: ServerState, msg: Message): void =
  removeGrammar(st.sock, msg)


# Init
# ----------------------------------------------------------------------------

setGrammarDir()
loadGrammarCodes()
handlers["hdlGrammarHelp"] = hdlGrammarHelp
handlers["hdlGrammarLearn"] = hdlGrammarLearn
handlers["hdlGrammarShow"] = hdlGrammarShow
handlers["hdlGrammarUnlearn"] = hdlGrammarUnlearn