defmodule DSPex.Adapters.Adapter do
  @moduledoc """
  Behavior for DSPy adapters with 3-layer testing support.
  """
  
  @type program_config :: %{
    id: String.t(),
    signature: module(),
    modules: list(map()),
    settings: map()
  }
  
  @type execution_options :: %{
    timeout: pos_integer(),
    max_retries: non_neg_integer(),
    context: map()
  }
  
  @type program_info :: %{
    id: String.t(),
    signature: map(),
    status: atom(),
    created_at: DateTime.t(),
    stats: map()
  }
  
  # Core operations (required for all adapters)
  @callback create_program(program_config()) :: {:ok, String.t()} | {:error, term()}
  @callback execute_program(String.t(), map()) :: {:ok, map()} | {:error, term()}
  @callback list_programs() :: {:ok, list(String.t())} | {:error, term()}
  @callback delete_program(String.t()) :: :ok | {:error, term()}
  
  # Extended operations (optional with default implementations)
  @callback execute_program(String.t(), map(), execution_options()) :: {:ok, map()} | {:error, term()}
  @callback get_program_info(String.t()) :: {:ok, program_info()} | {:error, term()}
  @callback validate_signature(module()) :: :ok | {:error, term()}
  
  # Health and monitoring (adapter-specific implementations)
  @callback health_check() :: :ok | {:error, term()}
  @callback get_stats() :: {:ok, map()} | {:error, term()}
  @callback cleanup() :: :ok | {:error, term()}
  
  # Test layer compatibility
  @callback supports_test_layer?(atom()) :: boolean()
  @callback get_test_capabilities() :: map()
  
  @optional_callbacks [
    execute_program: 3,
    get_program_info: 1,
    validate_signature: 1,
    health_check: 0,
    get_stats: 0,
    cleanup: 0,
    supports_test_layer?: 1,
    get_test_capabilities: 0
  ]
end

defmodule DSPex.Adapters.Registry do
  @moduledoc """
  Registry for managing available adapters with 3-layer test integration.
  """
  
  @default_adapter DSPex.Adapters.PythonPort
  
  @adapters %{
    python_port: DSPex.Adapters.PythonPort,
    bridge_mock: DSPex.Adapters.BridgeMock,  # New for Layer 2
    mock: DSPex.Adapters.Mock,
    native: DSPex.Adapters.Native  # Future implementation
  }
  
  @test_layer_adapters %{
    mock_adapter: :mock,
    bridge_mock: :bridge_mock,
    full_integration: :python_port
  }
  
  def get_adapter(adapter_name \\ nil) do
    # Priority: explicit -> test mode -> config -> default
    resolved_adapter = 
      adapter_name || 
      get_test_mode_adapter() || 
      Application.get_env(:dspex, :adapter) ||
      @default_adapter
    
    case resolved_adapter do
      atom when is_atom(atom) and is_map_key(@adapters, atom) -> 
        Map.get(@adapters, atom)
      module when is_atom(module) -> 
        module
      string when is_binary(string) -> 
        String.to_existing_atom(string) |> get_adapter()
      _ -> 
        @default_adapter
    end
  end
  
  defp get_test_mode_adapter do
    if Mix.env() == :test do
      case DSPex.Testing.TestMode.current_test_mode() do
        test_mode when is_map_key(@test_layer_adapters, test_mode) ->
          Map.get(@test_layer_adapters, test_mode)
        _ -> 
          nil
      end
    end
  end
  
  def get_adapter_for_test_layer(layer) do
    case layer do
      :layer_1 -> Map.get(@adapters, :mock)
      :layer_2 -> Map.get(@adapters, :bridge_mock)
      :layer_3 -> Map.get(@adapters, :python_port)
      _ -> @default_adapter
    end
  end
  
  def list_adapters do
    Map.keys(@adapters)
  end
  
  def list_test_layer_adapters do
    @test_layer_adapters
  end
  
  def validate_adapter(adapter) do
    case Code.ensure_loaded(adapter) do
      {:module, _} ->
        if function_exported?(adapter, :create_program, 1) and
           function_exported?(adapter, :execute_program, 2) and
           function_exported?(adapter, :list_programs, 0) do
          {:ok, adapter}
        else
          {:error, "Adapter does not implement required callbacks: #{adapter}"}
        end
      {:error, reason} ->
        {:error, "Failed to load adapter #{adapter}: #{reason}"}
    end
  end
  
  def validate_test_layer_compatibility(adapter, test_layer) do
    if function_exported?(adapter, :supports_test_layer?, 1) do
      case adapter.supports_test_layer?(test_layer) do
        true -> {:ok, adapter}
        false -> {:error, "Adapter #{adapter} does not support test layer #{test_layer}"}
      end
    else
      # Assume compatibility if not implemented
      {:ok, adapter}
    end
  end
end

defmodule DSPex.Adapters.BridgeMock do
  @moduledoc """
  Bridge mock adapter for Layer 2 protocol testing.
  
  This adapter validates the wire protocol and message format without
  requiring full Python DSPy. It uses our existing BridgeMockServer
  to simulate the Python bridge communication layer.
  """
  
  @behaviour DSPex.Adapters.Adapter
  
  alias DSPex.Testing.BridgeMockServer
  alias DSPex.PythonBridge.Protocol
  
  @impl true
  def create_program(config) do
    # Convert signature to wire protocol format
    signature_def = convert_signature_to_wire_format(config.signature)
    
    # Send through mock bridge to validate protocol
    case send_mock_command(:create_program, %{
      id: config.id,
      signature: signature_def,
      modules: config.modules || []
    }) do
      {:ok, response} -> {:ok, config.id}
      {:error, reason} -> {:error, reason}
    end
  end
  
  @impl true
  def execute_program(program_id, inputs) do
    case send_mock_command(:execute_program, %{
      program_id: program_id,
      inputs: inputs
    }) do
      {:ok, response} -> 
        # Generate deterministic mock outputs based on protocol response
        {:ok, generate_protocol_compatible_outputs(inputs)}
      {:error, reason} -> 
        {:error, reason}
    end
  end
  
  @impl true
  def list_programs do
    case send_mock_command(:list_programs, %{}) do
      {:ok, response} -> {:ok, []}  # Mock empty list for protocol testing
      {:error, reason} -> {:error, reason}
    end
  end
  
  @impl true
  def delete_program(program_id) do
    case send_mock_command(:delete_program, %{program_id: program_id}) do
      {:ok, _response} -> :ok
      {:error, reason} -> {:error, reason}
    end
  end
  
  @impl true
  def health_check do
    case BridgeMockServer.ping() do
      {:ok, _} -> :ok
      {:error, reason} -> {:error, reason}
    end
  end
  
  @impl true
  def get_stats do
    {:ok, %{
      adapter_type: :bridge_mock,
      layer: :layer_2,
      protocol_validated: true,
      mock_server_running: BridgeMockServer.running?()
    }}
  end
  
  @impl true
  def cleanup do
    # No cleanup needed for mock
    :ok
  end
  
  @impl true
  def supports_test_layer?(layer) do
    layer == :layer_2
  end
  
  @impl true
  def get_test_capabilities do
    %{
      protocol_validation: true,
      wire_format_testing: true,
      python_execution: false,
      deterministic_outputs: true,
      performance: :fast
    }
  end
  
  defp send_mock_command(command, args) do
    # Use existing bridge mock server infrastructure
    case BridgeMockServer.handle_command(command, args) do
      {:ok, result} -> {:ok, result}
      {:error, reason} -> {:error, reason}
    end
  end
  
  defp convert_signature_to_wire_format(signature_module) do
    signature = signature_module.__signature__()
    
    %{
      inputs: convert_fields_to_wire_format(signature.inputs),
      outputs: convert_fields_to_wire_format(signature.outputs)
    }
  end
  
  defp convert_fields_to_wire_format(fields) do
    Enum.map(fields, fn {name, type, _constraints} ->
      %{
        name: to_string(name),
        type: convert_type_to_wire_format(type),
        description: ""
      }
    end)
  end
  
  defp convert_type_to_wire_format(:string), do: "str"
  defp convert_type_to_wire_format(:integer), do: "int"
  defp convert_type_to_wire_format(:float), do: "float"
  defp convert_type_to_wire_format(:boolean), do: "bool"
  defp convert_type_to_wire_format({:list, inner}), do: "List[#{convert_type_to_wire_format(inner)}]"
  defp convert_type_to_wire_format(type), do: to_string(type)
  
  defp generate_protocol_compatible_outputs(inputs) do
    # Generate deterministic outputs that validate protocol format
    %{
      "result" => "mock_protocol_validated_output",
      "confidence" => 0.95,
      "reasoning" => ["Protocol validation", "Wire format test"],
      "input_echo" => inputs
    }
  end
end

defmodule DSPex.Adapters.Mock do
  @moduledoc """
  Mock adapter for Layer 1 fast testing.
  
  Enhanced with test capabilities and integration with 3-layer architecture.
  """
  
  @behaviour DSPex.Adapters.Adapter
  
  use GenServer
  
  defstruct [
    programs: %{}, 
    call_log: [], 
    config: %{},
    stats: %{
      programs_created: 0,
      programs_executed: 0,
      total_calls: 0
    }
  ]
  
  def start_link(opts \\ []) do
    name = Keyword.get(opts, :name, __MODULE__)
    GenServer.start_link(__MODULE__, opts, name: name)
  end
  
  # ... existing core implementations ...
  
  @impl true
  def supports_test_layer?(layer) do
    layer == :layer_1
  end
  
  @impl true
  def get_test_capabilities do
    %{
      deterministic_outputs: true,
      call_logging: true,
      fast_execution: true,
      python_execution: false,
      protocol_validation: false,
      performance: :fastest
    }
  end
  
  # Enhanced with configurable behavior for different test scenarios
  def configure_behavior(config) do
    GenServer.call(__MODULE__, {:configure, config})
  end
  
  def get_call_log do
    GenServer.call(__MODULE__, :get_call_log)
  end
  
  def reset do
    GenServer.call(__MODULE__, :reset)
  end
  
  # ... rest of existing implementation with enhancements ...
end

defmodule DSPex.Adapters.PythonPort do
  @moduledoc """
  Python port adapter for Layer 3 full integration testing.
  
  Enhanced with test capabilities and robust error handling.
  """
  
  @behaviour DSPex.Adapters.Adapter
  
  alias DSPex.PythonBridge.Bridge
  alias DSPex.Adapters.TypeConverter
  
  # ... existing core implementations ...
  
  @impl true
  def supports_test_layer?(layer) do
    layer == :layer_3
  end
  
  @impl true
  def get_test_capabilities do
    %{
      python_execution: true,
      real_ml_models: true,
      protocol_validation: true,
      deterministic_outputs: false,
      performance: :slowest,
      requires_environment: [:python, :dspy, :api_keys]
    }
  end
  
  @impl true
  def health_check do
    case Bridge.call(:ping, %{}, 5000) do
      {:ok, _response} -> :ok
      {:error, reason} -> {:error, "Python bridge health check failed: #{reason}"}
    end
  end
  
  # ... enhanced implementations with better error handling ...
end

defmodule DSPex.Testing.TestMode do
  # ... existing functions ...
  
  @doc """
  Returns the appropriate adapter module for the current test mode.
  Now uses the Registry system for consistency.
  """
  @spec get_adapter_module() :: 
    DSPex.Adapters.Mock | DSPex.Adapters.BridgeMock | DSPex.Adapters.PythonPort
  def get_adapter_module do
    DSPex.Adapters.Registry.get_adapter()
  end
  
  def get_adapter_for_current_layer do
    case effective_test_mode() do
      :mock_adapter -> DSPex.Adapters.Registry.get_adapter_for_test_layer(:layer_1)
      :bridge_mock -> DSPex.Adapters.Registry.get_adapter_for_test_layer(:layer_2)
      :full_integration -> DSPex.Adapters.Registry.get_adapter_for_test_layer(:layer_3)
    end
  end
  
  def validate_adapter_compatibility do
    adapter = get_adapter_module()
    test_mode = effective_test_mode()
    
    case test_mode do
      :mock_adapter -> validate_layer_1_adapter(adapter)
      :bridge_mock -> validate_layer_2_adapter(adapter)
      :full_integration -> validate_layer_3_adapter(adapter)
    end
  end
  
  defp validate_layer_1_adapter(adapter) do
    capabilities = adapter.get_test_capabilities()
    
    if capabilities.fast_execution and capabilities.deterministic_outputs do
      :ok
    else
      {:error, "Adapter not suitable for Layer 1 fast testing"}
    end
  end
  
  defp validate_layer_2_adapter(adapter) do
    capabilities = adapter.get_test_capabilities()
    
    if capabilities.protocol_validation and not capabilities.python_execution do
      :ok
    else
      {:error, "Adapter not suitable for Layer 2 protocol testing"}
    end
  end
  
  defp validate_layer_3_adapter(adapter) do
    capabilities = adapter.get_test_capabilities()
    
    if capabilities.python_execution do
      :ok
    else
      {:error, "Adapter not suitable for Layer 3 integration testing"}
    end
  end
end