# DSPEx.Services.ConfigManager - Lines 44-47
def get(path) when is_list(path) do
  # Foundation Config has contract violations - use fallback until fixed
  get_from_fallback_config(path)
end

# Line 218 - setup_dspex_config()
Logger.debug("DSPEx config path is restricted - using fallback config only")

defmodule Foundation.ConfigPathRestrictionTest do
  use ExUnit.Case
  
  test "config update returns proper error for restricted paths" do
    # This should return {:error, %Error{error_type: :config_update_forbidden}}
    # NOT crash or throw an exception
    result = Foundation.Config.update([:dspex, :test_key], "test_value")
    
    assert {:error, %Foundation.Types.Error{error_type: :config_update_forbidden}} = result
    # Should NOT: raise an exception, return :ok, or return malformed error
  end
  
  test "config get handles non-existent paths gracefully" do
    result = Foundation.Config.get([:non_existent, :path])
    
    # Should return standard error tuple, not crash
    assert {:error, %Foundation.Types.Error{}} = result
  end
  
  test "config update validates path format" do
    # Test various malformed paths
    invalid_paths = [
      nil,
      :not_a_list, 
      ["string_key"],
      [nil],
      []
    ]
    
    for path <- invalid_paths do
      result = Foundation.Config.update(path, "value")
      # Should return error tuple, not crash
      assert {:error, _} = result
    end
  end
end

defmodule Foundation.ConfigLifecycleTest do
  use ExUnit.Case
  
  test "config operations during service startup" do
    # Simulate the exact scenario DSPEx encounters
    # where it tries to use config before service is fully ready
    
    # Stop config service
    :ok = Foundation.Services.ConfigServer.stop()
    
    # Try to use config (this is what DSPEx does during init)
    result = Foundation.Config.get([:test, :key])
    
    # Should return error, not crash
    assert {:error, %Foundation.Types.Error{}} = result
  end
  
  test "config operations during service shutdown" do
    # This reproduces the shutdown race condition
    spawn(fn -> Foundation.Services.ConfigServer.stop() end)
    Process.sleep(10) # Race condition window
    
    result = Foundation.Config.update([:ai, :planning, :sampling_rate], 0.5)
    
    # Should handle shutdown gracefully
    assert result in [:ok, {:error, _}]
  end
end

# DSPEx.Services.TelemetrySetup - Lines 135-197
# This is a MASSIVE defensive block catching 8 different error types
try do
  if Foundation.available?() do
    do_handle_dspex_event(event, measurements, metadata, config)
  end
rescue
  ArgumentError ->         # ETS table may be gone during test cleanup
  SystemLimitError ->      # System under stress during test cleanup  
  UndefinedFunctionError -> # Foundation function may not be available
  FunctionClauseError ->   # Foundation contract violation
catch
  :exit, {:noproc, _} ->   # Process may be dead during cleanup
  :exit, {:badarg, _} ->   # ETS table corruption during cleanup
  :exit, {:normal, _} ->   # Process shutting down normally
  kind, reason ->          # Catch any other unexpected errors
end

defmodule Foundation.TelemetryShutdownTest do
  use ExUnit.Case
  
  test "telemetry handlers survive service restart" do
    # Attach a handler
    :ok = Foundation.Telemetry.attach_handlers([
      {[:test, :event], &__MODULE__.test_handler/4, nil}
    ])
    
    # Restart telemetry service (simulates what happens during testing)
    GenServer.stop(Foundation.Services.TelemetryService, :normal)
    {:ok, _} = Foundation.Services.TelemetryService.start_link([])
    
    # Try to emit event - should not crash
    result = Foundation.Telemetry.emit_histogram([:test, :metric], 100)
    
    assert :ok = result
  end
  
  test "concurrent telemetry operations during shutdown" do
    # Simulate the exact race condition DSPEx encounters
    
    tasks = for i <- 1..10 do
      Task.async(fn ->
        try do
          Foundation.Telemetry.emit_counter([:test, :concurrent], %{id: i})
        rescue
          error -> {:error, error}
        catch
          kind, reason -> {:error, {kind, reason}}
        end
      end)
    end
    
    # Stop service while tasks are running
    Process.sleep(5)
    GenServer.stop(Foundation.Services.TelemetryService, :shutdown)
    
    results = Task.await_many(tasks, 1000)
    
    # Should not have any unexpected crashes
    for result <- results do
      assert result in [:ok, {:error, _}]
    end
  end
  
  def test_handler(_event, _measurements, _metadata, _config), do: :ok
end

defmodule Foundation.ETSLifecycleTest do
  use ExUnit.Case
  
  test "telemetry operations when ETS table is deleted" do
    # This reproduces the "ETS table may be gone" error
    
    # Get the ETS table name used by telemetry service
    {:ok, pid} = Foundation.Services.TelemetryService.start_link([])
    state = :sys.get_state(pid)
    table_name = state[:table] # Assuming telemetry uses ETS
    
    # Delete the table (simulates what happens during harsh shutdown)
    if table_name do
      :ets.delete(table_name)
    end
    
    # Try to use telemetry
    result = Foundation.Telemetry.emit_histogram([:test, :after_deletion], 50)
    
    # Should return error, not crash with ArgumentError
    case result do
      :ok -> :ok  # If it still works, that's fine
      {:error, _} -> :ok  # Proper error handling
      _ -> flunk("Telemetry should handle ETS deletion gracefully")
    end
  end
end

# DSPEx.Client - Comment indicating Events API was broken
# "Foundation v0.1.3 fixed - re-enabled!"

# TelemetrySetup catching FunctionClauseError
FunctionClauseError ->   # Foundation contract violation

defmodule Foundation.EventsContractTest do
  use ExUnit.Case
  
  test "new_event function handles various input types" do
    # Test the exact patterns DSPEx uses
    
    valid_events = [
      Foundation.Events.new_event(
        "prediction_completed",
        %{duration: 150, success: true}
      ),
      Foundation.Events.new_event(
        "client_request_failed", 
        %{error: "timeout", provider: "gemini"}
      )
    ]
    
    for event <- valid_events do
      # Should create event without FunctionClauseError
      assert %Foundation.Types.Event{} = event
      
      # Should store without crashing
      result = Foundation.Events.store(event)
      assert :ok = result
    end
  end
  
  test "events system handles malformed metadata" do
    # Test edge cases that might cause FunctionClauseError
    
    malformed_cases = [
      %{nested: %{very: %{deep: %{structure: true}}}},
      %{binary_key: "value", atom_key: :value},
      %{pid: self(), ref: make_ref()},
      %{large_binary: String.duplicate("x", 10_000)}
    ]
    
    for metadata <- malformed_cases do
      event = Foundation.Events.new_event("test_event", metadata)
      
      # Should not crash during creation or storage
      result = Foundation.Events.store(event)
      assert result in [:ok, {:error, _}]
    end
  end
end

# Multiple modules have fallback correlation ID generation
defp generate_correlation_id do
  Foundation.Utils.generate_correlation_id()
rescue
  _ ->
    # Fallback for when Foundation is not available
    "test-" <> Base.encode16(:crypto.strong_rand_bytes(8), case: :lower)
end

defmodule Foundation.AvailabilityTest do
  use ExUnit.Case
  
  test "available? is accurate during startup sequence" do
    # Stop all Foundation services
    Foundation.Services.ConfigServer.stop()
    Foundation.Services.TelemetryService.stop()
    Foundation.Services.EventStore.stop()
    
    # Should return false
    assert false = Foundation.available?()
    
    # Start services one by one
    {:ok, _} = Foundation.Services.ConfigServer.start_link([])
    # available? might still be false since not all services are up
    
    {:ok, _} = Foundation.Services.TelemetryService.start_link([])
    {:ok, _} = Foundation.Services.EventStore.start_link([])
    
    # Now should be true
    assert true = Foundation.available?()
  end
  
  test "utility functions work when available? is true" do
    # If available? returns true, utils should work
    if Foundation.available?() do
      correlation_id = Foundation.Utils.generate_correlation_id()
      assert is_binary(correlation_id)
      assert String.length(correlation_id) > 0
    end
  end
end

defmodule Foundation.DSPExIntegrationTest do
  use ExUnit.Case
  
  test "reproduces DSPEx startup sequence" do
    # This test reproduces the exact sequence DSPEx goes through
    
    # 1. DSPEx.Services.ConfigManager starts and waits for Foundation
    assert Foundation.available?()
    
    # 2. Tries to update config with DSPEx namespace
    result = Foundation.Config.update([:dspex, :test], "value")
    # Should handle gracefully (even if forbidden)
    assert result in [:ok, {:error, _}]
    
    # 3. DSPEx.Services.TelemetrySetup attaches handlers
    :ok = Foundation.Telemetry.attach_handlers([
      {[:dspex, :test], &__MODULE__.test_handler/4, nil}
    ])
    
    # 4. DSPEx makes predictions and emits telemetry
    :ok = Foundation.Telemetry.emit_histogram([:dspex, :predict], 100)
    
    # 5. During shutdown, handlers should detach cleanly
    :ok = Foundation.Telemetry.detach_handlers([:dspex, :test])
  end
  
  def test_handler(_event, _measurements, _metadata, _config), do: :ok
end

# Add DSPEx paths to updatable_paths
@updatable_paths [
  # ... existing paths ...
  [:dspex, :providers],
  [:dspex, :prediction],
  [:dspex, :teleprompters],
  # Allow any path under :dspex for registered applications
]

# Or better: implement dynamic path registration
def register_application_namespace(namespace) when is_atom(namespace) do
  # Allow updates to any path under the registered namespace
end

# Add graceful degradation for ETS operations
defp safe_ets_operation(table, operation) do
  try do
    operation.(table)
  rescue
    ArgumentError -> {:error, :table_not_available}
  catch
    :exit, {:badarg, _} -> {:error, :table_corrupted}
  end
end

# Add proper shutdown coordination
def terminate(_reason, state) do
  # Notify all attached handlers before destroying ETS tables
  notify_handlers_of_shutdown(state.handlers)
  Process.sleep(100)  # Give handlers time to detach
  :ok
end

# Add input validation to prevent FunctionClauseError
def store(%Event{} = event) do
  case validate_event_metadata(event.metadata) do
    :ok -> do_store(event)
    {:error, reason} -> {:error, {:invalid_metadata, reason}}
  end
end

defp validate_event_metadata(metadata) when is_map(metadata) do
  # Ensure metadata can be safely serialized/stored
  try do
    Jason.encode!(metadata)
    :ok
  rescue
    _ -> {:error, :non_serializable_metadata}
  end
end