# Existing Foundation patterns align perfectly with perimeter zones
Foundation.Infrastructure    # Maps to Zone 4: Core Engine
Foundation.Services         # Maps to Zone 3: Coupling Zones  
Foundation.Registry         # Maps to Zone 2: Internal Perimeters
JidoFoundation.Bridge      # Maps to Zone 1: External Perimeter

defmodule Foundation.Perimeter do
  @moduledoc """
  Four-Zone Architecture implementation optimized for Foundation
  """
  
  # Zone 1: External Perimeter - Maximum validation
  defmacro external_contract(name, do: block) do
    quote do
      def unquote(name)(params) do
        with {:ok, validated} <- validate_external(params, unquote(block)),
             {:ok, sanitized} <- sanitize_input(validated),
             :ok <- audit_external_access(sanitized) do
          {:ok, sanitized}
        else
          error -> handle_external_error(error)
        end
      end
    end
  end
  
  # Zone 2: Strategic Boundaries - Service interfaces
  defmacro strategic_boundary(service_name, do: block) do
    quote do
      def unquote(service_name)(params) do
        case validate_service_boundary(params, unquote(block)) do
          {:ok, validated} -> {:ok, validated}
          error -> handle_service_error(error)
        end
      end
    end
  end
  
  # Zone 3: Productive Coupling - Direct calls
  def productive_call(module, function, args) when is_atom(module) do
    # Direct function calls with minimal overhead
    apply(module, function, args)
  end
  
  # Zone 4: Core Engine - Zero validation
  defmacro core_execute(do: block) do
    quote do
      # Maximum performance, trusted execution
      unquote(block)
    end
  end
end

defmodule Foundation.Perimeter.External do
  use Foundation.Perimeter
  
  # DSPEx program creation from external users
  external_contract :create_dspex_program do
    field :name, :string, required: true, length: 1..100
    field :description, :string, length: 0..1000
    field :schema_fields, {:list, :map}, 
      validate: &Foundation.Schema.validate_fields/1
    field :optimization_config, :map,
      validate: &Foundation.Variable.Space.validate_config/1
  end
  
  # Jido agent deployment from external requests
  external_contract :deploy_jido_agent do
    field :agent_spec, :map, validate: &validate_jido_spec/1
    field :clustering_config, :map, validate: &validate_clustering/1
    field :placement_strategy, :atom, 
      values: [:load_balanced, :capability_matched]
  end
end

defmodule Foundation.Perimeter.Services do
  use Foundation.Perimeter
  
  # MABEAM coordination boundaries
  strategic_boundary :coordinate_agents do
    field :agent_group, {:list, :pid}, validate: &all_alive?/1
    field :coordination_pattern, :atom,
      values: [:consensus, :pipeline, :map_reduce, :auction]
    field :timeout, :integer, range: 1000..300_000
  end
  
  # Registry service boundaries
  strategic_boundary :register_clustered_agent do
    field :agent_id, :string, format: :uuid
    field :agent_pid, :pid, validate: &Process.alive?/1
    field :capabilities, {:list, :atom}
    field :metadata, :map
  end
end

defmodule Foundation.Perimeter.JidoCoupling do
  use Foundation.Perimeter
  
  # Direct Jido agent coordination (trusted)
  def coordinate_jido_agent_direct(agent_pid, coordination_spec) do
    productive_call(Jido.Agent, :coordinate, [agent_pid, coordination_spec])
  end
  
  # Direct signal routing (trusted)
  def route_jido_signal_direct(signal, target_pids) do
    productive_call(Jido.Signal.Bus, :broadcast, [signal, target_pids])
  end
  
  # Direct state updates (trusted)
  def update_jido_state_direct(agent_pid, state_update) do
    productive_call(Jido.Agent, :set, [agent_pid, state_update])
  end
end

defmodule Foundation.Perimeter.Core do
  use Foundation.Perimeter
  
  # High-frequency signal routing
  def route_signals_fast(signals, target_map) do
    core_execute do
      Enum.each(signals, fn signal ->
        targets = Map.get(target_map, signal.type, [])
        Enum.each(targets, &send(&1, signal))
      end)
    end
  end
  
  # SIMBA optimization hot path
  def simba_step_fast(population, evaluation_fn, config) do
    core_execute do
      population
      |> mutate_population_unsafe(config.mutation_rate)
      |> evaluate_fitness_unsafe(evaluation_fn)
      |> select_survivors_unsafe()
    end
  end
end

# Refactor existing JidoFoundation.Bridge
defmodule JidoFoundation.Bridge do
  use Foundation.Perimeter.Services
  
  # Zone 2: Strategic boundary for agent registration
  def register_agent(agent_pid, opts) do
    case strategic_boundary(:register_clustered_agent, opts) do
      {:ok, validated_opts} ->
        # Zone 3: Productive coupling to Foundation services
        Foundation.Perimeter.JidoCoupling.register_agent_direct(
          agent_pid, 
          validated_opts
        )
      error -> error
    end
  end
  
  # Zone 4: Core performance for hot paths
  def emit_signal_fast(signal, targets) do
    Foundation.Perimeter.Core.route_signals_fast([signal], %{signal.type => targets})
  end
end