# Current bottleneck (mabeam/economics.ex)
def calculate_resource_allocation(agents, resources) do
  # Multiple synchronous calls creating serialization
  Enum.map(agents, fn agent ->
    GenServer.call(agent, :get_resource_needs)  # Bottleneck!
  end)
end

# Optimized version
def calculate_resource_allocation_async(agents, resources) do
  # Parallel resource need gathering
  tasks = Enum.map(agents, fn agent ->
    Task.async(fn -> GenServer.call(agent, :get_resource_needs) end)
  end)
  
  # Collect results asynchronously
  resource_needs = Task.await_many(tasks, 5000)
  
  # Delegate computation to Task
  Task.async(fn -> 
    compute_optimal_allocation(resource_needs, resources)
  end)
end

# Current bottleneck (mabeam/coordination.ex)
def broadcast_consensus_proposal(proposal, agents) do
  Enum.each(agents, fn agent ->
    GenServer.call(agent, {:consensus_proposal, proposal})  # Serialized!
  end)
end

# Optimized version  
def broadcast_consensus_proposal_async(proposal, agents) do
  # Parallel proposal broadcasting
  Enum.each(agents, fn agent ->
    GenServer.cast(agent, {:consensus_proposal, proposal})  # Async!
  end)
  
  # Use separate collector for responses
  start_consensus_collector(proposal.id, length(agents))
end

# Current bottleneck (Foundation services)
defmodule Foundation.ProcessRegistry do
  # All reads go through GenServer call
  def lookup(namespace, service) do
    GenServer.call(__MODULE__, {:lookup, {namespace, service}})  # Bottleneck!
  end
end

# Optimized CQRS pattern
defmodule Foundation.ProcessRegistry do
  # Reads from ETS (fast, concurrent)
  def lookup(namespace, service) do
    case :ets.lookup(:process_registry_read, {namespace, service}) do
      [{_, pid, metadata}] -> {:ok, pid}
      [] -> :error
    end
  end
  
  # Writes through GenServer (consistency)
  def register(namespace, service, pid, metadata) do
    GenServer.call(__MODULE__, {:register, {namespace, service}, pid, metadata})
  end
  
  # GenServer maintains ETS read table
  def handle_call({:register, key, pid, metadata}, _from, state) do
    # Update ETS for fast reads
    :ets.insert(:process_registry_read, {key, pid, metadata})
    # Update backend for persistence
    {:ok, new_state} = backend_register(state, key, pid, metadata)
    {:reply, :ok, new_state}
  end
end

# Current: Individual variable updates
def update_agent_variable(agent_id, variable, value) do
  case get_agent_pid(agent_id) do
    {:ok, pid} -> GenServer.call(pid, {:update_variable, variable, value})  # Per-variable call
    error -> error
  end
end

# Optimized: Batched updates
def update_agent_variables_batch(agent_id, variable_updates) do
  case get_agent_pid(agent_id) do
    {:ok, pid} -> GenServer.cast(pid, {:update_variables_batch, variable_updates})  # Async batch
    error -> error
  end
end

def broadcast_variable_updates_batch(variable_updates) do
  agents = get_all_active_agents()
  
  # Parallel broadcasting
  Task.async(fn ->
    Enum.each(agents, fn agent_pid ->
      GenServer.cast(agent_pid, {:update_variables_batch, variable_updates})
    end)
  end)
end

# Optimized agent spawning
defmodule MABEAM.AgentPool do
  use GenServer
  
  def init(_opts) do
    # Pre-spawn agent pool for faster task assignment
    pool = spawn_agent_pool(10)  # 10 ready agents
    {:ok, %{pool: pool, active: %{}}}
  end
  
  def get_agent(agent_type) do
    GenServer.call(__MODULE__, {:get_agent, agent_type})
  end
  
  def handle_call({:get_agent, agent_type}, _from, state) do
    case get_pooled_agent(state.pool, agent_type) do
      {:ok, agent_pid, new_pool} ->
        new_state = %{state | 
          pool: new_pool,
          active: Map.put(state.active, agent_pid, agent_type)
        }
        {:reply, {:ok, agent_pid}, new_state}
        
      :pool_empty ->
        # Spawn new agent if pool empty
        {:ok, agent_pid} = MABEAM.AgentSupervisor.start_agent(agent_type)
        {:reply, {:ok, agent_pid}, state}
    end
  end
end

# Replace manual timing with Benchee
defmodule Foundation.PerformanceBenchmarks do
  use ExUnit.Case
  
  @tag :performance
  test "agent coordination latency SLO" do
    agents = setup_test_agents(100)
    
    # Statistical benchmarking with Benchee
    Benchee.run(%{
      "variable_update_broadcast" => fn ->
        MABEAM.Coordination.broadcast_variable_update(:learning_rate, 0.01)
      end,
      "consensus_proposal" => fn ->
        MABEAM.Coordination.propose_variable_change(:batch_size, 128)
      end
    }, 
    time: 10,
    memory_time: 2,
    formatters: [{Benchee.Formatters.Console, extended_statistics: true}]
    )
    
    # Assert SLOs based on statistical results
    assert_slo("variable_update_broadcast", %{
      p99_latency_ms: 50,      # 99th percentile < 50ms
      mean_latency_ms: 10,     # Mean < 10ms
      throughput_ops: 1000     # > 1000 ops/sec
    })
  end
end

defmodule Foundation.SLOValidator do
  def assert_slo(operation, slo_config) do
    results = get_benchmark_results(operation)
    
    # Validate 99th percentile latency
    p99_ms = results.percentiles[99] / 1_000_000  # Convert to ms
    assert p99_ms < slo_config.p99_latency_ms, 
      "P99 latency #{p99_ms}ms exceeds SLO #{slo_config.p99_latency_ms}ms"
    
    # Validate mean latency
    mean_ms = results.average / 1_000_000
    assert mean_ms < slo_config.mean_latency_ms,
      "Mean latency #{mean_ms}ms exceeds SLO #{slo_config.mean_latency_ms}ms"
    
    # Validate throughput
    ops_per_sec = 1_000_000_000 / results.average
    assert ops_per_sec > slo_config.throughput_ops,
      "Throughput #{ops_per_sec} ops/sec below SLO #{slo_config.throughput_ops}"
  end
end

# Replace global memory measurements
defmodule Foundation.MemoryMonitor do
  def measure_process_memory_growth(process_name, workload_fn, iterations \\ 100) do
    # Get initial process memory
    {:ok, pid} = Foundation.ProcessRegistry.lookup(:production, process_name)
    {:memory, initial_memory} = Process.info(pid, :memory)
    
    # Force GC before measurement
    :erlang.garbage_collect(pid)
    Process.sleep(10)  # Allow GC to complete
    {:memory, baseline_memory} = Process.info(pid, :memory)
    
    # Run workload
    for _ <- 1..iterations do
      workload_fn.(pid)
    end
    
    # Force GC after workload
    :erlang.garbage_collect(pid)
    Process.sleep(10)
    {:memory, final_memory} = Process.info(pid, :memory)
    
    memory_growth = final_memory - baseline_memory
    growth_per_iteration = memory_growth / iterations
    
    %{
      baseline_memory: baseline_memory,
      final_memory: final_memory,
      total_growth: memory_growth,
      growth_per_iteration: growth_per_iteration,
      iterations: iterations
    }
  end
end

# Property-based memory testing
defmodule Foundation.MemoryProperties do
  use ExUnit.Case
  use ExUnitProperties
  
  property "ProcessRegistry memory usage remains stable under load" do
    check all(
      operation_count <- integer(1..1000),
      max_runs: 10
    ) do
      memory_stats = Foundation.MemoryMonitor.measure_process_memory_growth(
        :process_registry,
        fn _pid -> 
          Foundation.ProcessRegistry.register(:test, :temp_service, self())
          Foundation.ProcessRegistry.unregister(:test, :temp_service)
        end,
        operation_count
      )
      
      # Assert memory growth per operation is bounded
      assert memory_stats.growth_per_iteration < 1024  # < 1KB per operation
      
      # Assert total memory growth is reasonable
      max_growth = operation_count * 1024  # 1KB per operation max
      assert memory_stats.total_growth < max_growth
    end
  end
end

# Current anti-pattern
test "agent coordination eventually completes" do
  agents = start_test_agents(5)
  MABEAM.Coordination.start_consensus(:learning_rate, 0.01)
  
  Process.sleep(1000)  # Non-deterministic!
  
  assert consensus_reached?(:learning_rate)
end

# Optimized event-driven pattern
test "agent coordination completes deterministically" do
  agents = start_test_agents(5)
  
  # Subscribe to consensus events
  :ok = MABEAM.Coordination.subscribe_to_consensus_events(self())
  
  # Start consensus
  MABEAM.Coordination.start_consensus(:learning_rate, 0.01)
  
  # Wait for specific event - deterministic
  assert_receive {:consensus_reached, :learning_rate, 0.01}, 5000
  
  # Verify final state
  assert consensus_reached?(:learning_rate)
end

# Pattern: Use monitors instead of polling
test "agent crash detection is immediate" do
  {:ok, agent_pid} = MABEAM.AgentRegistry.start_agent(:test_agent)
  
  # Monitor for crash notification
  ref = Process.monitor(agent_pid)
  
  # Crash the agent
  Process.exit(agent_pid, :kill)
  
  # Deterministic crash detection
  assert_receive {:DOWN, ^ref, :process, ^agent_pid, :killed}, 1000
  
  # Verify registry updated
  assert {:error, :not_found} = MABEAM.AgentRegistry.get_agent_pid(:test_agent)
end

# Current race condition
test "service becomes available" do
  start_service(:config_server)
  Process.sleep(100)  # Race condition!
  assert service_available?(:config_server)
end

# Deterministic service startup
test "service availability is deterministic" do
  # Start service and wait for ready signal
  {:ok, service_pid} = start_service_monitored(:config_server)
  
  # Service sends ready notification when fully initialized
  assert_receive {:service_ready, :config_server, ^service_pid}, 5000
  
  # Now safe to test availability
  assert service_available?(:config_server)
end

defp start_service_monitored(service_name) do
  # Start service with explicit ready notification
  {:ok, pid} = Foundation.ConfigServer.start_link([notify_ready: self()])
  
  # Register in test namespace
  Foundation.ProcessRegistry.register(:test, service_name, pid)
  {:ok, pid}
end

# Optimized ETS lifecycle management
defmodule Foundation.OptimizedETS do
  def create_managed_table(name, opts) do
    # Create table with automatic cleanup
    table = :ets.new(name, [:named_table, :public | opts])
    
    # Register cleanup process
    cleanup_pid = spawn_link(fn -> 
      receive
        {:cleanup, ^table} -> cleanup_table(table)
      end
    end)
    
    # Store cleanup reference
    :persistent_term.put({:ets_cleanup, table}, cleanup_pid)
    table
  end
  
  def cleanup_table(table) do
    case :ets.info(table) do
      :undefined -> :ok
      _ -> 
        :ets.delete(table)
        :persistent_term.erase({:ets_cleanup, table})
    end
  end
end

# Agent process memory management
defmodule MABEAM.Agents.BaseAgent do
  use GenServer
  
  def init(opts) do
    # Set process memory limits
    max_memory = Keyword.get(opts, :max_memory, 50_000_000)  # 50MB default
    Process.flag(:max_heap_size, %{
      size: max_memory,
      kill: true,
      error_logger: true
    })
    
    # Set process priority
    priority = Keyword.get(opts, :priority, :normal)
    Process.flag(:priority, priority)
    
    # Initialize with memory monitoring
    state = %{
      agent_id: opts[:agent_id],
      memory_limit: max_memory,
      last_gc: System.monotonic_time(),
      gc_interval: 30_000  # 30 seconds
    }
    
    schedule_memory_check(state.gc_interval)
    {:ok, state}
  end
  
  def handle_info(:memory_check, state) do
    {:memory, current_memory} = Process.info(self(), :memory)
    
    if current_memory > state.memory_limit * 0.8 do  # 80% threshold
      :erlang.garbage_collect(self())
      Logger.warn("Agent #{state.agent_id} triggered GC: #{current_memory} bytes")
    end
    
    schedule_memory_check(state.gc_interval)
    {:noreply, state}
  end
end

# Optimized connection pooling
defmodule Foundation.ConnectionPool do
  use GenServer
  
  def init(opts) do
    pool_size = Keyword.get(opts, :pool_size, 10)
    max_overflow = Keyword.get(opts, :max_overflow, 5)
    
    # Create initial pool
    pool = create_connection_pool(pool_size)
    
    state = %{
      pool: pool,
      pool_size: pool_size,
      max_overflow: max_overflow,
      overflow_count: 0,
      waiting: :queue.new()
    }
    
    {:ok, state}
  end
  
  def handle_call(:get_connection, from, state) do
    case get_available_connection(state.pool) do
      {:ok, conn, new_pool} ->
        new_state = %{state | pool: new_pool}
        {:reply, {:ok, conn}, new_state}
        
      :pool_empty when state.overflow_count < state.max_overflow ->
        # Create overflow connection
        {:ok, conn} = create_connection()
        new_state = %{state | overflow_count: state.overflow_count + 1}
        {:reply, {:ok, conn}, new_state}
        
      :pool_empty ->
        # Add to waiting queue
        new_waiting = :queue.in(from, state.waiting)
        new_state = %{state | waiting: new_waiting}
        {:noreply, new_state}
    end
  end
end

# Optimized task pooling for coordination
defmodule MABEAM.CoordinationTaskPool do
  use GenServer
  
  def init(opts) do
    worker_count = Keyword.get(opts, :worker_count, System.schedulers_online())
    
    # Start worker pool
    workers = Enum.map(1..worker_count, fn i ->
      {:ok, pid} = MABEAM.CoordinationWorker.start_link([worker_id: i])
      {i, pid}
    end)
    
    {:ok, %{workers: Map.new(workers), next_worker: 1}}
  end
  
  def execute_coordination_task(task) do
    GenServer.call(__MODULE__, {:execute_task, task})
  end
  
  def handle_call({:execute_task, task}, _from, state) do
    # Round-robin task assignment
    worker_id = state.next_worker
    worker_pid = Map.get(state.workers, worker_id)
    
    # Execute task asynchronously
    Task.start(fn ->
      MABEAM.CoordinationWorker.execute(worker_pid, task)
    end)
    
    # Update next worker
    next_worker = rem(worker_id, map_size(state.workers)) + 1
    new_state = %{state | next_worker: next_worker}
    
    {:reply, :ok, new_state}
  end
end

# Real-time performance telemetry
defmodule Foundation.PerformanceTelemetry do
  def track_operation(operation_name, operation_fn) do
    start_time = System.monotonic_time(:microsecond)
    
    try do
      result = operation_fn.()
      duration = System.monotonic_time(:microsecond) - start_time
      
      # Emit performance metrics
      :telemetry.execute(
        [:foundation, :performance, :operation_completed],
        %{duration: duration},
        %{operation: operation_name, status: :success}
      )
      
      result
    rescue
      error ->
        duration = System.monotonic_time(:microsecond) - start_time
        
        :telemetry.execute(
          [:foundation, :performance, :operation_completed],
          %{duration: duration},
          %{operation: operation_name, status: :error, error: error}
        )
        
        reraise error, __STACKTRACE__
    end
  end
end

# Automatic SLO monitoring
defmodule Foundation.SLOMonitor do
  use GenServer
  
  def init(_opts) do
    # Subscribe to performance events
    :telemetry.attach_many(
      :slo_monitor,
      [
        [:foundation, :performance, :operation_completed],
        [:mabeam, :coordination, :consensus_completed],
        [:mabeam, :agent, :variable_updated]
      ],
      &handle_telemetry_event/4,
      %{}
    )
    
    {:ok, %{slo_violations: [], operation_stats: %{}}}
  end
  
  def handle_telemetry_event(event, measurements, metadata, state) do
    # Check SLO violations
    case check_slo_violation(event, measurements, metadata) do
      {:violation, violation} ->
        Logger.error("SLO Violation: #{inspect(violation)}")
        # Send alert
        send_slo_alert(violation)
        
      :ok ->
        :ok
    end
    
    # Update operation statistics
    update_operation_stats(state, event, measurements, metadata)
  end
end

# Automatic performance tuning
defmodule MABEAM.AdaptiveOptimizer do
  use GenServer
  
  def init(_opts) do
    # Start with baseline configuration
    config = %{
      batch_size: 32,
      consensus_timeout: 5000,
      variable_sync_interval: 100,
      agent_pool_size: 10
    }
    
    schedule_optimization_cycle(60_000)  # Optimize every minute
    {:ok, %{config: config, performance_history: []}}
  end
  
  def handle_info(:optimize, state) do
    # Analyze recent performance
    recent_performance = analyze_recent_performance()
    
    # Determine optimization strategy
    optimization = determine_optimization(recent_performance, state.config)
    
    # Apply optimization
    new_config = apply_optimization(optimization, state.config)
    
    # Update system configuration
    update_system_config(new_config)
    
    Logger.info("Applied performance optimization: #{inspect(optimization)}")
    
    schedule_optimization_cycle(60_000)
    {:noreply, %{state | config: new_config}}
  end
  
  defp determine_optimization(performance, current_config) do
    cond do
      performance.avg_latency > 50 ->
        # Latency too high - increase parallelism
        %{action: :increase_parallelism, factor: 1.2}
        
      performance.memory_usage > 0.8 ->
        # Memory pressure - reduce batch sizes
        %{action: :reduce_batch_size, factor: 0.8}
        
      performance.throughput < performance.target_throughput * 0.9 ->
        # Throughput too low - optimize coordination
        %{action: :optimize_coordination, strategy: :reduce_consensus_timeout}
        
      true ->
        # Performance within acceptable range
        %{action: :no_change}
    end
  end
end

# Performance budget enforcement
defmodule Foundation.PerformanceBudget do
  @performance_budgets %{
    # Agent coordination must not exceed these thresholds
    agent_variable_update: %{max_p99_ms: 10, max_mean_ms: 2},
    consensus_operation: %{max_p99_ms: 50, max_mean_ms: 20},
    service_discovery: %{max_p99_ms: 1, max_mean_ms: 0.5},
    
    # Memory budgets
    agent_memory_per_hour: %{max_growth_mb: 1},
    system_memory_baseline: %{max_growth_mb: 10}
  }
  
  def check_performance_budget(operation, results) do
    budget = Map.get(@performance_budgets, operation)
    
    cond do
      is_nil(budget) ->
        {:ok, :no_budget_defined}
        
      results.p99_ms > budget.max_p99_ms ->
        {:budget_exceeded, :p99_latency, results.p99_ms, budget.max_p99_ms}
        
      results.mean_ms > budget.max_mean_ms ->
        {:budget_exceeded, :mean_latency, results.mean_ms, budget.max_mean_ms}
        
      true ->
        {:ok, :within_budget}
    end
  end
end

# CI integration
defmodule Foundation.CIPerformanceCheck do
  def run_performance_gate do
    results = %{
      agent_coordination: run_agent_coordination_benchmark(),
      consensus_operations: run_consensus_benchmark(),
      service_discovery: run_service_discovery_benchmark(),
      memory_usage: run_memory_benchmark()
    }
    
    violations = Enum.flat_map(results, fn {operation, result} ->
      case Foundation.PerformanceBudget.check_performance_budget(operation, result) do
        {:budget_exceeded, metric, actual, budget} ->
          [%{operation: operation, metric: metric, actual: actual, budget: budget}]
        {:ok, _} ->
          []
      end
    end)
    
    case violations do
      [] ->
        IO.puts("✅ All performance budgets met")
        System.halt(0)
        
      violations ->
        IO.puts("❌ Performance budget violations:")
        Enum.each(violations, fn v ->
          IO.puts("  #{v.operation}.#{v.metric}: #{v.actual} > #{v.budget}")
        end)
        System.halt(1)
    end
  end
end

defmodule Foundation.ComprehensiveBenchmarks do
  use ExUnit.Case
  
  @tag :performance
  test "comprehensive system performance benchmarks" do
    # System-wide performance test
    Benchee.run(%{
      # Core Foundation operations
      "service_discovery" => fn ->
        Foundation.ProcessRegistry.lookup(:production, :config_server)
      end,
      "configuration_retrieval" => fn ->
        Foundation.ConfigServer.get_config([:mabeam, :agents])
      end,
      "event_emission" => fn ->
        Foundation.EventStore.append(%{type: :test, data: %{}})
      end,
      
      # MABEAM agent operations
      "agent_variable_update" => fn ->
        MABEAM.Coordination.update_agent_variable(:agent_1, :learning_rate, 0.01)
      end,
      "consensus_proposal" => fn ->
        MABEAM.Coordination.propose_variable_change(:batch_size, 128)
      end,
      "agent_coordination" => fn ->
        MABEAM.Coordination.coordinate_agents([:agent_1, :agent_2], :optimize)
      end,
      
      # Multi-agent scenarios
      "100_agent_coordination" => fn ->
        agents = get_test_agents(100)
        MABEAM.Coordination.broadcast_variable_update(:temperature, 0.8, agents)
      end,
      "distributed_consensus" => fn ->
        MABEAM.Coordination.distributed_consensus(:model_architecture, :transformer)
      end
    },
    time: 10,
    memory_time: 2,
    parallel: 1,
    formatters: [
      Benchee.Formatters.HTML,
      Benchee.Formatters.Console,
      {Foundation.PerformanceBudget.Formatter, []}
    ]
    )
  end
end

@system_slos %{
  # Latency SLOs
  service_discovery_p99: 1,         # ms
  agent_coordination_p99: 10,       # ms  
  consensus_operation_p99: 50,      # ms
  variable_sync_p99: 5,             # ms
  
  # Throughput SLOs
  agent_operations_per_sec: 10_000,
  consensus_operations_per_sec: 100,
  service_calls_per_sec: 50_000,
  
  # Memory SLOs
  agent_memory_growth_per_hour: 1,  # MB
  system_memory_growth_per_day: 10, # MB
  
  # Reliability SLOs
  consensus_success_rate: 0.999,    # 99.9%
  agent_coordination_success_rate: 0.9999, # 99.99%
  service_availability: 0.999       # 99.9%
}

# Real-time performance metrics
defmodule Foundation.PerformanceDashboard do
  def get_real_time_metrics do
    %{
      current_latencies: %{
        service_discovery: get_current_p99(:service_discovery),
        agent_coordination: get_current_p99(:agent_coordination),
        consensus_operations: get_current_p99(:consensus_operations)
      },
      
      throughput: %{
        agent_operations: get_current_throughput(:agent_operations),
        service_calls: get_current_throughput(:service_calls),
        consensus_operations: get_current_throughput(:consensus_operations)
      },
      
      resource_usage: %{
        total_agents: MABEAM.AgentRegistry.count_active_agents(),
        memory_usage: get_system_memory_usage(),
        cpu_utilization: get_cpu_utilization()
      },
      
      slo_compliance: %{
        latency_slos_met: check_latency_slos(),
        throughput_slos_met: check_throughput_slos(),
        reliability_slos_met: check_reliability_slos()
      }
    }
  end
end