require Logger

  alias OpenAgents.Analytics

  alias OpenAgents.Inference

  alias OpenAgents.Inference.Models

  alias OpenAgents.Providers.{Request, ToolDefinition, ToolOutput}

  # ── run + translate ─────────────────────────────────────────────────────

  defp run(conn, grant, model, request) do

    selection = selection_properties(grant, model, request, conn.body_params)

    Analytics.capture("inference_model_selected", analytics_distinct_id(grant), selection)

    parent = self()

    # The provider pushes events synchronously; capture them to this process's

        # answered, not what it assumed (PROVIDER-002).

        label = model_label(model, served)

        Analytics.capture(

          "inference_model_served",

          analytics_distinct_id(grant),

          Map.merge(selection, %{

            "served_model" => label,

            "served_model_disclosed" => served != :unresolved,

            "outcome" => "served",

            "usage_reported" => usage != %{}

          })

        )

        conn

        |> put_resp_content_type("text/event-stream")

        |> put_resp_header("cache-control", "no-store")

            if(status == nil, do: "", else: " upstream_status=#{status}")

        )

        Analytics.capture(

          "inference_model_failed",

          analytics_distinct_id(grant),

          Map.merge(selection, %{

            "outcome" => "provider_failed",

            "reason_code" => class,

            "upstream_status" => status,

            "usage_reported" => usage != %{}

          })

        )

        refuse(conn, {:provider_failed, class, status})

    end

  end

  defp meter(grant, usage, _served) when usage == %{}, do: {:ok, grant}

  defp meter(grant, usage, served), do: Inference.record_usage(grant, usage, served)

  # This is the complete non-secret selection record for one provider call.

  # It deliberately excludes the bearer grant, prompts, instructions, and tool

  # arguments. The grant's visitor id becomes the analytics distinct id only;

  # it is not an event property.

  defp selection_properties(grant, model, request, body) do

    requested = Map.get(body, "model")

    %{

      "selection_schema" => "inference_model_selection.v1",

      "selection_surface" => "inference_proxy",

      "requested_model" => requested,

      "requested_model_present" => is_binary(requested) and requested != "",

      "grant_model" => grant.model_id,

      "selected_model" => model.id,

      "provider" => Atom.to_string(model.provider),

      "provider_model" => model.provider_model,

      "model_availability" => Models.availability(model),

      "model_available" => Models.available?(model),

      "adapter_substitutable" => substitutable?(model.adapter),

      "request_model" => request.model_id,

      "max_output_tokens" => request.max_output,

      "input_message_count" => length(request.input),

      "tool_definition_count" => length(request.tool_definitions),

      "tool_output_count" => length(request.tool_outputs),

      "grant_call_count_before" => grant.call_count,

      "grant_max_calls" => grant.max_calls,

      "grant_max_total_tokens" => grant.max_total_tokens,

      "grant_max_cost_microusd" => grant.max_cost_microusd,

      "grant_has_thread_fence" => is_binary(grant.thread_id),

      "grant_has_conversation_fence" => is_binary(grant.conversation_id)

    }

  end

  defp analytics_distinct_id(grant),

    do: Analytics.distinct_id("visitor_" <> grant.owner_visitor_id)

  # Which model actually served this call.

  #

  # `:requested` where the response named the model the grant pins, and where a

  alias OpenAgents.Providers.RecordingTestProvider

  alias OpenAgents.Repo

  defmodule AnalyticsSink do

    def capture(event, distinct_id, properties) do

      send(:inference_proxy_analytics_test, {:analytics, event, distinct_id, properties})

      :ok

    end

  end

  setup do

    Process.register(self(), :inference_proxy_analytics_test)

    original_token = Application.get_env(:openagents, :posthog_project_token)

    original_sink = Application.get_env(:openagents, :analytics_sink)

    Application.put_env(:openagents, :posthog_project_token, "phc_test_token")

    Application.put_env(:openagents, :analytics_sink, AnalyticsSink)

    on_exit(fn ->

      if is_nil(original_token),

        do: Application.delete_env(:openagents, :posthog_project_token),

        else: Application.put_env(:openagents, :posthog_project_token, original_token)

      if is_nil(original_sink),

        do: Application.delete_env(:openagents, :analytics_sink),

        else: Application.put_env(:openagents, :analytics_sink, original_sink)

    end)

  end

  defp grant(key, options \\ []) do

    owner = github_user("proxy-#{key}")

    {:ok, conversation} = OpenAgents.Conversations.ensure_conversation(owner)

  test "a valid grant proxies a chat completion and meters usage", %{conn: conn} do

    %{grant: grant, token: token} = grant("ok")

    {:ok, default} = Models.fetch(Models.default_id())

    conn =

      post_chat(conn, token, %{

    assert metered.call_count == 1

    assert metered.usage["total_tokens"] == 12

    assert metered.usage["estimated_cost_microusd"] > 0

    assert_receive {:analytics, "inference_model_selected", distinct_id, selected}

    assert distinct_id =~ "visitor_"

    assert selected["selection_schema"] == "inference_model_selection.v1"

    assert selected["requested_model"] == Models.default_id()

    assert selected["grant_model"] == Models.default_id()

    assert selected["selected_model"] == Models.default_id()

    assert selected["provider_model"] == default.provider_model

    assert selected["input_message_count"] == 1

    assert selected["tool_definition_count"] == 0

    assert selected["tool_output_count"] == 0

    assert selected["grant_has_conversation_fence"]

    refute selected["grant_has_thread_fence"]

    assert_receive {:analytics, "inference_model_served", ^distinct_id, served}

    assert served["served_model"] == Models.default_id()

    assert served["outcome"] == "served"

  end

  test "a reasoning stream survives translation as delta.reasoning", %{conn: conn} do