# Zone 1: External Perimeter - HTTP/API boundaries
defmodule Foundation.ExternalAPI do
  use Perimeter.Zone1
  
  defcontract api_request :: %{
    required(:action) => atom(),
    required(:params) => map(),
    optional(:context) => map()
  }
  
  @guard input: api_request(),
         rate_limiting: true,
         authentication: true
  def handle_request(request) do
    # Once validated, no more validation needed
    Foundation.Internal.route(request)
  end
end

# Zone 2: Strategic Internal Boundaries - Major subsystem interfaces
defmodule Foundation.AgentInterface do
  use Perimeter.Zone2
  
  defcontract agent_instruction :: %{
    required(:agent_id) => String.t(),
    required(:action) => atom(),
    required(:params) => map()
  }
  
  @guard input: agent_instruction(),
         cache_validation: true
  def execute_instruction(instruction) do
    # Transition to coupling zone
    Foundation.Agents.Core.execute(instruction)
  end
end

# Zone 3: Coupling Zone - Foundation ↔ Jido integration
defmodule Foundation.Agents.Core do
  # NO validation - productive coupling
  alias Foundation.{Registry, Telemetry, CircuitBreaker}
  alias JidoSystem.{Agents, TaskManager}
  
  def execute(instruction) do
    # Direct function calls, shared data structures
    agent = Registry.get!(instruction.agent_id)
    result = Agents.execute_action(agent, instruction)
    Telemetry.emit(:agent_action, result)
  end
end

# Zone 4: Core Engine - Pure computation
defmodule Foundation.OptimizationEngine do
  # Maximum Elixir flexibility
  def optimize(variables) do
    # Hot code swapping, metaprogramming, dynamic compilation
    variables |> generate_code() |> compile() |> execute()
  end
end

# Current: Too many boundaries
defprotocol Foundation.Registry do
  def register(registry, key, value, metadata)
  def lookup(registry, key)
  def find_by_attribute(registry, attribute, value)
end

# Multiple implementations: ETS, distributed, etc.
# Each with validation overhead
# Complex query API for simple agent discovery

# Current: Excessive delegation
Foundation.Bridge.AgentManager.register_agent(agent)
  -> Foundation.Protocols.Registry.register(...)
    -> Foundation.Registry.ETS.register(...)
      -> :ets.insert(...)

# 4 layers of function calls for simple operation

# Current: Validation at every boundary
HTTP Request
  |> validate_at_phoenix_controller()    # 5ms
  |> validate_at_bridge_layer()          # 3ms
  |> validate_at_agent_manager()         # 2ms
  |> validate_at_registry_protocol()     # 1ms
# Total: 11ms overhead per request

# Perimeter: One validation point
defmodule Foundation.ExternalPerimeter do
  use Perimeter.Zone1
  
  # Comprehensive validation once
  defcontract foundation_request :: %{
    required(:type) => :agent_action | :pipeline_execute | :variable_update,
    required(:payload) => request_payload(),
    optional(:context) => execution_context()
  }
  
  @guard input: foundation_request(),
         comprehensive_validation: true
  def handle_request(request) do
    # All subsequent processing trusts this validation
    InternalRouter.route(request)
  end
end

# Perimeter: Strategic boundaries only
defmodule Foundation.AgentSubsystem do
  use Perimeter.Zone2
  
  # Only validate what matters for subsystem contracts
  defcontract agent_operation :: %{
    required(:agent_id) => agent_id(),
    required(:operation) => operation_spec()
  }
  
  @guard input: agent_operation()
  def execute_operation(op) do
    # Enter coupling zone - no more validation
    AgentCore.execute(op)
  end
end

# Perimeter: Zero validation overhead
defmodule Foundation.AgentCore do
  # Direct integration - no boundaries
  alias Foundation.{Registry, Telemetry, CircuitBreaker}
  alias JidoSystem.{Agents, TaskManager, CoordinatorAgent}
  
  def execute(operation) do
    # Direct function calls - maximum performance
    agent = Registry.lookup!(operation.agent_id)
    
    # Shared data structures
    context = %{
      agent: agent,
      operation: operation,
      metadata: build_metadata()
    }
    
    # Direct delegation to Jido
    result = Agents.execute(context)
    
    # Direct telemetry
    Telemetry.emit(:agent_executed, result)
    
    result
  end
end

# Typical agent action execution:
HTTP Request (100ms total):
  Phoenix validation:           5ms
  Bridge layer validation:      3ms  
  Agent manager validation:     2ms
  Registry protocol overhead:   1ms
  Circuit breaker checks:       2ms
  Telemetry overhead:           1ms
  Actual business logic:       86ms
  
# Validation overhead: 14% of total request time

# With Four-Zone Architecture:
HTTP Request (92ms total):
  Zone 1 perimeter validation:  5ms
  Zone 2 strategic validation:  1ms
  Zone 3 coupling (zero cost):  0ms
  Zone 4 core engine:          86ms
  
# Validation overhead: 6.5% of total request time
# 8% performance improvement

# Current: Multiple data transformations
external_request
|> Phoenix.transform_params()        # Copy 1
|> Bridge.normalize()                # Copy 2  
|> AgentManager.prepare()            # Copy 3
|> Registry.format_for_storage()     # Copy 4
# 5x memory usage

# Perimeter: Single transformation
external_request
|> Perimeter.validate_and_transform()  # Copy 1
|> pass_to_coupling_zone()            # Reference passing
# 1x memory usage (80% memory reduction)

# Create unified external interface
defmodule Foundation.API do
  use Perimeter.Zone1
  
  # Single comprehensive contract for all external requests
  defcontract foundation_request :: %{
    required(:action) => foundation_action(),
    required(:target) => target_spec(),
    required(:payload) => dynamic_payload(),
    optional(:context) => request_context()
  }
  
  defcontract foundation_action :: 
    :agent_create | :agent_execute | :agent_query |
    :pipeline_create | :pipeline_execute |
    :variable_update | :variable_optimize |
    :system_health | :system_metrics
  
  @guard input: foundation_request(),
         authentication: true,
         rate_limiting: true,
         comprehensive_logging: true
  def handle_request(request) do
    # Route to Zone 2 based on action
    case request.action do
      action when action in [:agent_create, :agent_execute, :agent_query] ->
        Foundation.AgentSubsystem.handle(request)
      action when action in [:pipeline_create, :pipeline_execute] ->
        Foundation.PipelineSubsystem.handle(request)
      action when action in [:variable_update, :variable_optimize] ->
        Foundation.VariableSubsystem.handle(request)
      action when action in [:system_health, :system_metrics] ->
        Foundation.SystemSubsystem.handle(request)
    end
  end
end

# Replace current Bridge pattern with strategic boundaries
defmodule Foundation.AgentSubsystem do
  use Perimeter.Zone2
  
  # Only validate agent-specific contracts
  defcontract agent_request :: %{
    required(:agent_id) => String.t(),
    required(:action) => agent_action(),
    required(:params) => map(),
    validate(:agent_authorization)
  }
  
  @guard input: agent_request(),
         cache_validation: true,
         fast_path: [:agent_id]
  def handle(request) do
    # Enter coupling zone
    Foundation.AgentCore.execute(request)
  end
  
  # Strategic validation only
  defp agent_authorization(request) do
    if Foundation.Registry.exists?(request.agent_id) do
      :ok
    else
      {:error, :agent_not_found}
    end
  end
end

# Eliminate protocol abstractions in coupling zones
defmodule Foundation.AgentCore do
  # Direct imports - no protocol indirection
  alias Foundation.Registry.ETS, as: Registry
  alias Foundation.Telemetry.Events, as: Telemetry
  alias Foundation.CircuitBreaker.Simple, as: CircuitBreaker
  
  # Direct imports from Jido
  alias JidoSystem.Agents.FoundationAgent
  alias JidoSystem.Agents.TaskAgent
  alias JidoSystem.Agents.CoordinatorAgent
  
  def execute(request) do
    # Direct ETS access - no protocol overhead
    agent_data = Registry.lookup_agent!(request.agent_id)
    
    # Direct Jido integration
    result = case agent_data.type do
      :foundation -> FoundationAgent.execute_action(agent_data, request.action, request.params)
      :task -> TaskAgent.execute_action(agent_data, request.action, request.params)
      :coordinator -> CoordinatorAgent.execute_action(agent_data, request.action, request.params)
    end
    
    # Direct telemetry emission
    Telemetry.emit_agent_action(agent_data.id, request.action, result)
    
    result
  end
end

# Enable maximum Elixir flexibility
defmodule Foundation.OptimizationCore do
  # No validation, no boundaries, maximum performance
  
  def optimize_variables(variables, constraints, objective_fn) do
    # Can use any Elixir feature without restriction
    variables
    |> compile_optimization_strategy()
    |> generate_candidate_solutions()
    |> parallel_evaluate(objective_fn)
    |> extract_pareto_optimal()
  end
  
  # Dynamic code generation for optimization
  defp compile_optimization_strategy(variables) do
    strategy_code = generate_strategy_code(variables)
    
    # Hot code swapping
    Code.eval_string(strategy_code)
    |> elem(0)
  end
  
  # Runtime strategy modification
  def update_strategy(new_strategy_fn) do
    # Can modify running optimization algorithms
    Registry.update_value(StrategyRegistry, :current, fn _ -> new_strategy_fn end)
  end
end

# Before: Complex delegation hierarchy
HTTP Request
  |> Phoenix.Controller
    |> Foundation.Bridge.AgentManager
      |> Foundation.Protocols.Registry
        |> Foundation.Registry.ETS
          |> JidoSystem.Agents.FoundationAgent

# After: Clear zone transitions
HTTP Request
  |> Foundation.API (Zone 1: Comprehensive validation)
    |> Foundation.AgentSubsystem (Zone 2: Strategic validation)
      |> Foundation.AgentCore (Zone 3: Direct coupling)
        |> JidoSystem.Agents.FoundationAgent

# Before: Debug across multiple boundaries
def debug_agent_issue(agent_id) do
  # Must understand 5+ validation layers
  # Different error formats at each layer
  # Complex stacktraces across protocols
end

# After: Single validation point
def debug_agent_issue(agent_id) do
  case Foundation.API.validate_agent_request(request) do
    {:ok, validated} ->
      # Direct function calls, clear stacktraces
      Foundation.AgentCore.execute(validated)
    {:error, reason} ->
      # Single error format, comprehensive details
      {:error, reason}
  end
end

# Before: Must mock multiple protocol layers
defmodule AgentManagerTest do
  test "agent creation" do
    # Mock Foundation.Registry protocol
    # Mock Foundation.CircuitBreaker protocol
    # Mock Foundation.Telemetry protocol
    # Set up complex test harness
  end
end

# After: Test perimeter once, business logic separately
defmodule PerimeterTest do
  test "validates agent requests" do
    assert {:ok, _} = Foundation.API.validate(valid_request)
    assert {:error, _} = Foundation.API.validate(invalid_request)
  end
end

defmodule AgentCoreTest do
  test "executes agent actions" do
    # Use real validated data directly
    result = Foundation.AgentCore.execute(valid_agent_request)
    assert result.success
  end
end

# Add Perimeter to Foundation
defp deps do
  [
    {:perimeter, path: "../perimeter"},
    # ... existing deps
  ]
end

# Create Foundation.Perimeter wrapper
defmodule Foundation.Perimeter do
  use Perimeter
  
  # Foundation-specific contract helpers
  defmacro agent_contract(name, do: block) do
    # Enhanced agent-specific validations
  end
  
  defmacro pipeline_contract(name, do: block) do
    # Enhanced pipeline-specific validations
  end
end