@doc "How many threads one account may hold open at once, or `nil` for no limit."

  @spec maximum_open_per_account() :: pos_integer() | nil

  @doc """

  What a thread has spent, summed across every grant it has ever held.

  A thread's authority is re-minted on resume — each mint is a new grant with

  a new generation — so the calls and tokens a session cost are spread across

  grants rather than sitting on one. Summing them is the only honest answer to

  "what did this session cost": reading the live grant alone reports a resumed

  session as though it had just started.

  Absent stays absent. A dimension no provider reported is not summed into

  existence as a zero, because a zero reads as a measurement and this is the

  absence of one (#220).

  """

  @spec spend(Thread.t() | String.t()) :: %{

          calls: non_neg_integer(),

          grants: non_neg_integer(),

          usage: map()

        }

  def spend(%Thread{id: thread_id}), do: spend(thread_id)

  def spend(thread_id) when is_binary(thread_id) do

    grants =

      from(grant in Grant,

        where: grant.thread_id == ^thread_id,

        select: {grant.call_count, grant.usage}

      )

      |> Repo.all()

    usage =

      Enum.reduce(grants, %{}, fn {_calls, usage}, acc ->

        Enum.reduce(usage || %{}, acc, fn

          {key, value}, inner when is_integer(value) -> Map.update(inner, key, value, &(&1 + value))

          {_key, _value}, inner -> inner

        end)

      end)

    %{

      calls: Enum.sum(Enum.map(grants, fn {calls, _usage} -> calls || 0 end)),

      grants: length(grants),

      usage: usage

    }

  end

  def maximum_open_per_account, do: setting(:maximum_open_threads_per_account, nil)

  @doc "How many threads this account currently holds open."

      "report" => thread.report,

      "error_code" => thread.error_code,

      "started_at" => stamp(thread.started_at),

      "completed_at" => stamp(thread.completed_at)

      "completed_at" => stamp(thread.completed_at),

      # What the session cost, summed across every grant this thread has held

      # (#132). A resumed thread re-mints, so the live grant alone would

      # under-report; a dimension no provider gave is absent rather than zero.

      "spend" => spend_view(thread)

    }

  end

  defp spend_view(%Thread{} = thread) do

    spend = Threads.spend(thread)

    %{"calls" => spend.calls, "grants" => spend.grants, "usage" => spend.usage}

  end

  # The plaintext token exists exactly once, here. Everything else in this map

  # is what a client needs to spend it: where to send the call, which model the

  # proxy will pin, when the authority ends, and what it may spend.

    {:reap_expired, 1} => :scoped_by_owner,

    {:record_event, 3} => :thread_struct,

    {:record_events, 2} => :thread_struct,

    {:spend, 1} => :thread_struct,

    {:subscribe, 1} => :thread_struct

  }

    Application.put_env(:openagents, :thread_grant_ttl_seconds, -1)

    on_exit(fn -> Application.put_env(:openagents, :thread_grant_ttl_seconds, previous) end)

  end

  describe "what a thread spent" do

    test "sums calls and usage across every grant the thread has held" do

      user = owner("spend-sums")

      {:ok, thread, grant, _token} = Threads.open_and_mint(user, "Spend some")

      {:ok, _} = Inference.record_usage(grant, %{"input_tokens" => 100, "output_tokens" => 10})

      # Resuming re-mints: the second grant is where later spend lands, and a

      # reader asking what the session cost must see both.

      {:ok, resumed, second, _token} = Threads.mint_grant(thread)

      {:ok, _} = Inference.record_usage(second, %{"input_tokens" => 40, "output_tokens" => 5})

      spend = Threads.spend(resumed)

      assert spend.grants == 2

      assert spend.calls == 2

      assert spend.usage["input_tokens"] == 140

      assert spend.usage["output_tokens"] == 15

    end

    test "a dimension no provider reported is absent rather than zero" do

      user = owner("spend-partial")

      {:ok, thread, grant, _token} = Threads.open_and_mint(user, "Partial usage")

      {:ok, _} = Inference.record_usage(grant, %{"input_tokens" => 7})

      spend = Threads.spend(thread)

      assert spend.usage["input_tokens"] == 7

      refute Map.has_key?(spend.usage, "cache_read_input_tokens")

    end

    test "a thread that never spent reports nothing spent" do

      user = owner("spend-none")

      {:ok, thread} = Threads.open(user, "Never spent")

      assert Threads.spend(thread) == %{calls: 0, grants: 0, usage: %{}}

    end

  end

end