# foundation/lib/foundation/process_registry/registry.ex
defmodule Foundation.ProcessRegistry do
  # Current: Basic process registration and lookup
  def register(name, pid, metadata \\ %{})
  def lookup(name)
  def unregister(name)
end

# foundation/lib/foundation/process_registry/registry.ex (enhanced)
defmodule Foundation.ProcessRegistry do
  @moduledoc """
  Enhanced process registry with agent-aware capabilities.
  Provides service discovery, agent metadata, and coordination support.
  """
  
  @type agent_metadata :: %{
    type: :agent | :service | :process,
    agent_type: atom(),
    capabilities: [atom()],
    coordination_variables: [atom()],
    resource_requirements: map(),
    health_status: :healthy | :degraded | :unhealthy,
    performance_metrics: map(),
    created_at: DateTime.t(),
    last_heartbeat: DateTime.t()
  }
  
  # Enhanced registration with rich metadata
  def register_agent(agent_id, pid, agent_config) do
    metadata = %{
      type: :agent,
      agent_type: agent_config[:agent_type],
      capabilities: agent_config[:capabilities] || [],
      coordination_variables: agent_config[:coordination_variables] || [],
      resource_requirements: agent_config[:resource_requirements] || %{},
      health_status: :healthy,
      performance_metrics: %{},
      created_at: DateTime.utc_now(),
      last_heartbeat: DateTime.utc_now()
    }
    
    register(agent_id, pid, metadata)
    
    # Start health monitoring
    Foundation.ProcessRegistry.HealthMonitor.monitor_agent(agent_id, pid)
    
    # Publish agent registration event
    Foundation.Services.EventStore.publish(%Foundation.Types.Event{
      type: :agent_registered,
      source: agent_id,
      data: metadata
    })
  end
  
  # Agent discovery by capabilities
  def find_agents_by_capability(capability) do
    get_all_agents()
    |> Enum.filter(fn {_id, metadata} ->
      capability in (metadata.capabilities || [])
    end)
    |> Enum.map(fn {id, _metadata} -> id end)
  end
  
  # Agent discovery by type
  def find_agents_by_type(agent_type) do
    get_all_agents()
    |> Enum.filter(fn {_id, metadata} ->
      metadata.agent_type == agent_type
    end)
    |> Enum.map(fn {id, _metadata} -> id end)
  end
  
  # Update agent health status
  def update_agent_health(agent_id, health_status) do
    case lookup(agent_id) do
      {:ok, pid} ->
        metadata = get_metadata(agent_id)
        new_metadata = %{metadata | 
          health_status: health_status,
          last_heartbeat: DateTime.utc_now()
        }
        update_metadata(agent_id, new_metadata)
        
        # Publish health update
        Foundation.Services.EventStore.publish(%Foundation.Types.Event{
          type: :agent_health_updated,
          source: agent_id,
          data: %{health_status: health_status}
        })
        
        :ok
      
      {:error, :not_found} ->
        {:error, :agent_not_found}
    end
  end
  
  # Get all agents with their metadata
  def get_all_agents() do
    get_all()
    |> Enum.filter(fn {_id, metadata} -> metadata.type == :agent end)
  end
  
  # Get agent coordination variables
  def get_agent_variables(agent_id) do
    case get_metadata(agent_id) do
      {:ok, metadata} -> {:ok, metadata.coordination_variables}
      error -> error
    end
  end
end

# foundation/lib/foundation/process_registry/health_monitor.ex
defmodule Foundation.ProcessRegistry.HealthMonitor do
  @moduledoc """
  Health monitoring for registered agents.
  """
  use GenServer
  
  def start_link(opts) do
    GenServer.start_link(__MODULE__, opts, name: __MODULE__)
  end
  
  def monitor_agent(agent_id, pid) do
    GenServer.cast(__MODULE__, {:monitor_agent, agent_id, pid})
  end
  
  def init(_opts) do
    # Check agent health every 30 seconds
    :timer.send_interval(30_000, :health_check)
    {:ok, %{monitored_agents: %{}}}
  end
  
  def handle_cast({:monitor_agent, agent_id, pid}, state) do
    # Monitor the process
    ref = Process.monitor(pid)
    
    new_monitored = Map.put(state.monitored_agents, agent_id, %{
      pid: pid,
      ref: ref,
      last_check: DateTime.utc_now()
    })
    
    {:noreply, %{state | monitored_agents: new_monitored}}
  end
  
  def handle_info(:health_check, state) do
    # Perform health checks on all monitored agents
    Enum.each(state.monitored_agents, fn {agent_id, info} ->
      check_agent_health(agent_id, info.pid)
    end)
    
    {:noreply, state}
  end
  
  def handle_info({:DOWN, ref, :process, pid, reason}, state) do
    # Handle agent process termination
    case find_agent_by_ref(state.monitored_agents, ref) do
      {:ok, agent_id} ->
        handle_agent_termination(agent_id, pid, reason)
        new_monitored = Map.delete(state.monitored_agents, agent_id)
        {:noreply, %{state | monitored_agents: new_monitored}}
      
      :not_found ->
        {:noreply, state}
    end
  end
  
  defp check_agent_health(agent_id, pid) do
    # Send health check message to agent
    try do
      response = GenServer.call(pid, :health_check, 5000)
      
      health_status = case response do
        {:ok, :healthy} -> :healthy
        {:ok, :degraded} -> :degraded
        _ -> :unhealthy
      end
      
      Foundation.ProcessRegistry.update_agent_health(agent_id, health_status)
    catch
      :exit, _ ->
        Foundation.ProcessRegistry.update_agent_health(agent_id, :unhealthy)
    end
  end
  
  defp handle_agent_termination(agent_id, pid, reason) do
    # Log termination
    Foundation.Services.EventStore.publish(%Foundation.Types.Event{
      type: :agent_terminated,
      source: agent_id,
      data: %{pid: pid, reason: reason}
    })
    
    # Unregister the agent
    Foundation.ProcessRegistry.unregister(agent_id)
  end
end

# foundation/lib/foundation/infrastructure/agent_circuit_breaker.ex
defmodule Foundation.Infrastructure.AgentCircuitBreaker do
  @moduledoc """
  Circuit breaker with agent-specific configuration and metrics.
  """
  
  def register_for_agent(agent_id, service_name, config \\ %{}) do
    circuit_breaker_name = "#{agent_id}_#{service_name}"
    
    enhanced_config = Map.merge(config, %{
      agent_id: agent_id,
      service_name: service_name,
      telemetry_prefix: [:foundation, :agent_circuit_breaker],
      on_state_change: &handle_agent_circuit_breaker_state_change/3
    })
    
    Foundation.Infrastructure.CircuitBreaker.register(circuit_breaker_name, enhanced_config)
  end
  
  def execute_for_agent(agent_id, service_name, function) do
    circuit_breaker_name = "#{agent_id}_#{service_name}"
    
    result = Foundation.Infrastructure.CircuitBreaker.execute(circuit_breaker_name, function)
    
    # Track agent-specific metrics
    Foundation.Telemetry.track_agent_service_call(agent_id, service_name, result)
    
    result
  end
  
  defp handle_agent_circuit_breaker_state_change(circuit_breaker_name, old_state, new_state) do
    # Extract agent_id and service_name from circuit_breaker_name
    [agent_id, service_name] = String.split(circuit_breaker_name, "_", parts: 2)
    
    # Publish state change event
    Foundation.Services.EventStore.publish(%Foundation.Types.Event{
      type: :agent_circuit_breaker_state_change,
      source: String.to_atom(agent_id),
      data: %{
        service_name: service_name,
        old_state: old_state,
        new_state: new_state
      }
    })
    
    # Update agent health if circuit breaker is open
    if new_state == :open do
      Foundation.ProcessRegistry.update_agent_health(String.to_atom(agent_id), :degraded)
    end
  end
end

# foundation/lib/foundation/infrastructure/agent_rate_limiter.ex
defmodule Foundation.Infrastructure.AgentRateLimiter do
  @moduledoc """
  Rate limiter with agent-specific quotas and coordination.
  """
  
  def setup_for_agent(agent_id, rate_limits) do
    Enum.each(rate_limits, fn {service, limit_config} ->
      limiter_name = "#{agent_id}_#{service}"
      
      enhanced_config = Map.merge(limit_config, %{
        agent_id: agent_id,
        service_name: service,
        on_rate_limit_exceeded: &handle_agent_rate_limit_exceeded/2
      })
      
      Foundation.Infrastructure.RateLimiter.setup(limiter_name, enhanced_config)
    end)
  end
  
  def check_rate_for_agent(agent_id, service_name) do
    limiter_name = "#{agent_id}_#{service_name}"
    
    result = Foundation.Infrastructure.RateLimiter.check_rate(limiter_name)
    
    # Track agent-specific rate limiting metrics
    Foundation.Telemetry.track_agent_rate_limit_check(agent_id, service_name, result)
    
    result
  end
  
  defp handle_agent_rate_limit_exceeded(limiter_name, current_rate) do
    [agent_id, service_name] = String.split(limiter_name, "_", parts: 2)
    
    # Publish rate limit exceeded event
    Foundation.Services.EventStore.publish(%Foundation.Types.Event{
      type: :agent_rate_limit_exceeded,
      source: String.to_atom(agent_id),
      data: %{
        service_name: service_name,
        current_rate: current_rate
      }
    })
  end
end

# foundation/lib/foundation/telemetry/agent_telemetry.ex
defmodule Foundation.Telemetry.AgentTelemetry do
  @moduledoc """
  Specialized telemetry for multi-agent systems.
  """
  
  # Track agent lifecycle events
  def track_agent_lifecycle(agent_id, event, metadata \\ %{}) do
    :telemetry.execute(
      [:foundation, :agent, :lifecycle],
      %{count: 1},
      %{agent_id: agent_id, event: event, metadata: metadata}
    )
  end
  
  # Track agent action execution
  def track_agent_action(agent_id, action_module, duration, result) do
    :telemetry.execute(
      [:foundation, :agent, :action],
      %{duration: duration, count: 1},
      %{
        agent_id: agent_id,
        action: action_module,
        result: result_type(result)
      }
    )
  end
  
  # Track agent coordination events
  def track_agent_coordination(agent_id, coordination_type, participants, result) do
    :telemetry.execute(
      [:foundation, :agent, :coordination],
      %{count: 1, participants: length(participants)},
      %{
        agent_id: agent_id,
        coordination_type: coordination_type,
        participants: participants,
        result: result_type(result)
      }
    )
  end
  
  # Track agent performance metrics
  def track_agent_performance(agent_id, metrics) do
    :telemetry.execute(
      [:foundation, :agent, :performance],
      metrics,
      %{agent_id: agent_id}
    )
  end
  
  # Track agent resource utilization
  def track_agent_resources(agent_id, resource_usage) do
    :telemetry.execute(
      [:foundation, :agent, :resources],
      resource_usage,
      %{agent_id: agent_id}
    )
  end
  
  # Track multi-agent system metrics
  def track_system_metrics(active_agents, coordination_events, system_health) do
    :telemetry.execute(
      [:foundation, :system, :metrics],
      %{
        active_agents: active_agents,
        coordination_events: coordination_events,
        system_health: system_health
      },
      %{timestamp: DateTime.utc_now()}
    )
  end
  
  defp result_type({:ok, _}), do: :success
  defp result_type({:error, _}), do: :error
  defp result_type(_), do: :unknown
end

# foundation/lib/foundation/telemetry/collectors/agent_collector.ex
defmodule Foundation.Telemetry.Collectors.AgentCollector do
  @moduledoc """
  Collects and aggregates agent metrics for analysis.
  """
  use GenServer
  
  def start_link(opts) do
    GenServer.start_link(__MODULE__, opts, name: __MODULE__)
  end
  
  def get_agent_metrics(agent_id) do
    GenServer.call(__MODULE__, {:get_agent_metrics, agent_id})
  end
  
  def get_system_metrics() do
    GenServer.call(__MODULE__, :get_system_metrics)
  end
  
  def init(_opts) do
    # Subscribe to agent telemetry events
    :telemetry.attach_many(
      "agent_collector",
      [
        [:foundation, :agent, :lifecycle],
        [:foundation, :agent, :action],
        [:foundation, :agent, :coordination],
        [:foundation, :agent, :performance],
        [:foundation, :agent, :resources]
      ],
      &handle_telemetry_event/4,
      %{}
    )
    
    # Aggregate metrics every 60 seconds
    :timer.send_interval(60_000, :aggregate_metrics)
    
    {:ok, %{
      agent_metrics: %{},
      system_metrics: %{},
      last_aggregation: DateTime.utc_now()
    }}
  end
  
  def handle_call({:get_agent_metrics, agent_id}, _from, state) do
    metrics = Map.get(state.agent_metrics, agent_id, %{})
    {:reply, metrics, state}
  end
  
  def handle_call(:get_system_metrics, _from, state) do
    {:reply, state.system_metrics, state}
  end
  
  def handle_info(:aggregate_metrics, state) do
    # Aggregate system-wide metrics
    system_metrics = aggregate_system_metrics(state.agent_metrics)
    
    # Track system metrics
    Foundation.Telemetry.AgentTelemetry.track_system_metrics(
      system_metrics.active_agents,
      system_metrics.coordination_events,
      system_metrics.system_health
    )
    
    new_state = %{state | 
      system_metrics: system_metrics,
      last_aggregation: DateTime.utc_now()
    }
    
    {:noreply, new_state}
  end
  
  defp handle_telemetry_event(event, measurements, metadata, _config) do
    GenServer.cast(__MODULE__, {:telemetry_event, event, measurements, metadata})
  end
  
  defp aggregate_system_metrics(agent_metrics) do
    active_agents = map_size(agent_metrics)
    
    total_actions = agent_metrics
    |> Enum.map(fn {_id, metrics} -> metrics[:actions_executed] || 0 end)
    |> Enum.sum()
    
    total_coordination_events = agent_metrics
    |> Enum.map(fn {_id, metrics} -> metrics[:coordination_events] || 0 end)
    |> Enum.sum()
    
    system_health = calculate_system_health(agent_metrics)
    
    %{
      active_agents: active_agents,
      total_actions: total_actions,
      coordination_events: total_coordination_events,
      system_health: system_health,
      timestamp: DateTime.utc_now()
    }
  end
  
  defp calculate_system_health(agent_metrics) do
    if map_size(agent_metrics) == 0 do
      1.0
    else
      healthy_agents = agent_metrics
      |> Enum.count(fn {_id, metrics} -> 
        (metrics[:health_status] || :healthy) == :healthy
      end)
      
      healthy_agents / map_size(agent_metrics)
    end
  end
end

# foundation/lib/foundation/services/agent_config_server.ex
defmodule Foundation.Services.AgentConfigServer do
  @moduledoc """
  Configuration management with agent-specific support and dynamic updates.
  """
  use GenServer
  
  def start_link(opts) do
    GenServer.start_link(__MODULE__, opts, name: __MODULE__)
  end
  
  # Get configuration for specific agent
  def get_agent_config(agent_id, key, default \\ nil) do
    GenServer.call(__MODULE__, {:get_agent_config, agent_id, key, default})
  end
  
  # Update configuration for specific agent
  def update_agent_config(agent_id, key, value) do
    GenServer.call(__MODULE__, {:update_agent_config, agent_id, key, value})
  end
  
  # Subscribe to configuration changes
  def subscribe_to_config_changes(agent_id, keys) do
    GenServer.call(__MODULE__, {:subscribe, agent_id, keys})
  end
  
  # Get global configuration
  def get_global_config(key, default \\ nil) do
    Foundation.Services.ConfigServer.get(key, default)
  end
  
  def init(opts) do
    {:ok, %{
      agent_configs: %{},
      subscribers: %{}
    }}
  end
  
  def handle_call({:get_agent_config, agent_id, key, default}, _from, state) do
    agent_config = Map.get(state.agent_configs, agent_id, %{})
    value = Map.get(agent_config, key, default)
    {:reply, value, state}
  end
  
  def handle_call({:update_agent_config, agent_id, key, value}, _from, state) do
    # Update agent configuration
    agent_config = Map.get(state.agent_configs, agent_id, %{})
    new_agent_config = Map.put(agent_config, key, value)
    new_configs = Map.put(state.agent_configs, agent_id, new_agent_config)
    
    # Notify subscribers
    notify_config_change(state.subscribers, agent_id, key, value)
    
    # Publish configuration change event
    Foundation.Services.EventStore.publish(%Foundation.Types.Event{
      type: :agent_config_updated,
      source: agent_id,
      data: %{key: key, value: value}
    })
    
    {:reply, :ok, %{state | agent_configs: new_configs}}
  end
  
  def handle_call({:subscribe, agent_id, keys}, {pid, _ref}, state) do
    # Monitor the subscribing process
    Process.monitor(pid)
    
    # Add subscription
    subscription = %{pid: pid, keys: keys}
    agent_subscribers = Map.get(state.subscribers, agent_id, [])
    new_agent_subscribers = [subscription | agent_subscribers]
    new_subscribers = Map.put(state.subscribers, agent_id, new_agent_subscribers)
    
    {:reply, :ok, %{state | subscribers: new_subscribers}}
  end
  
  def handle_info({:DOWN, _ref, :process, pid, _reason}, state) do
    # Remove subscriptions for terminated process
    new_subscribers = Enum.reduce(state.subscribers, %{}, fn {agent_id, subs}, acc ->
      filtered_subs = Enum.reject(subs, fn sub -> sub.pid == pid end)
      if length(filtered_subs) > 0 do
        Map.put(acc, agent_id, filtered_subs)
      else
        acc
      end
    end)
    
    {:noreply, %{state | subscribers: new_subscribers}}
  end
  
  defp notify_config_change(subscribers, agent_id, key, value) do
    agent_subscribers = Map.get(subscribers, agent_id, [])
    
    Enum.each(agent_subscribers, fn subscription ->
      if key in subscription.keys do
        send(subscription.pid, {:config_update, key, value})
      end
    end)
  end
end

# foundation/lib/foundation/types/agent_info.ex
defmodule Foundation.Types.AgentInfo do
  @moduledoc """
  Data structure for agent information and metadata.
  """
  
  defstruct [
    :agent_id,
    :pid,
    :agent_type,
    :capabilities,
    :coordination_variables,
    :resource_requirements,
    :health_status,
    :performance_metrics,
    :configuration,
    :created_at,
    :last_heartbeat,
    :version
  ]
  
  @type t :: %__MODULE__{
    agent_id: atom(),
    pid: pid(),
    agent_type: atom(),
    capabilities: [atom()],
    coordination_variables: [atom()],
    resource_requirements: map(),
    health_status: :healthy | :degraded | :unhealthy,
    performance_metrics: map(),
    configuration: map(),
    created_at: DateTime.t(),
    last_heartbeat: DateTime.t(),
    version: String.t()
  }
  
  def new(agent_id, pid, opts \\ []) do
    %__MODULE__{
      agent_id: agent_id,
      pid: pid,
      agent_type: opts[:agent_type],
      capabilities: opts[:capabilities] || [],
      coordination_variables: opts[:coordination_variables] || [],
      resource_requirements: opts[:resource_requirements] || %{},
      health_status: :healthy,
      performance_metrics: %{},
      configuration: opts[:configuration] || %{},
      created_at: DateTime.utc_now(),
      last_heartbeat: DateTime.utc_now(),
      version: opts[:version] || "1.0.0"
    }
  end
  
  def update_health(agent_info, health_status) do
    %{agent_info | 
      health_status: health_status,
      last_heartbeat: DateTime.utc_now()
    }
  end
  
  def update_performance_metrics(agent_info, metrics) do
    %{agent_info | performance_metrics: metrics}
  end
  
  def update_configuration(agent_info, key, value) do
    new_config = Map.put(agent_info.configuration, key, value)
    %{agent_info | configuration: new_config}
  end
end

# foundation/lib/foundation/types/coordination_event.ex
defmodule Foundation.Types.CoordinationEvent do
  @moduledoc """
  Data structure for agent coordination events.
  """
  
  defstruct [
    :event_id,
    :type,
    :coordinator,
    :participants,
    :data,
    :result,
    :started_at,
    :completed_at,
    :duration_ms
  ]
  
  @type t :: %__MODULE__{
    event_id: String.t(),
    type: atom(),
    coordinator: atom(),
    participants: [atom()],
    data: map(),
    result: {:ok, term()} | {:error, term()},
    started_at: DateTime.t(),
    completed_at: DateTime.t() | nil,
    duration_ms: non_neg_integer() | nil
  }
  
  def new(type, coordinator, participants, data \\ %{}) do
    %__MODULE__{
      event_id: generate_event_id(),
      type: type,
      coordinator: coordinator,
      participants: participants,
      data: data,
      started_at: DateTime.utc_now()
    }
  end
  
  def complete(event, result) do
    completed_at = DateTime.utc_now()
    duration_ms = DateTime.diff(completed_at, event.started_at, :millisecond)
    
    %{event | 
      result: result,
      completed_at: completed_at,
      duration_ms: duration_ms
    }
  end
  
  defp generate_event_id() do
    :crypto.strong_rand_bytes(16) |> Base.encode16(case: :lower)
  end
end

# These continue to work exactly as before
Foundation.ProcessRegistry.register(name, pid)
Foundation.Infrastructure.CircuitBreaker.execute(name, function)
Foundation.Services.ConfigServer.get(key)
Foundation.Telemetry.track_event(event, measurements)