# SPDX-License-Identifier: ISC

import ./syndicate/bags, ./syndicate/dataflow, ./syndicate/events, ./syndicate/skeletons
import preserves
import asyncdispatch, deques, hashes, macros, options, sets, strutils, tables

export dataflow.defineObservableProperty
export dataflow.recordObservation
export dataflow.recordDamage

template generateIdType(T: untyped) =
  type T* = distinct Natural
  proc `==`*(x, y: T): bool {.borrow.}
  proc `$`*(id: T): string {.borrow.}

generateIdType(ActorId)
generateIdType(FacetId)
generateIdType(EndpointId)
generateIdType(FieldId)

type
  Value* = Preserve
  Bag = bags.Bag[Value]

  Task[T] = proc (): T
  Script[T] = proc (facet: Facet): T
  ActivationScript* = Script[void]

  ActionKind = enum
    patchAction, messageAction, spawnAction, quitAction, deferredTurnAction, activationAction

  Action = object
    impl: proc (action: Action; ds: Dataspace; actor: Option[Actor]) {.gcsafe.}
    case kind: ActionKind
    of patchAction:
      changes: Bag
    else:
      discard

  Priority = enum
    pQueryHigh = 0,
    pQuery,
    pQueryHandler,
    pNormal,
    pGC,
    pIdle,
    len

  Actor = ref object
    id: ActorId
    name: string
    dataspace*: Dataspace
    rootFacet: ParentFacet
    pendingTasks: array[Priority.len, Deque[Task[void]]]
    pendingActions: seq[Action]
    adhocAssertions: Bag
    cleanupChanges: Bag
    parentId: ActorId
    isRunnable: bool

  EndpointSpec* = object
    assertion*: Option[Value]
    analysis*: Option[Analysis]

  Endpoint = ref object
    id: EndpointId
    facet: Facet
    updateProc: Script[EndpointSpec]
    spec: EndpointSpec

  Fields = seq[Preserve]
    # TODO: compile-time tuples

  Turn = object
    actions: seq[Action]
    actor: Option[Actor]

  Dataspace* = ref object
    ground*: Ground
    index: Index
    dataflow*: Graph[Endpoint, FieldId]
    runnable: seq[Actor]
    pendingTurns: seq[Turn]
    actors: Table[ActorId, Actor]
    activations: seq[ActivationScript]
    nextId: Natural

  StopHandler = proc (ds: Dataspace) {.gcsafe.}

  Ground = ref object
    dataspace: Dataspace
    stopHandlers: seq[StopHandler]
    future: Future[void]

  ParentFacet = Option[Facet]

  Facet* = ref FacetObj
  FacetObj = object
    id: FacetId
    actor*: Actor
    parent: ParentFacet
    endpoints: Table[EndpointId, Endpoint]
    stopScripts: seq[Script[void]]
    children: Table[FacetId, Facet]
    fields*: Fields
    isLive, inScript: bool

  # FacetImpl[Fields] = ref FacetImplObj[Fields]
  # FacetImplObj[Fields] {.final.} = object of FacetBaseObj

using
  dataspace: Dataspace
  actor: Actor
  facet: Facet

proc `$`*(spec: EndpointSpec): string =
  result.add "{assertion: "
  if spec.assertion.isSome:
    result.add $(spec.assertion.get)
  else:
    result.add "nil"
  result.add ", analysis: "
  if spec.analysis.isSome:
    result.add $spec.analysis.get
  else:
    result.add "nil"
  result.add " }"

proc `$`*(actor): string =
  result.add "Actor("
  result.add $actor.id
  result.add ','
  result.add actor.name
  result.add ')'

proc `$`*(facet): string =
  result.add "Facet("
  result.add $facet.actor.id
  result.add ','
  result.add facet.actor.name
  result.add ','
  result.add $facet.id
  result.add ')'

proc hash*(ep: Endpoint): Hash =
  !$(hash(ep.id) !& hash(ep.facet.id))

proc generateId*(ds: Dataspace): Natural =
  # TODO: used by declareField, but should be hidden.
  inc(ds.nextId)
  ds.nextId

proc newActor(ds: Dataspace; name: string; initialAssertions: Value; parentId: ActorId): Actor =
  assert(initialAssertions.kind == pkSet)
  result = Actor(
      id: ds.generateId.ActorId,
      name: name,
      dataspace: ds,
      parentId: parentId)
  for v in initialAssertions.set:
    discard result.adhocAssertions.change(v, 1)
  ds.actors[result.id] = result

proc newFacet(actor; parent: ParentFacet): Facet =
  result = Facet(
      id: actor.dataspace.generateId.FacetId,
      actor: actor,
      parent: parent,
      isLive: true,
      inScript: true)
  if parent.isSome:
    parent.get.children[result.id] = result
  else:
    actor.rootFacet = some result

proc applyPatch(ds: Dataspace; actor: Option[Actor]; changes: Bag) =
  type Pair = tuple[val: Value; count: int]
  var removals: seq[Pair]
  for a, count in changes.pairs:
    if count > 0:
      # echo "applyPatch +", a
      discard ds.index.adjustAssertion(a, count)
    else:
      removals.add((a, count))
    actor.map do (ac: Actor):
      discard ac.cleanupChanges.change(a, -count)
  for (a, count) in removals:
    # echo "applyPatch -", a
    discard ds.index.adjustAssertion(a, count)

proc initPatch(): Action =
  proc impl(patch: Action; ds: Dataspace; actor: Option[Actor]) {.gcsafe.} =
    ds.applyPatch(actor, patch.changes)
  Action(impl: impl, kind: patchAction)

proc pendingPatch(actor): var Action =
  for a in actor.pendingActions.mitems:
    if a.kind == patchAction: return a
  actor.pendingActions.add(initPatch())
  actor.pendingActions[actor.pendingActions.high]

proc adjust(patch: var Action; v: Value; delta: int) =
  discard patch.changes.change(v, delta)

proc subscribe(ds: Dataspace; handler: Analysis) =
  ds.index.addHandler(handler, handler.callback.get)

proc unsubscribe(ds: Dataspace; handler: Analysis) =
  ds.index.removeHandler(handler, handler.callback.get)

proc assert(actor; a: Value) = actor.pendingPatch.adjust(a, +1)

proc retract(actor; a: Value) = actor.pendingPatch.adjust(a, -1)

proc install(ep: Endpoint; spec: EndpointSpec) =
  ep.spec = spec
  ep.spec.assertion.map do (a: Value):
    ep.facet.actor.assert(a)
  ep.spec.analysis.map do (a: Analysis):
    ep.facet.actor.dataspace.subscribe(a)

proc scheduleTask(actor; prio: Priority; task: Task[void]) =
  if not actor.isRunnable:
    actor.isRunnable = true
    actor.dataspace.runnable.add(actor)
  actor.pendingTasks[prio].addLast(task)

proc scheduleTask(actor; task: Task[void]) =
  scheduleTask(actor, pNormal, task)

proc abandonQueuedWork(actor) =
  actor.pendingActions = @[]
  for q in actor.pendingTasks.mitems: clear(q)

proc uninstall(ep: Endpoint; emitPatches: bool) =
  if emitPatches:
    ep.spec.assertion.map do (a: Value):
      ep.facet.actor.retract(a)
  ep.spec.analysis.map do (a: Analysis):
    ep.facet.actor.dataspace.unsubscribe(a)

proc destroy(ep: Endpoint; emitPatches: bool) =
  ep.facet.actor.dataspace.dataflow.forgetSubject(ep)
  ep.uninstall(emitPatches)
  ep.facet.actor.scheduleTask(pGC) do ():
    ep.facet.endpoints.del(ep.id)
      # TODO: cannot remove from ep.facet.endpoints during
      # its iteration, defering remove is probably unecessary
      # because the facet is going down.

proc retractAssertionsAndSubscriptions(facet; emitPatches: bool) =
  facet.actor.scheduleTask do ():
    for ep in facet.endpoints.values:
      ep.destroy(emitPatches)
    clear(facet.endpoints)

proc abort(facet; emitPatches: bool) =
  facet.isLive = false
  for child in facet.children.values:
    child.abort(emitPatches)
  facet.retractAssertionsAndSubscriptions(emitPatches)

proc enqueueScriptAction(actor; action: Action) =
  actor.pendingActions.add(action)

proc enqueueScriptAction(facet; action: Action) =
  enqueueScriptAction(facet.actor, action)

proc initQuitAction(): Action =
  proc impl(action: Action; ds: Dataspace; actor: Option[Actor]) =
    assert(actor.isSome)
    ds.applyPatch(actor, actor.get.cleanupChanges)
    ds.actors.del(actor.get.id)
  Action(impl: impl, kind: quitAction)

proc terminate(actor; emitPatches: bool) =
  if emitPatches:
    actor.scheduleTask do ():
      for a in actor.adhocAssertions.keys:
        actor.retract(a)
  actor.rootFacet.map do (root: Facet):
    root.abort(emitPatches)
  actor.scheduleTask do ():
    actor.enqueueScriptAction(initQuitAction())

proc invokeScript(facet; script: Script[void]) =
  try: script(facet)
  except:
    let e = getCurrentException()
    # TODO: install an error handling callback at the facet?
    facet.actor.abandonQueuedWork()
    facet.actor.terminate(false)
    raise e

func isInert(facet): bool =
  facet.endpoints.len == 0 and facet.children.len == 0

proc terminate(facet) =
  if facet.isLive:
    let
      actor = facet.actor
      parent = facet.parent
    if parent.isSome:
      parent.get.children.del(facet.id)
    else:
      reset actor.rootFacet
    facet.isLive = false
    for child in facet.children.values:
      child.terminate()
    actor.scheduleTask do ():
      facet.invokeScript do (facet: Facet):
        for s in facet.stopScripts:
          s(facet)

    facet.retractAssertionsAndSubscriptions(true)
    actor.scheduleTask(pGC) do ():
      if parent.isSome:
        if parent.get.isInert:
          parent.get.terminate()
      else:
        actor.terminate(true)

template withNonScriptContext(facet; body: untyped) =
  let inScriptPrev = facet.inScript
  facet.inScript = false
  try: body
  finally: facet.inScript = inScriptPrev

proc ensureFacetSetup(facet; s: string) =
  assert(not facet.inScript, "Cannot " & s & "ouside facet setup")

proc ensureNonFacetSetup(facet; s: string) =
  assert(facet.inScript, "Cannot " & s & " during facet setup")

proc wrap(facet; script: Script[void]): Task[void] =
  proc task() = facet.invokeScript(script)
  task

proc wrap*(facet; cb: proc(facet: Facet; event: EventKind; bindings: seq[Value]) {.gcsafe.}): HandlerCallback =
  proc wrapper(event: EventKind; bindings: seq[Value]) =
    facet.invokeScript do (facet: Facet):
      cb(facet, event, bindings)
  wrapper

proc scheduleScript*(facet; prio: Priority; script: Script[void]) =
  facet.actor.scheduleTask(prio, facet.wrap(script))

proc scheduleScript*(facet; script: Script[void]) =
  facet.actor.scheduleTask(pNormal, facet.wrap(script))

proc addStartScript(facet; s: Script[void]) =
  facet.ensureFacetSetup("onStart")
  facet.scheduleScript(pNormal, s)

proc addFacet(actor; parentFacet: Option[Facet]; bootScript: Script[void]; checkInScript = false) =
  if checkInScript and parentFacet.isSome:
    assert parentFacet.get.inScript
  let f = Facet(
      id: actor.dataspace.generateId.FacetId,
      actor: actor,
      parent: parentFacet,
      isLive: true,
      inScript: true)
  if parentFacet.isSome:
    parentFacet.get.children[f.id] = f
    f.fields = parentFacet.get.fields
      # inherit scope by copying fields of the parent
  else:
    actor.rootFacet = some f
  f.invokeScript do (facet: Facet):
    facet.withNonScriptContext:
      bootScript(facet)
  actor.scheduleTask do ():
    if ((parentFacet.isSome) and (not parentFacet.get.isLive)) or f.isInert:
      f.terminate()

proc deliverMessage(ds: Dataspace; msg: Value; ac: Option[Actor]) =
  ds.index.deliverMessage(msg)

proc adhocRetract(actor; a: Value) =
  if actor.adhocAssertions.change(a, -1, true) == cdPresentToAbsent:
    actor.retract(a)

proc refresh(ep: Endpoint) =
  let newSpec = ep.updateProc(ep.facet)
  if newSpec.assertion != ep.spec.assertion:
    ep.uninstall(true)
    ep.install(newSpec)

proc refreshAssertions(ds: Dataspace) =
  ds.dataflow.repairDamage do (ep: Endpoint):
    let facet = ep.facet
    assert(facet.isLive)
    facet.invokeScript do (f: Facet):
      f.withNonScriptContext:
        refresh(ep)

proc addActor(ds: Dataspace; name: string; bootProc: Script[void]; initialAssertions: Value; parent: Option[Actor]) =
  var parentId: ActorId
  parent.map do (p: Actor): parentId = p.id
  let ac = newActor(ds, name, initialAssertions, parentId)
  ds.applyPatch(some ac, ac.adhocAssertions)
  ac.addFacet(none Facet) do (systemFacet: Facet):
    # Root facet is a dummy "system" facet that exists to hold
    # one-or-more "user" "root" facets.
    ac.addFacet(some systemFacet, bootProc)
    # ^ The "true root", user-visible facet.
    for a in initialAssertions.set:
      ac.adhocRetract(a)

proc send*(facet; body: Value) =
  facet.ensureNonFacetSetup("send")
  proc impl(action: Action; ds: Dataspace; actor: Option[Actor]) =
    ds.deliverMessage(body, actor)
  facet.enqueueScriptAction(Action(impl: impl, kind: messageAction))

proc initSpawnAction(name: string; bootProc: Script[void], initialAssertions: Value): Action =
  proc impl(action: Action; ds: Dataspace; actor: Option[Actor]) =
    ds.addActor(name, bootProc, initialAssertions, actor)
  Action(impl: impl, kind: spawnAction)

proc spawn*(facet; name: string; bootProc: Script[void], initialAssertions: Value) =
  facet.ensureNonFacetSetup("spawn")
  facet.enqueueScriptAction(initSpawnAction(name, bootProc, initialAssertions))

proc spawn*(facet; name: string; bootProc: Script[void]) =
  spawn(facet, name, bootProc, Value(kind: pkSet))

#[
template spawn*(facet; name: string; fields: untyped; bootProc: Script[void]): untyped =
  type Fields = typeof(fields)
  spawn[Fields](facet, name, bootProc, Value(kind: pkSet))
]#

proc initActivationAction(script: ActivationScript; name: string): Action =
  proc impl(action: Action; ds: Dataspace; actor: Option[Actor]) =
    for s in ds.activations:
      if s == script: return
    ds.activations.add(script)
    proc boot(root: Facet) =
      root.addStartScript(script)
    ds.addActor(name, boot, Preserve(kind: pkSet), actor)
  Action(impl: impl, kind: activationAction)

proc activate(facet; script: ActivationScript; name = "") =
  facet.ensureNonFacetSetup "`activate`"
  facet.enqueueScriptAction(initActivationAction(script, name))

proc newDataspace(ground: Ground; bootProc: ActivationScript): Dataspace =
  let turn = Turn(actions: @[initSpawnAction("", bootProc, Value(kind: pkSet))])
  Dataspace(ground: ground, index: initIndex(), pendingTurns: @[turn])

proc addEndpoint*(facet; updateScript: Script[EndpointSpec], isDynamic = true): Endpoint =
  facet.ensureFacetSetup("add endpoint")
  let
    actor = facet.actor
    dataspace = actor.dataspace
  result = Endpoint(
        id: dataspace.generateId.EndpointId,
        facet: facet,
        updateProc: updateScript)
  dataspace.dataflow.addSubject(result)
  let
    dyn = if isDynamic: some result else: none Endpoint
    initialSpec = dataspace.dataflow.withSubject(dyn) do () -> EndpointSpec:
      updateScript(facet)
  result.install(initialSpec)
  facet.endpoints[result.id] = result
  # dataspace.endpointHook(facet, result)
  # Subclasses may override

proc addDataflow*(facet; prio: Priority; subjectProc: Script[void]): Endpoint =
  facet.addEndpoint do (fa: Facet) -> EndpointSpec:
    let subjectId = facet.actor.dataspace.dataflow.currentSubjectId
    facet.scheduleScript(prio) do (fa: Facet):
      if facet.isLive:
        facet.actor.dataspace.dataflow.withSubject(subjectId):
          subjectProc(facet)
    # result is the default EndpointSpec

proc addDataflow*(facet; subjectProc: Script[void]): Endpoint =
  addDataflow(facet, pNormal, subjectProc)

proc commitActions(dataspace; actor; pending: seq[Action]) =
  dataspace.pendingTurns.add(Turn(actor: some actor, actions: pending))

proc runPendingTask(actor): bool =
  for deque in actor.pendingTasks.mitems:
    if deque.len > 0:
      let task = deque.popFirst()
      task()
      actor.dataspace.refreshAssertions()
      return true

proc runPendingTasks(actor) =
  while actor.runPendingTask(): discard
  actor.isRunnable = false
  if actor.pendingActions.len > 0:
    var pending = move actor.pendingActions
    actor.dataspace.commitActions(actor, pending)

proc runPendingTasks(ds: Dataspace) =
  var runnable = move ds.runnable
  for actor in runnable:
    runPendingTasks(actor)

proc performPendingActions(ds: Dataspace) =
  var turns = move ds.pendingTurns
  for turn in turns:
    for action in turn.actions:
      action.impl(action, ds, turn.actor)
      runPendingTasks(ds)

proc runTasks(ds: Dataspace): bool =
  ds.runPendingTasks()
  ds.performPendingActions()
  result = ds.runnable.len > 0 or ds.pendingTurns.len > 0

proc stop*(facet; continuation: Script[void]) =
  facet.parent.map do (parent: Facet):
    facet.actor.scheduleTask do ():
      facet.terminate()
      parent.scheduleScript do (parent: Facet):
        continuation(parent)
        # ^ TODO: is this the correct scope to use??

proc stop*(facet) =
  facet.parent.map do (parent: Facet):
    facet.actor.scheduleTask do ():
      facet.terminate()

proc addStopHandler*(g: Ground; h: StopHandler) =
  g.stopHandlers.add(h)

proc step(g: Ground) =
  if g.dataspace.runTasks():
    asyncdispatch.callSoon: step(g)
  else:
    for sh in g.stopHandlers:
      sh(g.dataspace)
    reset g.stopHandlers
    complete(g.future)

proc bootModule*(bootProc: ActivationScript): Future[void] =
  # TODO: better integration with the async dispatcher
  let g = Ground(future: newFuture[void]"bootModule")
  g.dataspace = newDataspace(g) do (rootFacet: Facet):
    rootFacet.addStartScript do (rootFacet: Facet):
      rootFacet.activate(bootProc)
  addTimer(1, true) do (fd: AsyncFD) -> bool:
    step(g)
    true
  return g.future

template declareField*(facet: Facet; F: untyped; T: typedesc; init: T): untyped =
  ## Declare getter and setter procs for field `F` of type `T` initalized with `init`.
  # TODO: do more at compile-time, use a tuple rather than a sequence of Preserves.
  facet.fields.add(toPreserve(init))
  let
    `F FieldOff` = facet.fields.high
    `F FieldId` = facet.actor.dataspace.generateId.FieldId
  facet.actor.dataspace.dataflow.defineObservableProperty(`F FieldId`)

  proc `F`(fields: Fields): T =
    facet.actor.dataspace.dataflow.recordObservation(`F FieldId`)
    fromPreserve[T](result, facet.fields[`F FieldOff`])

  proc `F =`(fields: var Fields; x: T) =
    facet.actor.dataspace.dataflow.recordDamage(`F FieldId`)
    facet.fields[`F FieldOff`] = toPreserve[T](x)

  proc `F =`(fields: var Fields; x: Preserve) =
    assert(x.kind == facet.fields[`F FieldOff`].kind, "invalid Preserves item for field type")
    facet.actor.dataspace.dataflow.recordDamage(`F FieldId`)
    facet.fields[`F FieldOff`] = x


#[
# Some early macros

proc send() =
  discard

proc generateField(stmt: NimNode): NimNode =
  stmt.expectLen 3
  let l = stmt[1]
  let r = stmt[2]
  case r.kind
  of nnkStmtList:
    r.expectLen 1
    result = newNimNode(nnkVarSection).add(newIdentDefs(l, r[0]))
  else:
    raiseAssert("unhandled field " & r.treeRepr)

proc generateStopOnTuple(output: var NimNode; stmt: NimNode): NimNode =
  stmt.expectLen 3
  let
    cond = stmt[1]
    body = stmt[2]
    # symCond = genSym(ident="stopOnCond")
    symStop = genSym(ident="stopOnCb")
  # output.add(newProc(name = symCond, params = [ident"bool"], body = cond))
  output.add(newProc(name = symStop, body = body))
  newPar(newColonExpr(ident"cond", cond), newColonExpr(ident"body", symStop))

macro spawn*(label: string; body: untyped) =
  ## Spawn actor.
  result = newNimNode(nnkStmtList)
  let blockBody = newNimNode(nnkStmtList)
  let actorSym = genSym(nskVar, label.strVal)
  result.add(newNimNode(nnkVarSection).add(
    newIdentDefs(actorSym, ident"Actor")))
  var stopOnSeq = newNimNode(nnkBracket)
  body.expectKind nnkStmtList
  for stmt in body:
    case stmt.kind
    of nnkCommentStmt:
      result.add(stmt)
    of nnkCommand:
      let cmd = stmt[0]
      cmd.expectKind nnkIdent
      if eqIdent(cmd, "field"):
        result.add(generateField(stmt))
      elif eqIdent(cmd, "stopOn"):
        let stop = generateStopOnTuple(result, stmt)
        stopOnSeq.add(stop)
      else:
        raiseAssert("unhandled spawn command " & cmd.repr)
    else:
      raiseAssert("unhandled statment " & stmt.treeRepr)
  result.add(
    newAssignment(newDotExpr(actorSym, ident"stops"), prefix(stopOnSeq, "@")))
  #result.add(newBlockStmt(blockBody))
  echo result.repr
  # echo result.treeRepr

macro dumpStuff*(body: untyped): untyped =
  echo body.treeRepr
]#