# WRONG - Creates bottleneck
defmodule Foundation do
  use GenServer
  
  def register(key, pid, metadata) do
    GenServer.call(__MODULE__, {:registry, :register, [key, pid, metadata]})
  end
end

# lib/foundation/protocols/registry.ex
defprotocol Foundation.Registry do
  @moduledoc """
  Universal protocol for process/service registration and discovery.
  Implementations optimize for their specific domain requirements.
  """
  
  @fallback_to_any true
  
  @spec register(impl, key :: term(), pid(), metadata :: map()) :: 
    :ok | {:error, term()}
  def register(impl, key, pid, metadata \\ %{})
  
  @spec lookup(impl, key :: term()) :: 
    {:ok, {pid(), map()}} | :error
  def lookup(impl, key)
  
  @spec find_by_attribute(impl, attribute :: atom(), value :: term()) :: 
    {:ok, list({key :: term(), pid(), map()})} | :error
  def find_by_attribute(impl, attribute, value)
  
  @spec list_all(impl, filter :: (map() -> boolean()) | nil) :: 
    list({key :: term(), pid(), map()})
  def list_all(impl, filter \\ nil)
  
  @spec update_metadata(impl, key :: term(), metadata :: map()) :: 
    :ok | {:error, term()}
  def update_metadata(impl, key, metadata)
  
  @spec unregister(impl, key :: term()) :: 
    :ok | {:error, term()}
  def unregister(impl, key)
end

# lib/foundation/protocols/coordination.ex
defprotocol Foundation.Coordination do
  @moduledoc """
  Universal protocol for distributed coordination primitives.
  """
  
  # Consensus
  @spec start_consensus(impl, participants :: [term()], proposal :: term(), timeout()) :: 
    {:ok, consensus_ref :: term()} | {:error, term()}
  def start_consensus(impl, participants, proposal, timeout \\ 30_000)
  
  @spec vote(impl, consensus_ref :: term(), participant :: term(), vote :: term()) :: 
    :ok | {:error, term()}
  def vote(impl, consensus_ref, participant, vote)
  
  @spec get_consensus_result(impl, consensus_ref :: term()) :: 
    {:ok, result :: term()} | {:error, term()}
  def get_consensus_result(impl, consensus_ref)
  
  # Barriers
  @spec create_barrier(impl, barrier_id :: term(), participant_count :: pos_integer()) :: 
    :ok | {:error, term()}
  def create_barrier(impl, barrier_id, participant_count)
  
  @spec arrive_at_barrier(impl, barrier_id :: term(), participant :: term()) :: 
    :ok | {:error, term()}
  def arrive_at_barrier(impl, barrier_id, participant)
  
  @spec wait_for_barrier(impl, barrier_id :: term(), timeout()) :: 
    :ok | {:error, term()}
  def wait_for_barrier(impl, barrier_id, timeout \\ 60_000)
  
  # Locks
  @spec acquire_lock(impl, lock_id :: term(), holder :: term(), timeout()) :: 
    {:ok, lock_ref :: term()} | {:error, term()}
  def acquire_lock(impl, lock_id, holder, timeout \\ 30_000)
  
  @spec release_lock(impl, lock_ref :: term()) :: 
    :ok | {:error, term()}
  def release_lock(impl, lock_ref)
end

# lib/foundation/protocols/infrastructure.ex
defprotocol Foundation.Infrastructure do
  @moduledoc """
  Universal protocol for infrastructure protection patterns.
  """
  
  # Circuit breaker
  @spec register_circuit_breaker(impl, service_id :: term(), config :: map()) :: 
    :ok | {:error, term()}
  def register_circuit_breaker(impl, service_id, config)
  
  @spec execute_protected(impl, service_id :: term(), function :: (-> any()), context :: map()) :: 
    {:ok, result :: any()} | {:error, term()}
  def execute_protected(impl, service_id, function, context \\ %{})
  
  @spec get_circuit_status(impl, service_id :: term()) :: 
    {:ok, :closed | :open | :half_open} | {:error, term()}
  def get_circuit_status(impl, service_id)
  
  # Rate limiting
  @spec setup_rate_limiter(impl, limiter_id :: term(), config :: map()) :: 
    :ok | {:error, term()}
  def setup_rate_limiter(impl, limiter_id, config)
  
  @spec check_rate_limit(impl, limiter_id :: term(), identifier :: term()) :: 
    :ok | {:error, :rate_limited}
  def check_rate_limit(impl, limiter_id, identifier)
end

# lib/foundation.ex
defmodule Foundation do
  @moduledoc """
  Stateless facade for the Foundation Protocol Platform.
  Dispatches directly to configured implementations with zero overhead.
  """
  
  # --- Configuration Access ---
  
  defp registry_impl do
    Application.get_env(:foundation, :registry_impl) || 
      raise "Foundation.Registry implementation not configured"
  end
  
  defp coordination_impl do
    Application.get_env(:foundation, :coordination_impl) ||
      raise "Foundation.Coordination implementation not configured"
  end
  
  defp infrastructure_impl do
    Application.get_env(:foundation, :infrastructure_impl) ||
      raise "Foundation.Infrastructure implementation not configured"
  end
  
  # --- Registry API (Zero Overhead) ---
  
  @spec register(key :: term(), pid(), metadata :: map()) :: 
    :ok | {:error, term()}
  def register(key, pid, metadata \\ %{}) do
    Foundation.Registry.register(registry_impl(), key, pid, metadata)
  end
  
  @spec lookup(key :: term()) :: 
    {:ok, {pid(), map()}} | :error
  def lookup(key) do
    Foundation.Registry.lookup(registry_impl(), key)
  end
  
  @spec find_by_attribute(attribute :: atom(), value :: term()) :: 
    {:ok, list({key :: term(), pid(), map()})} | :error
  def find_by_attribute(attribute, value) do
    Foundation.Registry.find_by_attribute(registry_impl(), attribute, value)
  end
  
  @spec list_all(filter :: (map() -> boolean()) | nil) :: 
    list({key :: term(), pid(), map()})
  def list_all(filter \\ nil) do
    Foundation.Registry.list_all(registry_impl(), filter)
  end
  
  @spec update_metadata(key :: term(), metadata :: map()) :: 
    :ok | {:error, term()}
  def update_metadata(key, metadata) do
    Foundation.Registry.update_metadata(registry_impl(), key, metadata)
  end
  
  @spec unregister(key :: term()) :: 
    :ok | {:error, term()}
  def unregister(key) do
    Foundation.Registry.unregister(registry_impl(), key)
  end
  
  # --- Coordination API (Zero Overhead) ---
  
  @spec start_consensus(participants :: [term()], proposal :: term(), timeout()) :: 
    {:ok, consensus_ref :: term()} | {:error, term()}
  def start_consensus(participants, proposal, timeout \\ 30_000) do
    Foundation.Coordination.start_consensus(coordination_impl(), participants, proposal, timeout)
  end
  
  @spec vote(consensus_ref :: term(), participant :: term(), vote :: term()) :: 
    :ok | {:error, term()}
  def vote(consensus_ref, participant, vote) do
    Foundation.Coordination.vote(coordination_impl(), consensus_ref, participant, vote)
  end
  
  @spec get_consensus_result(consensus_ref :: term()) :: 
    {:ok, result :: term()} | {:error, term()}
  def get_consensus_result(consensus_ref) do
    Foundation.Coordination.get_consensus_result(coordination_impl(), consensus_ref)
  end
  
  @spec create_barrier(barrier_id :: term(), participant_count :: pos_integer()) :: 
    :ok | {:error, term()}
  def create_barrier(barrier_id, participant_count) do
    Foundation.Coordination.create_barrier(coordination_impl(), barrier_id, participant_count)
  end
  
  @spec arrive_at_barrier(barrier_id :: term(), participant :: term()) :: 
    :ok | {:error, term()}
  def arrive_at_barrier(barrier_id, participant) do
    Foundation.Coordination.arrive_at_barrier(coordination_impl(), barrier_id, participant)
  end
  
  @spec wait_for_barrier(barrier_id :: term(), timeout()) :: 
    :ok | {:error, term()}
  def wait_for_barrier(barrier_id, timeout \\ 60_000) do
    Foundation.Coordination.wait_for_barrier(coordination_impl(), barrier_id, timeout)
  end
  
  @spec acquire_lock(lock_id :: term(), holder :: term(), timeout()) :: 
    {:ok, lock_ref :: term()} | {:error, term()}
  def acquire_lock(lock_id, holder, timeout \\ 30_000) do
    Foundation.Coordination.acquire_lock(coordination_impl(), lock_id, holder, timeout)
  end
  
  @spec release_lock(lock_ref :: term()) :: 
    :ok | {:error, term()}
  def release_lock(lock_ref) do
    Foundation.Coordination.release_lock(coordination_impl(), lock_ref)
  end
  
  # --- Infrastructure API (Zero Overhead) ---
  
  @spec execute_protected(service_id :: term(), function :: (-> any()), context :: map()) :: 
    {:ok, result :: any()} | {:error, term()}
  def execute_protected(service_id, function, context \\ %{}) do
    Foundation.Infrastructure.execute_protected(infrastructure_impl(), service_id, function, context)
  end
  
  @spec setup_rate_limiter(limiter_id :: term(), config :: map()) :: 
    :ok | {:error, term()}
  def setup_rate_limiter(limiter_id, config) do
    Foundation.Infrastructure.setup_rate_limiter(infrastructure_impl(), limiter_id, config)
  end
  
  @spec check_rate_limit(limiter_id :: term(), identifier :: term()) :: 
    :ok | {:error, :rate_limited}
  def check_rate_limit(limiter_id, identifier) do
    Foundation.Infrastructure.check_rate_limit(infrastructure_impl(), limiter_id, identifier)
  end
end

# lib/mabeam/agent_registry.ex
defmodule MABEAM.AgentRegistry do
  @moduledoc """
  High-performance agent registry with O(1) capability and health lookups.
  Manages its own ETS tables and lifecycle as a supervised GenServer.
  """
  
  use GenServer
  
  defstruct [
    main_table: nil,
    capability_index: nil,
    health_index: nil,
    node_index: nil,
    resource_index: nil
  ]
  
  # --- OTP Lifecycle ---
  
  def start_link(opts) do
    name = Keyword.get(opts, :name, __MODULE__)
    GenServer.start_link(__MODULE__, opts, name: name)
  end
  
  def child_spec(opts) do
    %{
      id: __MODULE__,
      start: {__MODULE__, :start_link, [opts]},
      type: :worker,
      restart: :permanent,
      shutdown: 5000
    }
  end
  
  def init(_opts) do
    state = %__MODULE__{
      main_table: :ets.new(:agent_main, [:set, :public, :named_table, read_concurrency: true]),
      capability_index: :ets.new(:agent_capability_idx, [:bag, :public, :named_table, read_concurrency: true]),
      health_index: :ets.new(:agent_health_idx, [:bag, :public, :named_table, read_concurrency: true]),
      node_index: :ets.new(:agent_node_idx, [:bag, :public, :named_table, read_concurrency: true]),
      resource_index: :ets.new(:agent_resource_idx, [:ordered_set, :public, :named_table, read_concurrency: true])
    }
    
    {:ok, state}
  end
  
  def terminate(_reason, state) do
    # Clean up ETS tables
    :ets.delete(state.main_table)
    :ets.delete(state.capability_index)
    :ets.delete(state.health_index) 
    :ets.delete(state.node_index)
    :ets.delete(state.resource_index)
    :ok
  end
end

# Foundation.Registry protocol implementation
defimpl Foundation.Registry, for: MABEAM.AgentRegistry do
  def register(registry_pid, agent_id, pid, metadata) do
    GenServer.call(registry_pid, {:register, agent_id, pid, metadata})
  end
  
  def lookup(registry_pid, agent_id) do
    # Direct ETS lookup - no GenServer call needed for reads
    case :ets.lookup(:agent_main, agent_id) do
      [{^agent_id, pid, metadata, _timestamp}] -> {:ok, {pid, metadata}}
      [] -> :error
    end
  end
  
  def find_by_attribute(registry_pid, :capability, capability) do
    # O(1) lookup in capability index
    agent_ids = :ets.lookup(:agent_capability_idx, capability)
                |> Enum.map(&elem(&1, 1))
    
    # Batch lookup in main table
    results = 
      agent_ids
      |> Enum.map(&:ets.lookup(:agent_main, &1))
      |> List.flatten()
      |> Enum.map(fn {id, pid, metadata, _timestamp} -> {id, pid, metadata} end)
    
    {:ok, results}
  end
  
  def find_by_attribute(registry_pid, :health_status, health_status) do
    # O(1) lookup in health index
    agent_ids = :ets.lookup(:agent_health_idx, health_status)
                |> Enum.map(&elem(&1, 1))
    
    # Batch lookup in main table  
    results = 
      agent_ids
      |> Enum.map(&:ets.lookup(:agent_main, &1))
      |> List.flatten()
      |> Enum.map(fn {id, pid, metadata, _timestamp} -> {id, pid, metadata} end)
    
    {:ok, results}
  end
  
  def find_by_attribute(_registry_pid, attribute, _value) do
    {:error, {:unsupported_attribute, attribute}}
  end
  
  def list_all(_registry_pid, filter_fn) do
    :ets.tab2list(:agent_main)
    |> Enum.map(fn {id, pid, metadata, _timestamp} -> {id, pid, metadata} end)
    |> (fn results ->
      if filter_fn, do: Enum.filter(results, fn {_id, _pid, metadata} -> filter_fn.(metadata) end), else: results
    end).()
  end
  
  def update_metadata(registry_pid, agent_id, new_metadata) do
    GenServer.call(registry_pid, {:update_metadata, agent_id, new_metadata})
  end
  
  def unregister(registry_pid, agent_id) do
    GenServer.call(registry_pid, {:unregister, agent_id})
  end
end

# GenServer implementation for state-changing operations
defmodule MABEAM.AgentRegistry do
  # ... (continuation of above)
  
  def handle_call({:register, agent_id, pid, metadata}, _from, state) do
    with :ok <- validate_agent_metadata(metadata) do
      entry = {agent_id, pid, metadata, :os.timestamp()}
      
      case :ets.insert_new(state.main_table, entry) do
        true ->
          # Update all indexes atomically
          update_all_indexes(state, agent_id, metadata)
          
          # Setup process monitoring
          Process.monitor(pid)
          
          {:reply, :ok, state}
        false ->
          {:reply, {:error, :already_exists}, state}
      end
    else
      error -> {:reply, error, state}
    end
  end
  
  def handle_call({:update_metadata, agent_id, new_metadata}, _from, state) do
    with :ok <- validate_agent_metadata(new_metadata),
         [{^agent_id, pid, _old_metadata, _timestamp}] <- :ets.lookup(state.main_table, agent_id) do
      
      # Update main table
      :ets.insert(state.main_table, {agent_id, pid, new_metadata, :os.timestamp()})
      
      # Clear old indexes and rebuild
      clear_agent_from_indexes(state, agent_id)
      update_all_indexes(state, agent_id, new_metadata)
      
      {:reply, :ok, state}
    else
      [] -> {:reply, {:error, :not_found}, state}
      error -> {:reply, error, state}
    end
  end
  
  def handle_call({:unregister, agent_id}, _from, state) do
    case :ets.lookup(state.main_table, agent_id) do
      [{^agent_id, _pid, _metadata, _timestamp}] ->
        :ets.delete(state.main_table, agent_id)
        clear_agent_from_indexes(state, agent_id)
        {:reply, :ok, state}
      [] ->
        {:reply, {:error, :not_found}, state}
    end
  end
  
  def handle_info({:DOWN, _ref, :process, pid, _reason}, state) do
    # Clean up when monitored process dies
    agent_entries = :ets.match(state.main_table, {:'$1', pid, :'$3', :'$4'})
    
    for [agent_id, _metadata, _timestamp] <- agent_entries do
      :ets.delete(state.main_table, agent_id)
      clear_agent_from_indexes(state, agent_id)
    end
    
    {:noreply, state}
  end
  
  # Private helper functions
  
  defp validate_agent_metadata(metadata) do
    required_fields = [:capabilities, :health_status, :node, :resources]
    
    case Enum.find(required_fields, fn field -> not Map.has_key?(metadata, field) end) do
      nil -> :ok
      missing_field -> {:error, {:missing_required_field, missing_field}}
    end
  end
  
  defp update_all_indexes(state, agent_id, metadata) do
    # Capability index
    for capability <- Map.get(metadata, :capabilities, []) do
      :ets.insert(state.capability_index, {capability, agent_id})
    end
    
    # Health index
    health_status = Map.get(metadata, :health_status, :unknown)
    :ets.insert(state.health_index, {health_status, agent_id})
    
    # Node index
    node = Map.get(metadata, :node, node())
    :ets.insert(state.node_index, {node, agent_id})
    
    # Resource index (ordered by memory usage)
    resources = Map.get(metadata, :resources, %{})
    memory_usage = Map.get(resources, :memory_usage, 0.0)
    :ets.insert(state.resource_index, {{memory_usage, agent_id}, agent_id})
  end
  
  defp clear_agent_from_indexes(state, agent_id) do
    :ets.match_delete(state.capability_index, {:_, agent_id})
    :ets.match_delete(state.health_index, {:_, agent_id})
    :ets.match_delete(state.node_index, {:_, agent_id})
    :ets.match_delete(state.resource_index, {{:_, agent_id}, agent_id})
  end
end

# lib/mabeam/discovery.ex
defmodule MABEAM.Discovery do
  @moduledoc """
  Domain-specific discovery APIs for agents.
  Provides clean, agent-native functions while using generic Foundation protocols.
  """
  
  # --- Agent-Specific Discovery Functions ---
  
  @spec find_by_capability(capability :: atom()) :: 
    {:ok, list({agent_id :: term(), pid(), metadata :: map()})} | :error
  def find_by_capability(capability) do
    Foundation.find_by_attribute(:capability, capability)
  end
  
  @spec find_healthy_agents() :: 
    list({agent_id :: term(), pid(), metadata :: map()})
  def find_healthy_agents do
    case Foundation.find_by_attribute(:health_status, :healthy) do
      {:ok, agents} -> agents
      :error -> []
    end
  end
  
  @spec find_agents_on_node(node :: atom()) :: 
    {:ok, list({agent_id :: term(), pid(), metadata :: map()})} | :error
  def find_agents_on_node(node) do
    Foundation.find_by_attribute(:node, node)
  end
  
  @spec find_capable_and_healthy(capability :: atom()) :: 
    list({agent_id :: term(), pid(), metadata :: map()})
  def find_capable_and_healthy(capability) do
    with {:ok, capable_agents} <- find_by_capability(capability),
         {:ok, healthy_agents} <- Foundation.find_by_attribute(:health_status, :healthy) do
      
      # Intersection of capable and healthy agents
      capable_ids = MapSet.new(capable_agents, fn {id, _pid, _metadata} -> id end)
      
      healthy_agents
      |> Enum.filter(fn {id, _pid, _metadata} -> MapSet.member?(capable_ids, id) end)
    else
      _ -> []
    end
  end
  
  @spec find_agents_with_resources(min_memory :: float(), min_cpu :: float()) :: 
    list({agent_id :: term(), pid(), metadata :: map()})
  def find_agents_with_resources(min_memory, min_cpu) do
    Foundation.list_all(fn metadata ->
      resources = Map.get(metadata, :resources, %{})
      memory_available = Map.get(resources, :memory_available, 0.0)
      cpu_available = Map.get(resources, :cpu_available, 0.0)
      
      memory_available >= min_memory and cpu_available >= min_cpu
    end)
  end
  
  @spec count_agents_by_capability() :: map()
  def count_agents_by_capability do
    Foundation.list_all()
    |> Enum.flat_map(fn {_id, _pid, metadata} ->
      Map.get(metadata, :capabilities, [])
    end)
    |> Enum.frequencies()
  end
  
  @spec get_system_health_summary() :: map()
  def get_system_health_summary do
    all_agents = Foundation.list_all()
    
    health_counts = 
      all_agents
      |> Enum.map(fn {_id, _pid, metadata} -> Map.get(metadata, :health_status, :unknown) end)
      |> Enum.frequencies()
    
    %{
      total_agents: length(all_agents),
      health_distribution: health_counts,
      healthy_percentage: 
        (Map.get(health_counts, :healthy, 0) / max(length(all_agents), 1)) * 100
    }
  end
end

# lib/mabeam/coordination.ex  
defmodule MABEAM.Coordination do
  @moduledoc """
  Domain-specific coordination APIs for agents.
  Provides agent-aware coordination while using generic Foundation protocols.
  """
  
  @spec coordinate_capable_agents(capability :: atom(), coordination_type :: atom(), proposal :: term()) :: 
    {:ok, term()} | {:error, term()}
  def coordinate_capable_agents(capability, coordination_type, proposal) do
    case MABEAM.Discovery.find_capable_and_healthy(capability) do
      [] -> 
        {:error, :no_capable_agents}
      
      agents ->
        participant_ids = Enum.map(agents, fn {id, _pid, _metadata} -> id end)
        
        case coordination_type do
          :consensus ->
            Foundation.start_consensus(participant_ids, proposal)
          
          :barrier ->
            barrier_id = generate_barrier_id()
            Foundation.create_barrier(barrier_id, length(participant_ids))
            {:ok, barrier_id}
          
          _ ->
            {:error, {:unsupported_coordination_type, coordination_type}}
        end
    end
  end
  
  @spec coordinate_resource_allocation(required_resources :: map(), allocation_strategy :: atom()) :: 
    {:ok, term()} | {:error, term()}
  def coordinate_resource_allocation(required_resources, allocation_strategy) do
    min_memory = Map.get(required_resources, :memory, 0.0)
    min_cpu = Map.get(required_resources, :cpu, 0.0)
    
    eligible_agents = MABEAM.Discovery.find_agents_with_resources(min_memory, min_cpu)
    
    if length(eligible_agents) == 0 do
      {:error, :insufficient_resources}
    else
      participant_ids = Enum.map(eligible_agents, fn {id, _pid, _metadata} -> id end)
      
      proposal = %{
        type: :resource_allocation,
        required_resources: required_resources,
        allocation_strategy: allocation_strategy,
        eligible_agents: participant_ids
      }
      
      Foundation.start_consensus(participant_ids, proposal)
    end
  end
  
  defp generate_barrier_id do
    :crypto.strong_rand_bytes(16) |> Base.encode16()
  end
end

# config/config.exs
import Config

# Configure Foundation implementations
config :foundation,
  registry_impl: MyApp.AgentRegistry,
  coordination_impl: MyApp.AgentCoordination,
  infrastructure_impl: MyApp.AgentInfrastructure

# Test configuration with mocks
if config_env() == :test do
  config :foundation,
    registry_impl: Foundation.Registry.MockBackend,
    coordination_impl: Foundation.Coordination.MockBackend
end

# lib/my_app/application.ex
defmodule MyApp.Application do
  use Application
  
  def start(_type, _args) do
    children = [
      # Start and supervise the MABEAM implementations
      {MABEAM.AgentRegistry, name: MyApp.AgentRegistry},
      {MABEAM.AgentCoordination, name: MyApp.AgentCoordination},
      {MABEAM.AgentInfrastructure, name: MyApp.AgentInfrastructure},
      
      # Start other MABEAM services
      MABEAM.Supervisor,
      
      # Start Jido integration
      {JidoFoundation.Integration, []},
      
      # Start DSPEx services
      DSPEx.Supervisor
    ]
    
    Supervisor.start_link(children, strategy: :one_for_one, name: MyApp.Supervisor)
  end
end