# lib/dspex/python_bridge/bridge.ex:393
Process.sleep(100)  # ❌ Production code guessing timing

# lib/dspex/python_bridge/supervisor.ex:299
Process.sleep(1_000)  # ❌ 1-second production delay

# lib/dspex/python_bridge/supervisor.ex:330  
Process.sleep(100)   # ❌ More production timing assumptions

Process.sleep(500)   # Line 21  - Bridge startup wait
Process.sleep(200)   # Line 95  - Response wait  
Process.sleep(1000)  # Line 109 - "Give Python bridge time to start"
Process.sleep(500)   # Line 138 - Command execution wait
Process.sleep(500)   # Line 176 - Bridge readiness wait
Process.sleep(1000)  # Line 198 - "Give Python bridge time to start"
Process.sleep(1000)  # Line 251 - Bridge startup wait
Process.sleep(500)   # Line 294 - Operation completion wait
Process.sleep(1000)  # Line 316 - Bridge startup wait  
Process.sleep(1000)  # Line 342 - Bridge startup wait

Process.sleep(100)  # Line 93  - Health check wait
Process.sleep(100)  # Line 113 - Status verification wait
Process.sleep(50)   # Line 117 - Quick status check
Process.sleep(200)  # Line 148 - Multiple health checks
Process.sleep(200)  # Line 173 - Failure accumulation wait
Process.sleep(100)  # Line 193 - Bridge response wait
Process.sleep(50)   # Line 216 - Health check loop
Process.sleep(100)  # Line 219 - Final status check

Process.sleep(100)  # Line 129 - Child restart wait
Process.sleep(100)  # Line 172 - Supervisor stop wait
Process.sleep(100)  # Line 210 - Bridge initialization wait
Process.sleep(100)  # Line 256 - Restart verification wait  
Process.sleep(100)  # Line 299 - Bridge restart wait
Process.sleep(100)  # Line 332 - Stop sequence wait
Process.sleep(200)  # Line 351 - Configuration reload wait

Process.sleep(100)  # Line 80  - Initialization wait
Process.sleep(100)  # Line 185 - "Let it initialize"

Process.sleep(1000) # Line 16 - Integration test wait

# test/support/supervision_test_helpers.ex
defmodule DSPex.SupervisionTestHelpers do
  @moduledoc """
  Test helpers for supervision tree isolation and process lifecycle management.
  Eliminates all Process.sleep() usage with event-driven coordination.
  """
  
  # Bridge readiness verification
  def wait_for_bridge_ready(supervisor_pid, bridge_name, timeout \\ 5000) do
    start_time = System.monotonic_time(:millisecond)
    
    Stream.repeatedly(fn ->
      case get_bridge_status(supervisor_pid, bridge_name) do
        {:ok, %{status: :running, python_ready: true}} -> {:ok, :ready}
        {:ok, status} -> {:waiting, status}
        {:error, _} = error -> error
      end
    end)
    |> Stream.take_while(fn
      {:ok, :ready} -> false
      {:waiting, _} -> 
        elapsed = System.monotonic_time(:millisecond) - start_time
        elapsed < timeout
      {:error, _} -> false
    end)
    |> Enum.to_list()
    
    get_bridge_status(supervisor_pid, bridge_name)
  end
  
  # Process restart synchronization
  def wait_for_process_restart(supervisor_pid, process_name, old_pid, timeout \\ 5000) do
    ref = Process.monitor(old_pid)
    
    # Wait for crash
    receive do
      {:DOWN, ^ref, :process, ^old_pid, _reason} -> :ok
    after timeout -> {:error, :crash_timeout}
    end
    
    # Wait for restart with new PID
    wait_for(fn ->
      case get_child_pid(supervisor_pid, process_name) do
        {:ok, new_pid} when new_pid != old_pid and Process.alive?(new_pid) ->
          {:ok, new_pid}
        _ -> nil
      end
    end, timeout)
  end
  
  # Generic condition waiting
  def wait_for(fun, timeout \\ 5000) do
    start_time = System.monotonic_time(:millisecond)
    
    Stream.repeatedly(fun)
    |> Stream.take_while(fn
      {:ok, _} -> false
      nil -> 
        elapsed = System.monotonic_time(:millisecond) - start_time
        elapsed < timeout
      {:error, _} -> false
    end)
    |> Enum.to_list()
    
    case fun.() do
      {:ok, result} -> {:ok, result}
      nil -> {:error, :timeout}
      {:error, _} = error -> error
    end
  end
end

# test/support/bridge_test_helpers.ex  
defmodule DSPex.BridgeTestHelpers do
  @moduledoc """
  Test helpers for Python bridge communication.
  Provides event-driven coordination for bridge operations.
  """
  
  # Synchronized bridge calls with proper timeout handling
  def bridge_call_with_retry(bridge_pid, command, args, retries \\ 3, timeout \\ 2000) do
    Enum.reduce_while(1..retries, {:error, :max_retries}, fn attempt, _acc ->
      case GenServer.call(bridge_pid, {:call, command, args}, timeout) do
        {:ok, result} -> {:halt, {:ok, result}}
        {:error, :timeout} when attempt < retries ->
          # Wait for bridge to recover
          case wait_for_bridge_recovery(bridge_pid, 1000) do
            :ok -> {:cont, {:error, :retry}}
            error -> {:halt, error}
          end
        error -> {:halt, error}
      end
    end)
  end
  
  # Bridge recovery verification
  defp wait_for_bridge_recovery(bridge_pid, timeout) do
    wait_for(fn ->
      case GenServer.call(bridge_pid, :get_status, 100) do
        %{status: :running} -> {:ok, :recovered}
        _ -> nil
      end
    rescue
      _ -> nil
    end, timeout)
  end
  
  # Python process synchronization
  def wait_for_python_response(bridge_pid, request_id, timeout \\ 5000) do
    wait_for(fn ->
      case GenServer.call(bridge_pid, {:get_response, request_id}, 100) do
        {:ok, response} -> {:ok, response}
        {:error, :not_ready} -> nil
        error -> error
      end
    end, timeout)
  end
end

# test/support/monitor_test_helpers.ex
defmodule DSPex.MonitorTestHelpers do
  @moduledoc """
  Test helpers for monitor behavior verification.
  Eliminates timing assumptions with event-driven health checks.
  """
  
  # Wait for specific health status
  def wait_for_health_status(monitor_pid, expected_status, timeout \\ 3000) do
    wait_for(fn ->
      case GenServer.call(monitor_pid, :get_status) do
        %{status: ^expected_status} = status -> {:ok, status}
        _ -> nil
      end
    end, timeout)
  end
  
  # Wait for failure count
  def wait_for_failure_count(monitor_pid, expected_count, timeout \\ 3000) do
    wait_for(fn ->
      case GenServer.call(monitor_pid, :get_status) do
        %{total_failures: ^expected_count} = status -> {:ok, status}
        _ -> nil
      end
    end, timeout)
  end
  
  # Trigger and verify health check
  def trigger_health_check_and_wait(monitor_pid, expected_result, timeout \\ 2000) do
    GenServer.cast(monitor_pid, :force_health_check)
    
    wait_for(fn ->
      case GenServer.call(monitor_pid, :get_status) do
        %{last_check_result: ^expected_result} = status -> {:ok, status}
        _ -> nil
      end
    end, timeout)
  end
end

# test/support/unified_test_foundation.ex
defmodule DSPex.UnifiedTestFoundation do
  @moduledoc """
  Unified test foundation implementing isolation patterns from UNIFIED_TESTING_GUIDE.md
  """
  
  defmacro __using__(isolation_type) do
    quote do
      use ExUnit.Case, async: isolation_allows_async?(unquote(isolation_type))
      import DSPex.SupervisionTestHelpers
      import DSPex.BridgeTestHelpers  
      import DSPex.MonitorTestHelpers
      
      setup context do
        unquote(__MODULE__).setup_isolation(unquote(isolation_type), context)
      end
    end
  end
  
  def setup_isolation(:basic, _context) do
    unique_id = :erlang.unique_integer([:positive])
    {:ok, test_id: unique_id}
  end
  
  def setup_isolation(:supervision_testing, _context) do
    unique_id = :erlang.unique_integer([:positive])
    supervisor_name = :"test_supervisor_#{unique_id}"
    
    # Start isolated supervisor with unique names
    {:ok, supervisor_pid} = DSPex.PythonBridge.Supervisor.start_link(
      name: supervisor_name,
      bridge_name: :"bridge_#{unique_id}",
      monitor_name: :"monitor_#{unique_id}"
    )
    
    on_exit(fn ->
      if Process.alive?(supervisor_pid) do
        graceful_supervisor_shutdown(supervisor_pid)
      end
    end)
    
    {:ok, 
     supervision_tree: supervisor_pid,
     bridge_name: :"bridge_#{unique_id}",
     monitor_name: :"monitor_#{unique_id}",
     test_id: unique_id}
  end
  
  defp graceful_supervisor_shutdown(supervisor_pid) do
    ref = Process.monitor(supervisor_pid)
    GenServer.stop(supervisor_pid, :normal, 2000)
    
    receive do
      {:DOWN, ^ref, :process, ^supervisor_pid, _} -> :ok
    after 3000 -> 
      Process.exit(supervisor_pid, :kill)
    end
  end
  
  defp isolation_allows_async?(:supervision_testing), do: false
  defp isolation_allows_async?(_), do: true
end

# BEFORE (bridge.ex:393)
def terminate(_reason, state) do
  if state.port && Port.info(state.port) do
    Port.close(state.port)
    Process.sleep(100)  # ❌ REMOVE THIS
  end
end

# AFTER - Event-driven termination
def terminate(_reason, state) do
  if state.port && Port.info(state.port) do
    # Send graceful shutdown command
    case send_command(state.port, "shutdown", %{}) do
      :ok ->
        # Wait for acknowledgment or timeout
        receive do
          {^port, {:data, response}} ->
            case Jason.decode(response) do
              {:ok, %{"status" => "shutdown_ack"}} -> :ok
              _ -> :ok
            end
        after 2000 -> :ok
        end
      _ -> :ok
    end
    
    Port.close(state.port)
  end
end

# BEFORE (supervisor.ex:299)
def wait_for_bridge_ready(supervisor_pid, timeout \\ 30_000) do
  # ... existing code ...
  Process.sleep(1_000)  # ❌ REMOVE THIS
end

# AFTER - Event-driven readiness check
def wait_for_bridge_ready(supervisor_pid, timeout \\ 30_000) do
  bridge_name = get_bridge_name(supervisor_pid)
  
  wait_for(fn ->
    case get_bridge_status(supervisor_pid, bridge_name) do
      {:ok, %{status: :running, python_ready: true}} -> {:ok, :ready}
      _ -> nil
    end
  end, timeout)
end

# BEFORE (supervisor.ex:330)  
defp do_stop_bridge(bridge_pid) do
  GenServer.stop(bridge_pid, :normal, 5_000)
  Process.sleep(100)  # ❌ REMOVE THIS
end

# AFTER - Monitored shutdown
defp do_stop_bridge(bridge_pid) do
  ref = Process.monitor(bridge_pid)
  GenServer.stop(bridge_pid, :normal, 5_000)
  
  receive do
    {:DOWN, ^ref, :process, ^bridge_pid, _} -> :ok
  after 6_000 -> 
    Process.exit(bridge_pid, :kill)
  end
end

# BEFORE - Typical sleep pattern
test "bridge handles complex queries" do
  {:ok, supervisor_pid} = start_supervised({DSPex.PythonBridge.Supervisor, [name: :test_supervisor]})
  Process.sleep(1000)  # ❌ "Give Python bridge time to start"
  
  result = DSPex.PythonBridge.call(:test_supervisor, :query, query_params)
  assert {:ok, _} = result
end

# AFTER - Event-driven pattern  
test "bridge handles complex queries", %{supervision_tree: sup_tree, bridge_name: bridge_name} do
  # Wait for bridge readiness
  assert {:ok, :ready} = wait_for_bridge_ready(sup_tree, bridge_name)
  
  # Make call with proper synchronization
  result = bridge_call_with_retry(bridge_name, :query, query_params)
  assert {:ok, _} = result
end

# BEFORE - Sleep-based health check
test "tracks bridge health over time" do
  {:ok, monitor_pid} = start_monitor()
  Process.sleep(200)  # ❌ Wait for multiple health checks
  
  status = GenServer.call(monitor_pid, :get_status)
  assert status.total_checks >= 2
end

# AFTER - Event-driven health tracking
test "tracks bridge health over time" do
  {:ok, monitor_pid} = start_monitor()
  
  # Trigger specific number of health checks
  for _i <- 1..3 do
    assert {:ok, _} = trigger_health_check_and_wait(monitor_pid, :success)
  end
  
  status = GenServer.call(monitor_pid, :get_status)
  assert status.total_checks == 3
end

# BEFORE - Sleep-based restart testing
test "restarts bridge on failure" do
  {:ok, supervisor_pid} = start_supervisor()
  bridge_pid = get_bridge_pid(supervisor_pid)
  
  Process.exit(bridge_pid, :kill)
  Process.sleep(100)  # ❌ Wait for restart
  
  new_bridge_pid = get_bridge_pid(supervisor_pid)
  assert new_bridge_pid != bridge_pid
end

# AFTER - Event-driven restart verification
test "restarts bridge on failure", %{supervision_tree: sup_tree, bridge_name: bridge_name} do
  {:ok, bridge_pid} = get_service(sup_tree, bridge_name)
  
  Process.exit(bridge_pid, :kill)
  
  # Wait for restart with new PID
  assert {:ok, new_bridge_pid} = wait_for_process_restart(sup_tree, bridge_name, bridge_pid)
  assert new_bridge_pid != bridge_pid
  assert Process.alive?(new_bridge_pid)
end

test "system survives random bridge failures" do
  chaos_task = Task.async(fn ->
    run_bridge_chaos_loop(sup_tree, 30_000)  # 30 seconds
  end)
  
  health_task = Task.async(fn ->
    monitor_bridge_health(sup_tree, 30_000)
  end)
  
  chaos_events = Task.await(chaos_task, 35_000)
  health_results = Task.await(health_task, 35_000)
  
  assert length(chaos_events) > 5  # Multiple failure events
  assert Enum.all?(health_results, & &1.recovered)  # All recovered
end

test "bridge restart performance benchmarks" do
  restart_times = for _i <- 1..10 do
    {:ok, bridge_pid} = get_service(sup_tree, bridge_name)
    
    start_time = :erlang.monotonic_time(:microsecond)
    Process.exit(bridge_pid, :kill)
    {:ok, _new_pid} = wait_for_process_restart(sup_tree, bridge_name, bridge_pid)
    end_time = :erlang.monotonic_time(:microsecond)
    
    (end_time - start_time) / 1000  # Convert to milliseconds
  end
  
  avg_time = Enum.sum(restart_times) / length(restart_times)
  p95_time = percentile(restart_times, 0.95)
  
  assert avg_time < 2000, "Average restart too slow: #{avg_time}ms"
  assert p95_time < 5000, "P95 restart too slow: #{p95_time}ms"
end

# CI pipeline checks
echo "Checking for Process.sleep usage..."
rg "Process\.sleep\(" --type elixir && echo "❌ SLEEP DETECTED" && exit 1

echo "Checking for hardcoded process names..."  
rg "name: :[a-z_]+\b" --type elixir | grep -v "unique_integer" && echo "❌ HARDCODED NAMES" && exit 1

echo "Running tests with different seeds..."
for i in {1..5}; do
  mix test --seed $RANDOM || (echo "❌ FLAKY TESTS" && exit 1)
done

echo "✅ All quality checks passed"