# BEFORE (lib/foundation/application.ex)
@type startup_phase ::
        :infrastructure | :foundation_services | :coordination | :application | :mabeam

# AFTER
@type startup_phase ::
        :infrastructure | :foundation_services | :coordination | :application

# BEFORE
def build_supervision_tree do
  # ... other phases ...
  mabeam_children = build_phase_children(:mabeam)
  
  infrastructure_children ++
    foundation_children ++
    coordination_children ++
    application_children ++
    mabeam_children ++  # REMOVE THIS
    test_children ++
    tidewave_children
end

# AFTER  
def build_supervision_tree do
  # ... other phases ...
  
  infrastructure_children ++
    foundation_children ++
    coordination_children ++
    application_children ++
    test_children ++
    tidewave_children
end

# BEFORE
shutdown_phases = [:mabeam, :application, :coordination, :foundation_services, :infrastructure]

# AFTER
shutdown_phases = [:application, :coordination, :foundation_services, :infrastructure]

# BEFORE (lib/mabeam/migration.ex)
def using_unified_registry? do
  case Application.get_env(:foundation, :mabeam, []) do  # VIOLATION
    mabeam_config when is_list(mabeam_config) ->
      Keyword.get(mabeam_config, :use_unified_registry, false)
    _ -> false
  end
end

# AFTER
def using_unified_registry? do
  case Application.get_env(:mabeam, :config, []) do  # PROPER
    mabeam_config when is_list(mabeam_config) ->
      Keyword.get(mabeam_config, :use_unified_registry, false)
    _ -> false
  end
end

# BEFORE
def set_unified_registry(enabled) when is_boolean(enabled) do
  current_mabeam_config = Application.get_env(:foundation, :mabeam, [])  # VIOLATION
  updated_config = Keyword.put(current_mabeam_config, :use_unified_registry, enabled)
  Application.put_env(:foundation, :mabeam, updated_config)  # VIOLATION
  Logger.info("Unified registry feature flag set to: #{enabled}")
end

# AFTER
def set_unified_registry(enabled) when is_boolean(enabled) do
  current_mabeam_config = Application.get_env(:mabeam, :config, [])  # PROPER
  updated_config = Keyword.put(current_mabeam_config, :use_unified_registry, enabled)
  Application.put_env(:mabeam, :config, updated_config)  # PROPER
  Logger.info("Unified registry feature flag set to: #{enabled}")
end

# apps/foundation_mabeam/mix.exs
defmodule FoundationMABEAM.MixProject do
  use Mix.Project

  def project do
    [
      app: :foundation_mabeam,
      version: "0.1.0",
      elixir: "~> 1.15",
      start_permanent: Mix.env() == :prod,
      deps: deps()
    ]
  end

  def application do
    [
      extra_applications: [:logger],
      mod: {FoundationMABEAM.Application, []}
    ]
  end

  defp deps do
    [
      {:foundation, path: "../foundation"},
      {:mabeam, path: "../mabeam"}
    ]
  end
end

# apps/foundation_mabeam/lib/foundation_mabeam/application.ex
defmodule FoundationMABEAM.Application do
  @moduledoc """
  Composition application that orchestrates Foundation and MABEAM together.
  
  This application demonstrates the proper way to compose Foundation 
  infrastructure with MABEAM services while maintaining architectural boundaries.
  """
  
  use Application
  require Logger

  def start(_type, _args) do
    Logger.info("Starting Foundation + MABEAM composition application")

    children = [
      # Start Foundation first (infrastructure)
      {Foundation.Application, []},
      
      # Start MABEAM after Foundation is ready
      {MABEAM.Application, []},
      
      # Optional: Add composition-specific services
      {FoundationMABEAM.IntegrationMonitor, []}
    ]

    opts = [
      strategy: :one_for_one,
      name: FoundationMABEAM.Supervisor,
      max_restarts: 3,
      max_seconds: 10
    ]

    case Supervisor.start_link(children, opts) do
      {:ok, pid} ->
        Logger.info("Foundation + MABEAM composition started successfully")
        {:ok, pid}
      
      {:error, reason} ->
        Logger.error("Failed to start composition: #{inspect(reason)}")
        {:error, reason}
    end
  end

  def stop(_state) do
    Logger.info("Stopping Foundation + MABEAM composition application")
    :ok
  end
end

# apps/foundation_mabeam/lib/foundation_mabeam/integration_monitor.ex
defmodule FoundationMABEAM.IntegrationMonitor do
  @moduledoc """
  Monitors the integration health between Foundation and MABEAM.
  
  This is composition-level logic that doesn't belong in either
  Foundation or MABEAM individually.
  """
  
  use GenServer
  require Logger

  def start_link(opts \\ []) do
    GenServer.start_link(__MODULE__, opts, name: __MODULE__)
  end

  def init(_opts) do
    # Monitor both applications
    schedule_integration_check()
    {:ok, %{check_interval: 30_000}}
  end

  def handle_info(:integration_check, state) do
    # Check that Foundation services are available to MABEAM
    foundation_health = check_foundation_health()
    mabeam_health = check_mabeam_health()
    
    integration_status = %{
      foundation: foundation_health,
      mabeam: mabeam_health,
      integration: check_integration_health(foundation_health, mabeam_health),
      timestamp: DateTime.utc_now()
    }
    
    # Emit composition-level telemetry
    :telemetry.execute(
      [:foundation_mabeam, :integration, :health_check],
      %{status: if(integration_status.integration == :healthy, do: 1, else: 0)},
      integration_status
    )
    
    schedule_integration_check()
    {:noreply, state}
  end

  defp check_foundation_health do
    case Process.whereis(Foundation.ProcessRegistry) do
      nil -> :unhealthy
      _pid -> :healthy
    end
  end

  defp check_mabeam_health do
    case Process.whereis(MABEAM.Core) do
      nil -> :unhealthy
      _pid -> :healthy
    end
  end

  defp check_integration_health(:healthy, :healthy), do: :healthy
  defp check_integration_health(_, _), do: :unhealthy

  defp schedule_integration_check do
    Process.send_after(self(), :integration_check, 30_000)
  end
end

# config/foundation.exs - ONLY Foundation configuration
config :foundation,
  environment: :prod,
  enhanced_error_handling: true,
  coordination: %{
    consensus_timeout: 5000,
    election_timeout: 3000,
    lock_timeout: 5000,
    barrier_timeout: 10_000
  },
  health_monitoring: %{
    global_health_check_interval: 30_000,
    health_check_timeout: 5000,
    unhealthy_threshold: 3,
    degraded_threshold: 1
  }

# config/mabeam.exs - ONLY MABEAM configuration
config :mabeam,
  config: [
    use_unified_registry: true,
    agent_supervision_strategy: :one_for_one,
    max_agents: 1000
  ],
  economics: %{
    auction_timeout: 300_000,
    default_bid_increment: 1.0
  },
  coordination: %{
    consensus_algorithm: :raft,
    election_timeout: 5000
  }

# config/foundation_mabeam.exs - Composition-specific configuration
config :foundation_mabeam,
  integration_monitoring: %{
    enabled: true,
    check_interval: 30_000,
    alert_on_failure: true
  },
  startup_order: [:foundation, :mabeam],
  shutdown_timeout: 30_000

# Temporary bridge for existing deployments
defmodule Foundation.MABEAM.ConfigBridge do
  @moduledoc """
  TEMPORARY: Migration bridge for configuration compatibility.
  
  Remove this module after all deployments have migrated to
  the new configuration structure.
  """
  
  def get_legacy_config(key) do
    case Application.get_env(:foundation, :mabeam) do
      nil -> 
        # Try new configuration location
        Application.get_env(:mabeam, :config) |> Keyword.get(key)
      legacy_config when is_list(legacy_config) ->
        Logger.warn("Using legacy MABEAM configuration under :foundation app. Please migrate to :mabeam app configuration.")
        Keyword.get(legacy_config, key)
    end
  end
end

# Update MABEAM.Migration to handle both old and new config locations
def using_unified_registry? do
  # Try new location first
  case Application.get_env(:mabeam, :config, []) do
    [] ->
      # Fall back to legacy location with warning
      case Application.get_env(:foundation, :mabeam, []) do
        [] -> false
        legacy_config ->
          Logger.warn("MABEAM configuration found in legacy location (:foundation, :mabeam). Please migrate to (:mabeam, :config).")
          Keyword.get(legacy_config, :use_unified_registry, false)
      end
    
    mabeam_config ->
      Keyword.get(mabeam_config, :use_unified_registry, false)
  end
end

defmodule Foundation.IndependenceTest do
  use ExUnit.Case
  
  test "Foundation can start without MABEAM application" do
    # Ensure MABEAM is not started
    assert :error = Application.start(:mabeam)
    
    # Foundation should start successfully
    assert {:ok, _} = Foundation.Application.start(:normal, [])
    
    # Foundation services should be functional
    assert {:ok, _} = Foundation.ProcessRegistry.register(:test, :independence_test, self())
  end
  
  test "Foundation has no compile-time dependencies on MABEAM modules" do
    # Use AST analysis to verify no direct MABEAM module references
    foundation_modules = get_foundation_modules()
    
    Enum.each(foundation_modules, fn module ->
      ast = get_module_ast(module)
      refute has_mabeam_references?(ast), "#{module} contains MABEAM references"
    end)
  end
end

defmodule FoundationMABEAM.IntegrationTest do
  use ExUnit.Case
  
  test "composition application starts both Foundation and MABEAM" do
    assert {:ok, _} = FoundationMABEAM.Application.start(:normal, [])
    
    # Both applications should be running
    assert Process.whereis(Foundation.ProcessRegistry) != nil
    assert Process.whereis(MABEAM.Core) != nil
  end
  
  test "MABEAM can use Foundation services after composition startup" do
    assert {:ok, _} = FoundationMABEAM.Application.start(:normal, [])
    
    # MABEAM should be able to register with Foundation
    assert {:ok, _} = MABEAM.AgentRegistry.register_agent(build_test_agent_config())
  end
end