defmodule Scopes.CSys.Programs 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/2}
    #&std_proc/2
  end

  # processors

  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

  def std_proc({:parent}, scope) do
    env = env(scope)
    syn = synapse(self(), &Function.identity/1, 0)
    new = neuron({[], Environ.get_stage(env, :basic, :initial), [syn], env})
    notify({:created, new}, scope)
  end

  #def std_proc({:activate}, {state, _proc, syns, env) do
  def 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 std_proc(msg, scope) do
    unless forward(msg, scope), do: notify(msg, scope)
  end
end