defmodule Scopes.CSys.Program do
  import Scopes.CSys, only: [
    neuron: 1, update_neuron: 1, synapse: 3, 
    syns: 1, env: 1
  ]

  alias Scopes.CSys.Environ

  # programs

  def basic_prog() do
    %{initial: &std_proc/1,
      active: &std_proc/1,
      retired: &std_proc/1
    }
  end

  # processors

  #def std_proc({:parent}, scope) do
  def std_proc(msg) do
    scope = Process.get(:scope)
    case msg do
      {:parent} ->
        new = create_parent(scope)
        notify({:created, new}, scope)
      _ -> forward(msg, scope) || notify(msg, scope)
    end
  end

  #def std_proc({:activate}, {state, _proc, syns, env) do
  def xx_std_proc({:next}, {state, _proc, syns, env}) do
    #proc = Environ.get_next_stage(env, :basic, :initial)
    #proc = Environ.get_stage_for(env, :basic, :activate)
    proc = Environ.get_stage(env, :basic, :active)
    update_neuron({state, proc, syns, env})
  end

  def xx_std_proc(msg, scope) do
    forward(msg, scope) || notify(msg, scope)
  end

# processor steps

  def notify(msg, scope) do
    Environ.notify(env(scope), msg)
  end

  def forward(msg, scope) do
    Enum.reduce(syns(scope), false, fn s, _acc -> s.(msg); true end)
  end

# step functions

  def create_parent({_state, procs, _syns, env}) do
    syn = synapse(self(), &Function.identity/1, 0)
    #neuron({[], Environ.get_stage(env, :basic, :initial), [syn], env})
    neuron({[], procs, [syn], env})
  end
end