# test/foundation/mabeam/types_test.exs
defmodule Foundation.MABEAM.TypesTest do
  use ExUnit.Case, async: true
  
  alias Foundation.MABEAM.Types
  
  describe "orchestration_variable/0" do
    test "validates required fields" do
      valid_variable = %{
        id: :test_variable,
        scope: :local,
        type: :agent_selection,
        agents: [:agent1, :agent2],
        coordination_fn: &test_coordination/3,
        adaptation_fn: &test_adaptation/3,
        constraints: [],
        resource_requirements: %{memory: 100, cpu: 0.5},
        fault_tolerance: %{strategy: :restart, max_restarts: 3},
        telemetry_config: %{enabled: true}
      }
      
      assert Types.valid_orchestration_variable?(valid_variable)
    end
    
    test "rejects invalid scope" do
      invalid_variable = %{id: :test, scope: :invalid}
      refute Types.valid_orchestration_variable?(invalid_variable)
    end
  end
end

# lib/foundation/mabeam/types.ex
defmodule Foundation.MABEAM.Types do
  @moduledoc """
  Type definitions and validation for MABEAM multi-agent orchestration.
  """
  
  @type agent_reference :: pid() | {atom(), node()} | atom()
  @type variable_scope :: :local | :global | :cluster
  @type orchestration_type :: :agent_selection | :resource_allocation | :communication_topology
  
  @type orchestration_variable :: %{
    id: atom(),
    scope: variable_scope(),
    type: orchestration_type(),
    agents: [agent_reference()],
    coordination_fn: coordination_function(),
    adaptation_fn: adaptation_function(),
    constraints: [constraint()],
    resource_requirements: resource_allocation(),
    fault_tolerance: fault_tolerance_config(),
    telemetry_config: telemetry_config()
  }
  
  # ... additional type definitions
end

# test/foundation/mabeam/core_test.exs
defmodule Foundation.MABEAM.CoreTest do
  use ExUnit.Case, async: false
  
  alias Foundation.MABEAM.{Core, Types}
  
  setup do
    start_supervised!(Core)
    :ok
  end
  
  describe "variable registration" do
    test "registers valid orchestration variable" do
      variable = create_valid_variable()
      assert :ok = Core.register_orchestration_variable(variable)
      
      {:ok, status} = Core.system_status()
      assert Map.has_key?(status.variable_registry, variable.id)
    end
    
    test "rejects invalid variable" do
      invalid_variable = %{id: :invalid}
      assert {:error, _reason} = Core.register_orchestration_variable(invalid_variable)
    end
  end
  
  describe "system coordination" do
    test "coordinates empty system" do
      assert {:ok, []} = Core.coordinate_system()
    end
    
    test "coordinates system with registered variables" do
      variable = create_valid_variable()
      :ok = Core.register_orchestration_variable(variable)
      
      assert {:ok, results} = Core.coordinate_system()
      assert is_list(results)
    end
  end
end

# lib/foundation/mabeam/core.ex
defmodule Foundation.MABEAM.Core do
  @moduledoc """
  Universal Variable Orchestrator for multi-agent coordination on the BEAM.
  
  Provides the core infrastructure for variables to coordinate agents across
  the entire BEAM cluster, managing agent lifecycle, resource allocation,
  and adaptive behavior based on collective performance.
  """
  
  use GenServer
  use Foundation.Services.ServiceBehaviour
  
  alias Foundation.{ProcessRegistry, Events, Telemetry}
  alias Foundation.MABEAM.{Types}
  
  @type orchestrator_state :: %{
    variable_registry: %{atom() => Types.orchestration_variable()},
    coordination_history: [coordination_event()],
    performance_metrics: performance_metrics(),
    service_config: map()
  }
  
  ## Public API
  
  @spec start_link(keyword()) :: GenServer.on_start()
  def start_link(opts \\ []) do
    GenServer.start_link(__MODULE__, opts, name: __MODULE__)
  end
  
  @spec register_orchestration_variable(Types.orchestration_variable()) :: 
    :ok | {:error, term()}
  def register_orchestration_variable(variable) do
    GenServer.call(__MODULE__, {:register_variable, variable})
  end
  
  @spec coordinate_system() :: {:ok, [coordination_result()]} | {:error, term()}
  def coordinate_system() do
    GenServer.call(__MODULE__, :coordinate_system)
  end
  
  @spec system_status() :: {:ok, system_status()} | {:error, term()}
  def system_status() do
    GenServer.call(__MODULE__, :system_status)
  end
  
  ## GenServer Implementation
  
  @impl true
  def init(opts) do
    case Foundation.Services.ServiceRegistry.register_service(__MODULE__, opts) do
      :ok ->
        state = initialize_orchestrator_state(opts)
        setup_telemetry()
        {:ok, state}
      
      {:error, reason} ->
        {:stop, reason}
    end
  end
  
  @impl true
  def handle_call({:register_variable, variable}, _from, state) do
    case Types.validate_orchestration_variable(variable) do
      {:ok, validated_variable} ->
        new_state = %{state | 
          variable_registry: Map.put(state.variable_registry, variable.id, validated_variable)
        }
        
        emit_variable_registered_event(variable)
        {:reply, :ok, new_state}
      
      {:error, reason} ->
        {:reply, {:error, reason}, state}
    end
  end
  
  # ... additional GenServer callbacks
end

describe "coordination algorithms" do
  test "coordinates agent selection variable" do
    agents = [:agent1, :agent2, :agent3]
    variable = create_agent_selection_variable(agents)
    :ok = Core.register_orchestration_variable(variable)
    
    context = %{task_type: :computation, load: :medium}
    {:ok, results} = Core.coordinate_system(context)
    
    assert [%{agent: selected_agent, action: :start}] = results
    assert selected_agent in agents
  end
  
  test "handles coordination failures gracefully" do
    failing_variable = create_failing_variable()
    :ok = Core.register_orchestration_variable(failing_variable)
    
    assert {:ok, []} = Core.coordinate_system()
    # Should log error but not crash
  end
end

describe "foundation integration" do
  test "registers with process registry" do
    start_supervised!(Core)
    
    assert {:ok, pid} = Foundation.ProcessRegistry.lookup(Core)
    assert is_pid(pid)
  end
  
  test "emits telemetry events" do
    :telemetry_test.attach_event_handlers(self(), [
      [:mabeam, :coordination, :start],
      [:mabeam, :coordination, :stop]
    ])
    
    variable = create_valid_variable()
    :ok = Core.register_orchestration_variable(variable)
    {:ok, _} = Core.coordinate_system()
    
    assert_received {:telemetry, [:mabeam, :coordination, :start], _, _}
    assert_received {:telemetry, [:mabeam, :coordination, :stop], _, _}
  end
end