mix test              # Uses pure mock mode
mix test.mock         # Explicit pure mock mode
DSPEX_TEST_MODE=mock mix test

mix test.fallback     # Live API when available, mock fallback
DSPEX_TEST_MODE=fallback mix test

mix test.live         # Requires API keys, fails without
DSPEX_TEST_MODE=live mix test

# Unit tests - always mock
test "program validates input fields correctly" do
  # Mock client ensures consistent behavior
end

# Basic integration - fallback works great
test "end-to-end prediction flow" do
  # setup_adaptive_client/1 handles mode switching
  {client_type, client} = MockHelpers.setup_adaptive_client(:gemini)
  # Test works in any mode
end

# Performance tests - always mock for consistency
test "high-frequency requests are handled efficiently" do
  # Force mock client for consistent timing
  {:ok, client} = DSPEx.MockClientManager.start_link(:gemini, %{
    simulate_delays: false
  })
end

# Mark tests that will eventually need live APIs
@tag :future_live_required
test "complex multi-turn conversation handling" do
  # Currently works with fallback
  # May need live APIs for realistic conversation flow validation
end

@tag :live_preferred  
test "multi-provider optimization" do
  # Works in fallback but benefits from real API behavior
end

# 1. Real API-specific behavior that can't be mocked
test "handles gemini rate limiting gracefully" do
  case DSPEx.TestModeConfig.get_test_mode() do
    :live ->
      # Test real rate limiting behavior
      run_rate_limit_test()
    _ ->
      skip("Requires live API mode: mix test.live")
  end
end

# 2. Model-specific response validation
test "gpt-4 vs gpt-3.5 response quality differences" do
  # Requires real model comparison
  require_live_mode!("Model comparison requires real API responses")
end

# 3. Cost and billing validation
test "token usage tracking accuracy" do
  # Real token counting validation
  require_live_mode!("Token counting requires real API usage")
end

# 4. Network and infrastructure testing
test "handles network timeouts and recovers" do
  # Real network conditions
  require_live_mode!("Network testing requires real connections")
end

# Adaptive test helper that respects test modes
{client_type, client} = MockHelpers.setup_adaptive_client(:gemini)

# Mode-aware client setup
case DSPEx.TestModeConfig.get_test_mode() do
  :mock -> setup_isolated_mock_client(provider)
  :fallback -> setup_adaptive_client(provider)
  :live -> setup_live_client(provider)
end

defmodule MyIntegrationTest do
  use ExUnit.Case
  import DSPEx.LiveTestHelpers
  
  @tag :live_required
  test "real API rate limiting" do
    require_live_mode!("Rate limiting testing requires real API calls")
    
    # Test implementation
    run_live_rate_limit_test()
  end
  
  @tag :live_preferred
  test "multi-provider optimization" do
    case DSPEx.TestModeConfig.get_test_mode() do
      :live ->
        run_with_live_apis()
      _ ->
        IO.puts("Running with mock/fallback - results may vary from live behavior")
        run_with_adaptive_clients()
    end
  end
end

defmodule DSPEx.LiveTestHelpers do
  def require_live_mode!(message \\ "Test requires live API mode") do
    unless DSPEx.TestModeConfig.live_only_mode?() do
      skip(message <> " - Use: mix test.live")
    end
  end
  
  def skip_unless_live_mode(message \\ "Skipping in mock/fallback mode") do
    unless DSPEx.TestModeConfig.live_only_mode?() do
      skip(message)
    end
  end
  
  def adaptive_test_setup(provider) do
    # Use the established pattern
    MockHelpers.setup_adaptive_client(provider)
  end
end

# config/test.exs
config :dspex, :test_modes,
  default_mode: :mock,
  live_test_timeout: 30_000,
  mock_test_timeout: 5_000,
  enable_mode_logging: true

# Conditional test configuration
case DSPEx.TestModeConfig.get_test_mode() do
  :live ->
    ExUnit.configure(timeout: 30_000, max_failures: 5)
  :fallback ->
    ExUnit.configure(timeout: 15_000)
  :mock ->
    ExUnit.configure(timeout: 5_000, max_failures: :infinity)
end

# Performance tests should always use controlled conditions
describe "performance characteristics" do
  test "request processing time is reasonable" do
    # Force mock for consistent performance testing
    {:ok, client} = DSPEx.MockClientManager.start_link(:gemini, %{
      simulate_delays: false,
      responses: :contextual
    })
    
    # Measure only local processing time
    start_time = System.monotonic_time(:millisecond)
    _result = DSPEx.MockClientManager.request(client, messages)
    end_time = System.monotonic_time(:millisecond)
    
    # Assert consistent performance
    assert (end_time - start_time) < 200
  end
end

# Handle process lifecycle properly in supervision tests
describe "supervision and fault tolerance" do
  test "client crash doesn't affect other components" do
    # Start unlinked to prevent exit signal propagation
    {:ok, client} = GenServer.start(DSPEx.ClientManager, {:gemini, %{}})
    program = Predict.new(TestSignature, client)
    
    # Kill the client and handle the resulting exit gracefully
    ref = Process.monitor(client)
    Process.exit(client, :kill)
    
    receive do
      {:DOWN, ^ref, :process, ^client, :killed} -> :ok
    after
      1000 -> flunk("Client process did not die as expected")
    end
    
    # Use try/catch to handle GenServer call to dead process
    result = 
      try do
        Program.forward(program, %{question: "Post-crash test"})
      catch
        :exit, _reason -> {:error, :client_dead}
      end
    
    assert match?({:error, _}, result)
    assert Process.alive?(self())
  end
end