## Contains helper macros for NimQml

import macros
import strutils
import typetraits
import tables

template debug(body: stmt): stmt =
  {.push warning[user]: off.}
  when defined(debug):
    {.pop.}
    body
  else:
    {.pop.}


let nimFromQtVariant {.compileTime.} = {
  "int" : "intVal",
  "string" : "stringVal",
  "bool" : "boolVal",
}.toTable

let nim2QtMeta {.compileTime.} = {
    "bool": "Bool",
    "int " : "Int",
    "string" : "QString",
    "pointer" : "VoidStar",
    "QVariant": "QVariant",
    "" : "Void", # no return, which is represented by an nnkEmpty node
}.toTable

proc getNodeOf*(tree: PNimrodNode, kind: TNimrodNodeKind): PNimrodNode {.compileTime.} =
  ## recursively looks for a node of kind, ``kind``, in the tree provided as ``tree``
  ## Returnsthe first node that satisfies this condition 
  for i in 0.. <tree.len:
    var child = tree[i]
    if child.kind == kind:
      return child
    var candidate = getNodeOf(child, kind)
    if not candidate.isNil:
      return candidate

static:
  type Context* = ref object of RootObj
  type NullContext* = ref object of Context  

type NodeModifier*[T] = proc(context: T, a: var PNimrodNode): PNimrodNode

# had to remove type bound on hook due to recent regression with generics
proc hookOnNode*[T](context: T, code: PNimrodNode, hook: NodeModifier, 
    recursive: bool = false): PNimrodNode {.compileTime.} =
  ## Iterates over the tree, ``code``, calling ``hook`` on each ``PNimrodNode``
  ## encountered. If ``recursive`` is true, it will recurse over the tree, otherwise
  ## it will only visit ``code``s children. ``hook`` should return a replacement for 
  ## the node that was passed in via it's return value.
  if code.len == 0:
    return code
  var newCode = newNimNode(code.kind)
  for i in 0.. <code.len:
    var child = code[i].copy()
    child = hook(context, child)
    if recursive:
      child = hookOnNode(context,child,hook,true)
    if child != nil:
      newCode.add child
  return newCode
  
proc removeOpenSym*(context: NullContext, a: var PNimrodNode): PNimrodNode {.compileTime.} =
  ## replaces: ``nnkOpenSymChoice`` and ``nnkSym`` nodes with idents corresponding to the
  ## symbols string representation. 
  if a.kind == nnkOpenSymChoice: 
    return ident($a[0].symbol)
  elif a.kind == nnkSym:
    return ident($a.symbol)  
  return a
  
proc newTemplate*(name = newEmptyNode(); params: openArray[PNimrodNode] = [newEmptyNode()];  
    body: PNimrodNode = newStmtList()): PNimrodNode {.compileTime.} =
  ## shortcut for creating a new template
  ##
  ## The ``params`` array must start with the return type of the template, 
  ## followed by a list of IdentDefs which specify the params.
  result = newNimNode(nnkTemplateDef).add(
    name,
    newEmptyNode(),
    newEmptyNode(),
    newNimNode(nnkFormalParams).add(params), ##params
    newEmptyNode(),  ## pragmas
    newEmptyNode(),
    body)
    
template declareSuperTemplate*(parent: typedesc, typ: typedesc): typedesc =
  template superType*(ofType: typedesc[typ]): typedesc[parent] =
    parent

proc getTypeName*(a: PNimrodNode): PNimrodNode {.compileTime.} =
  ## returns the node containing the name of an object in a 
  ## given type definition block 
  expectMinLen a, 1
  expectKind a, nnkTypeDef
  var testee = a
  if testee[0].kind == nnkPragmaExpr:
    testee = testee[0]
  if testee[0].kind in {nnkIdent}:
    return testee[0]
  elif testee[0].kind in {nnkPostfix}:
    return testee[0][1]

proc genSuperTemplate*(typeDecl: PNimrodNode): PNimrodNode {.compileTime.} =
  ## generates a template, with name: superType, that returns the super type
  ## of the object defined in the type defintion, ``typeDecl``. ``typeDecl``
  ## must contain an object inheriting from a base type.
  expectKind typeDecl, nnkTypeDef
  let inheritStmt = typeDecl.getNodeOf(nnkOfInherit)
  let typeName = getTypeName(typeDecl)
  if inheritStmt == nil: error("you must declare a super type for " & $typeName)
  # ident of superType (have to deal with generics)
  let superType = if inheritStmt[0].kind == nnkIdent: inheritStmt[0] else: inheritStmt[0].getNodeOf(nnkIdent)
  let superTemplate = getAst declareSuperTemplate(superType, typeName) 
  return superTemplate[0]

proc getSuperType*(typeDecl: PNimrodNode): PNimrodNode {.compileTime.} =
  ## returns ast containing superType info, may not be an ident if generic
  let inheritStmt = typeDecl.getNodeOf(nnkOfInherit)
  if inheritStmt.isNil: return newEmptyNode()
  return inheritStmt[0]

proc getPragmaName*(child: PNimrodNode): PNimrodNode {.compileTime.} =
  ## name of child in a nnkPragma section
  if child.kind == nnkIdent:
    return child
  # assumes first ident is name of pragma
  let ident = child.getNodeOf(nnkIdent)
  result = ident

proc removePragma*(pragma: PNimrodNode, toRemove: string): PNimrodNode {.compileTime.} =
  ## removes a pragma from pragma definition, `pragma`, with name `toRemove`
  expectKind pragma, nnkPragma
  result = newNimNode(nnkPragma)
  for i in 0.. <pragma.len:
    let child = pragma[i]
    if $child.getPragmaName == toRemove:
      continue
    result.add child 
  if result.len == 0:
    return newEmptyNode() 

proc hasPragma*(node: PNimrodNode, pragmaName: string): bool {.compileTime.} =
  ## Returns ``true`` iff the method, or proc definition: ``node``, has a pragma
  ## ``pragmaName``
  doAssert node.kind in {nnkMethodDef, nnkProcDef}
  result = false
  let pragma = node.pragma
  if pragma.kind == nnkEmpty:
    # denotes no pragma set
    return false
  for child in pragma.children():
    if $child.getPragmaName() == pragmaName:
      return true

proc getArgType*(arg: PNimrodNode): PNimrodNode  {.compileTime.} =
  ## returns the ``PNimrodNode`` representing a parameters type
  if arg[1].kind == nnkIdent: 
    arg[1] 
  else: 
    arg[1].getNodeOf(nnkIdent)

proc getArgName*(arg: PNimrodNode): PNimrodNode  {.compileTime.} =
  ## returns the ``PNimrodNode`` representing a parameters name
  if arg[0].kind == nnkIdent: 
    arg[0] 
  else: 
    arg[0].getNodeOf(nnkIdent)    

proc addSignalBody(signal: PNimrodNode): PNimrodNode {.compileTime.} =
  # e.g: produces: emit(MyQObject, "nameChanged")
  expectKind signal, nnkMethodDef
  result = newStmtList()
  # if exported, will use postfix
  let name = if signal.name.kind == nnkIdent: signal.name else: signal.name[1]
  let params = signal.params
  # type signal defined on is the 1st arg
  let self = getArgName(params[1])
  var args = newSeq[PNimrodNode]()
  args.add(self)
  args.add newLit($name)
  if params.len > 2: # more args than just type
    for i in 2.. <params.len:
      args.add getArgName params[i]
  result.add newCall("emit", args)

template declareOnSlotCalled(typ: typedesc): stmt =
  method onSlotCalled(myQObject: typ, slotName: string, args: openarray[QVariant]) =
    discard

template prototypeCreate(typ: typedesc): stmt =
  template create(myQObject: var typ) =
    var super = (typ.superType())(myQObject)
    procCall create(super)

proc doRemoveOpenSym(a: var PNimrodNode): PNimrodNode {.compileTime.} =
  hookOnNode(NullContext(),a, removeOpenSym, true)

proc templateBody*(a: PNimrodNode): PNimrodNode {.compileTime.} =
  expectKind a, nnkTemplateDef
  result = a[6]
  
proc genArgTypeArray(params: PNimrodNode): PNimrodNode {.compileTime.} =
  expectKind params, nnkFormalParams
  result = newNimNode(nnkBracket)
  for i in 0 .. <params.len:
    if i == 1:
      # skip "self" param eg: myQObject: MyQObject
      continue
    let pType = if i != 0: getArgType params[i] else: params[i]
    let pTypeString = if pType.kind == nnkEmpty: "" else: $pType
    # function that maps Qvariant type to nim type
    let qtMeta = nim2QtMeta[pTypeString]
    if qtMeta == nil: error(pTypeString & " not supported yet")
    let metaDot = newDotExpr(ident "QMetaType", ident qtMeta)
    result.add metaDot

proc getIdentDefName*(a: PNimrodNode): PNimrodNode {.compileTime.} =
  ## returns object field name from ident def
  expectKind a, nnkIdentDefs
  if a[0].kind == nnkIdent:
    return a[0]
  elif a[0].kind == nnkPostFix:
    return a[0][1]

macro QtType*(qtDecl: stmt): stmt {.immediate.} =
  expectKind(qtDecl, nnkStmtList)
  #echo treeRepr qtDecl
  result = newStmtList()
  var slots = newSeq[PNimrodNode]()
  var properties = newSeq[PNimrodNode]()
  var signals = newSeq[PNimrodNode]()
  # assume only one type per section for now
  var typ: PNimrodNode
  for it in qtDecl.children():
    if it.kind == nnkTypeSection:
      let typeDecl = it.findChild(it.kind == nnkTypeDef)
      let superType = typeDecl.getSuperType()
      if superType.kind == nnkEmpty:
        # allow simple types and type aliases
        result.add it
      else:
        let superName = if superType.kind == nnkIdent: superType else: superType.getNodeOf(nnkIdent)
        if $superName != "QtProperty":
          if typ != nil:
            error("only support one type declaration")
          typ = typeDecl.getTypeName
          result.add it
          result.add genSuperTemplate(typeDecl)
        else:
          # process later
          properties.add(it)
    elif it.kind == nnkMethodDef:
      if it.hasPragma("slot"):
        let pragma = it.pragma()
        it.pragma = pragma.removePragma("slot")
        slots.add it # we need to gensome code later
        result.add it
      elif it.hasPragma("signal"):
        let pragma = it.pragma()
        it.pragma = pragma.removePragma("signal")
        it.body = addSignalBody(it)
        result.add it
        signals.add it
    else:
      # everything else should pass through unchanged
      result.add it
  
  ## define onSlotCalled
  var slotProto = (getAst declareOnSlotCalled(typ))[0]
  var caseStmt = newNimNode(nnkCaseStmt)
  caseStmt.add ident("slotName")
  for slot in slots:
    var ofBranch = newNimNode(nnkOfBranch)
    # for exported procedures - strip * marker
    let slotName = ($slot.name).replace("*","")
    ofBranch.add newLit slotName
    let params = slot.params
    let hasReturn = not (params[0].kind == nnkEmpty)
    var branchStmts = newStmtList()
    var args = newSeq[PNimrodNode]()
    # first params always the object
    args.add ident "myQObject"
    for i in 2.. <params.len:
      let pType = getArgType params[i]
      # function that maps Qvariant type to nim type
      let mapper = nimFromQtVariant[$pType]
      let argAccess = newNimNode(nnkBracketExpr)
        .add (ident "args")
        .add newIntLitNode(i-1)
      let dot = newDotExpr(argAccess, ident mapper)
      args.add dot
    var call = newCall(ident slotName, args)
    if hasReturn:
      # eg: args[0].strVal = getName(myQObject)
      let retType = params[0]
      let mapper = nimFromQtVariant[$retType]
      let argAccess = newNimNode(nnkBracketExpr)
        .add (ident "args")
        .add newIntLitNode(0)
      let dot = newDotExpr(argAccess, ident mapper)
      call = newAssignment(dot, call)
    branchStmts.add call     
    ofBranch.add branchStmts
    caseStmt.add ofBranch
  # add else: discard
  caseStmt.add newNimNode(nnkElse)
    .add newStmtList().add newNimNode(nnkDiscardStmt).add newNimNode(nnkEmpty)
  slotProto.body = newStmtList().add caseStmt
  result.add slotProto

  # generate create method
  var createProto = (getAst prototypeCreate(typ))[0]
  # the template creates loads of openSyms - replace these with idents
  createProto = doRemoveOpenSym(createProto) 
  var createBody = createProto.templateBody
  for slot in slots:
    let params = slot.params
    let regSlotDot = newDotExpr(ident "myQObject", ident "registerSlot")
    let name = ($slot.name).replace("*","")
    let argTypesArray = genArgTypeArray(params)
    let call = newCall(regSlotDot, newLit name, argTypesArray)
    createBody.add call
  for signal in signals:
    let params = signal.params
    let regSigDot = newDotExpr(ident "myQObject", ident "registerSignal")
    let name = ($signal.name).replace("*","")
    let argTypesArray = genArgTypeArray(params)
    let call = newCall(regSigDot, newLit name, argTypesArray)
    createBody.add call
  for property in properties:
    let inherit = property.getNodeOf(nnkOfInherit)
    # OfInherit
    #   BracketExpr
    #     Ident !"QtProperty"
    #     Ident !"string"
    let nimPropType = inherit[0][1]
    let qtPropMeta = nim2QtMeta[$nimPropType]
    if qtPropMeta == nil: error($nimPropType & " not supported")
    let metaDot = newDotExpr(ident "QMetaType", ident qtPropMeta) 
    let typeDef = property.getNodeOf(nnkTypeDef)
    let typeName = typeDef.getTypeName()
    var read, write, notify: PNimrodNode
    # fields
    let recList = typeDef.getNodeof(nnkRecList)
    for identDef in recList.children:
      let name = identDef.getIdentDefName()
      case $name
      of "read":
        read = identDef[2]
      of "write":
        write = identDef[2]
      of "notify":
        notify = identDef[2]
      else:
        error("unknown property field: " & $name) 
    let regPropDot = newDotExpr(ident "myQObject", ident "registerProperty")
    let readArg = if read == nil: newNilLit() else: newLit($read)
    let writeArg = if write == nil: newNilLit() else: newLit($write)
    let notifyArg = if notify == nil: newNilLit() else: newLit($notify)
    let call = newCall(regPropDot, newLit($typeName), metaDot, readArg, writeArg, notifyArg)
    createBody.add call

  #echo repr createProto
  result.add createProto
  debug:
    echo repr result