# Multiple critical calls to undefined modules
UUID.uuid4()  # Will crash immediately - no UUID dependency

defmodule Mabeam.Agent.Behaviour do
  @callback init(agent(), config()) :: {:ok, agent()} | {:error, term()}
  @callback handle_action(agent(), action(), params()) :: action_result()
  @callback handle_event(agent(), event()) :: {:ok, agent()} | {:error, term()}
end

# Clean agent implementation pattern
defmodule MyAgent do
  use Mabeam.Agent
  
  @impl true
  def init(agent, _config) do
    {:ok, %{agent | state: %{counter: 0}}}
  end
  
  @impl true
  def handle_action(agent, :increment, _params) do
    new_state = %{agent.state | counter: agent.state.counter + 1}
    {:ok, %{agent | state: new_state}, %{result: :incremented}}
  end
end

defmodule Foundation.Agent.Enhanced do
  @moduledoc """
  Enhanced agent behavior that bridges Jido excellence with Foundation infrastructure
  """
  
  @callback init(Jido.Agent.t(), config()) :: {:ok, Jido.Agent.t()} | {:error, term()}
  @callback handle_cluster_action(Jido.Agent.t(), action(), params()) :: cluster_result()
  @callback handle_coordination_event(Jido.Agent.t(), event()) :: {:ok, Jido.Agent.t()}
  
  defmacro __using__(opts) do
    quote do
      use Jido.Agent, unquote(opts)  # Preserve Jido excellence
      @behaviour Foundation.Agent.Enhanced  # Add Foundation capabilities
      
      # Override mount to add Foundation integration
      def mount(agent, opts) do
        # Standard Jido mount first
        {:ok, agent} = super(agent, opts)
        
        # Add Foundation clustering capabilities
        case __MODULE__.init(agent, opts) do
          {:ok, enhanced_agent} ->
            Foundation.ClusterRegistry.register(enhanced_agent)
            {:ok, enhanced_agent}
          error -> error
        end
      end
    end
  end
end

defstruct [
  agents: %{},  # agent_id => agent_data
  indices: %{
    by_type: %{},       # atom() => MapSet.t(agent_id())
    by_capability: %{}, # atom() => MapSet.t(agent_id())
    by_node: %{}        # node() => MapSet.t(agent_id())
  }
]

# Efficient lookup patterns
def find_by_capability(state, capability) do
  agent_ids = get_in(state.indices, [:by_capability, capability]) || MapSet.new()
  Enum.map(agent_ids, &Map.get(state.agents, &1))
end

defmodule Foundation.DistributedRegistry.Indices do
  @moduledoc """
  Multi-index registry for efficient agent discovery across cluster
  """
  
  defstruct [
    agents: %{},
    local_indices: %{
      by_capability: %{},
      by_jido_skill: %{},      # Index by Jido skills
      by_action_type: %{}      # Index by Jido action types
    },
    cluster_indices: %{
      by_node: %{},
      by_load: %{},            # Performance-based indexing
      by_availability: %{}     # Health-based indexing
    }
  ]
  
  def find_capable_agents(capability) do
    # Combine local Jido capabilities with Foundation cluster awareness
    local_agents = find_local_by_capability(capability)
    cluster_agents = find_cluster_by_capability(capability)
    
    # Return agents sorted by availability and load
    sort_by_optimal_placement(local_agents ++ cluster_agents)
  end
end

defp match_wildcard_pattern(pattern, event_type_string) do
  case String.split(pattern, "*", parts: 2) do
    [prefix] -> 
      String.starts_with?(event_type_string, prefix)
    [prefix, suffix] -> 
      String.starts_with?(event_type_string, prefix) and 
      String.ends_with?(event_type_string, suffix)
  end
end

# Fast pattern subscription
def subscribe(event_pattern) do
  # No regex compilation overhead
  # O(1) pattern matching during event dispatch
end

defmodule Foundation.EventBus.PatternMatcher do
  @moduledoc """
  Efficient pattern matching for Jido signals across cluster
  """
  
  def match_signal_pattern(pattern, %Jido.Signal{type: signal_type}) do
    # Extend MABEAM's efficient pattern matching for Jido signals
    case String.split(pattern, "*", parts: 2) do
      [prefix] -> 
        String.starts_with?(signal_type, prefix)
      [prefix, suffix] -> 
        String.starts_with?(signal_type, prefix) and 
        String.ends_with?(signal_type, suffix)
    end
  end
  
  def route_signal_across_cluster(%Jido.Signal{} = signal, subscription_patterns) do
    # Use efficient pattern matching to route Jido signals across nodes
    matching_patterns = Enum.filter(subscription_patterns, fn {pattern, _subscribers} ->
      match_signal_pattern(pattern, signal)
    end)
    
    # Route using Foundation's distributed signaling
    Foundation.DistributedSignaling.route_to_patterns(signal, matching_patterns)
  end
end

defp update_lifecycle_state(agent, new_state) do
  %{agent | 
    lifecycle: new_state,
    updated_at: DateTime.utc_now(),
    version: agent.version + 1
  }
end

# Immutable state transitions
def transition_agent_state(agent, transition_spec) do
  case validate_transition(agent.lifecycle, transition_spec.target) do
    :ok -> 
      {:ok, update_lifecycle_state(agent, transition_spec.target)}
    {:error, reason} -> 
      {:error, {:invalid_transition, reason}}
  end
end

defmodule Foundation.Agent.StateManager do
  @moduledoc """
  Enhanced state management for Jido agents with clustering support
  """
  
  def update_agent_state(%Jido.Agent{} = agent, state_update) do
    # Combine Jido's excellent state validation with Foundation's versioning
    case Jido.Agent.set(agent, state_update) do
      {:ok, updated_agent} ->
        enhanced_agent = %{updated_agent | 
          cluster_metadata: %{
            version: (agent.cluster_metadata[:version] || 0) + 1,
            updated_at: DateTime.utc_now(),
            node: Node.self()
          }
        }
        
        # Replicate across cluster if needed
        Foundation.StateReplication.replicate_if_critical(enhanced_agent)
        
        {:ok, enhanced_agent}
        
      error -> error
    end
  end
end

# MABEAM: 90+ line handle_call function - violates OTP best practices
def handle_call({:complex_operation, params}, from, state) do
  # 90+ lines of complex logic mixing concerns
end

# Better: Break into focused functions
def handle_call({:register_agent, agent}, _from, state) do
  case register_agent_internal(agent, state) do
    {:ok, new_state} -> {:reply, :ok, new_state}
    {:error, reason} -> {:reply, {:error, reason}, state}
  end
end

# MABEAM: Multiple error pattern styles
{:error, "string reason"}
{:error, :atom_reason}
{:error, {:tuple, :reason}}

# Better: Consistent error patterns
{:error, {:registration_failed, reason}}
{:error, {:lookup_failed, :not_found}}

# MABEAM: No specs on critical functions
def critical_function(complex_params) do
  # Implementation
end

# Better: Proper type specifications
@spec register_agent(agent_spec(), registry_state()) :: 
  {:ok, registry_state()} | {:error, registration_error()}