{# select or count over the threads or the queues of every addressed server.

   The columns are dynamic here, unlike the registry's fixed five: the thread
   table is 26 wide and a statement projects what it wants, so the row loop
   reads values by attribute rather than naming them. That is the same access
   the row matcher and the export use, which is what keeps a derived column
   rendering exactly as it filters. #}
<div class="result-view d-flex flex-column h-100"
     data-title="{{ outcome.verb }} {{ outcome.kind }}"
     data-icon-kind="{{ outcome.icon_kind }}" data-icon-id="{{ outcome.icon_id }}">
  <div class="result-toolbar d-flex align-items-center gap-2 px-2 py-1">
    <span class="badge text-bg-secondary text-uppercase">{{ t("threads.badge." ~ outcome.kind) }}</span>
    <span class="text-secondary small" aria-live="polite">
      {% if outcome.verb == "count" %}
        {{ t("results.hits") }}: {{ outcome.total }}
      {% else %}
        {{ t("results.rows", n=outcome.total) }}
        {% if outcome.truncated %}({{ t("results.rows_shown", n=outcome.rows|length) }}){% endif %}
      {% endif %}
    </span>
    {% if outcome.servers %}
      <span class="text-secondary small">
        {{ t("threads.servers", n=outcome.servers|length) }}: {{ outcome.servers|join(", ") }}
      </span>
    {% endif %}
  </div>

  {% for failure in outcome.errors %}
    <div class="alert alert-warning mx-2 mt-2 mb-0 py-2" role="alert">
      <i class="ph ph-warning" aria-hidden="true"></i>
      {{ t("threads.server_failed", server=failure.server, detail=failure.message) }}
    </div>
  {% endfor %}

  {% if outcome.verb == "count" %}
    <div class="p-3">
      <div class="count-total display-4 fw-semibold">{{ outcome.total }}</div>
      <div class="text-secondary">{{ t("results.hits") }}</div>
      {% if outcome.counts|length > 1 %}
        <ul class="list-unstyled mt-3 mb-0">
          {% for server, count in outcome.counts %}
            <li class="d-flex align-items-center gap-2 py-1">
              <i class="ph ph-hard-drives" aria-hidden="true"></i>
              <span class="flex-grow-1">{{ server }}</span>
              <span class="fw-semibold">{{ count }}</span>
            </li>
          {% endfor %}
        </ul>
      {% endif %}
    </div>
  {% elif not outcome.rows %}
    <div class="result-empty text-center text-secondary py-5">
      <i class="ph ph-cpu fs-1 d-block mb-2" aria-hidden="true"></i>
      {{ t("results.empty") }}
    </div>
  {% else %}
    <div class="table-scroll">
      <table class="table table-sm table-hover result-table result-table-mono mb-0">
        <thead>
          <tr>
            {% if outcome.kind == "threads" %}
              <th class="col-actions"><span class="visually-hidden">{{ t("results.actions") }}</span></th>
            {% endif %}
            {% for column in outcome.columns %}
              <th{% if column in outcome.numeric %} class="text-end"{% endif %}
                 title="{{ t('threads.doc.' ~ outcome.kind ~ '.' ~ column) }}">
                {{ t("threads." ~ outcome.kind ~ ".column." ~ column) }}
              </th>
            {% endfor %}
          </tr>
        </thead>
        <tbody>
          {% for row in outcome.rows %}
            <tr>
              {% if outcome.kind == "threads" %}
                <td class="col-actions">
                  {# Both statements are prefilled and never run from the
                     table, the way the registry's edit button works.

                     The break button is offered for every thread that has ever
                     run a job, not only one running right now: a snapshot is a
                     moment and the statement is written for later, so tying the
                     button to that moment made it unreachable in practice. A
                     running row pins the job number it saw; a finished row
                     leaves it out, so the runner reads whatever the thread is
                     doing when the statement is actually run. A thread that has
                     never been used gets no button, because there is nothing to
                     name. #}
                  {# The harmless read first, the destructive request second,
                     so the stack is what the hand reaches for by default. #}
                  <button type="button" class="btn btn-sm btn-link p-0 open-statement"
                          data-statement="select callstack of thread {{ row.threadid }} on '{{ row.server }}'"
                          aria-label="{{ t('threads.stack') }}" title="{{ t('threads.stack') }}">
                    <i class="ph ph-stack" aria-hidden="true"></i>
                  </button>
                  {% if not row.idle %}
                    <button type="button" class="btn btn-sm btn-link p-0 open-statement"
                            data-statement="break thread {{ row.threadid }}{% if row.running %} job {{ row.uniquenumber }}{% endif %} on '{{ row.server }}'"
                            aria-label="{{ t('threads.break') }}" title="{{ t('threads.break') }}">
                      <i class="ph ph-octagon text-danger" aria-hidden="true"></i>
                    </button>
                  {% endif %}
                </td>
              {% endif %}
              {% for column in outcome.columns %}
                {# attr reaches fields and derived properties alike, which is the
                   same access the matcher and the export use. #}
                {% set value = row|attr(column) %}
                {% if column == "server" %}
                  {# host:port is the identity a condition and an on clause
                     use; the machine's own name rides along muted. #}
                  <td class="text-nowrap">
                    {{ value }}
                    {% if row.computer %}<span class="text-secondary small">· {{ row.computer }}</span>{% endif %}
                  </td>
                {% elif column == "running" %}
                  {# The state of the row, as the job call monitor draws one: a
                     play sign while a job is on the thread, a check once it is
                     done. Danger rather than the monitor's info colour because
                     here a running job is the thing you came looking for. #}
                  <td class="text-center">
                    {% if value %}
                      <i class="ph-fill ph-play text-danger" aria-hidden="true"
                         title="{{ t('threads.state_running') }}"></i>
                      <span class="visually-hidden">{{ t("threads.state_running") }}</span>
                    {% elif row.idle %}
                      {# A plain hyphen, not a minus icon: the glyph reads as a
                         dash and dashes of that shape are not used here. Same
                         mark every empty cell in this table already shows. #}
                      <span class="text-secondary" title="{{ t('threads.state_unused') }}">-</span>
                      <span class="visually-hidden">{{ t("threads.state_unused") }}</span>
                    {% else %}
                      <i class="ph ph-check text-success" aria-hidden="true"
                         title="{{ t('threads.state_done') }}"></i>
                      <span class="visually-hidden">{{ t("threads.state_done") }}</span>
                    {% endif %}
                  </td>
                {% elif column == "idle" %}
                  <td class="text-center">
                    {% if value %}
                      {# Muted rather than the success colour: a thread nobody
                         has used is neither good nor bad. #}
                      <i class="ph ph-check text-secondary" aria-hidden="true"></i>
                      <span class="visually-hidden">{{ t("threads.yes") }}</span>
                    {% else %}
                      <span class="text-secondary">-</span>
                      <span class="visually-hidden">{{ t("threads.no") }}</span>
                    {% endif %}
                  </td>
                {% elif value is none %}
                  {# A running job has no stop time and an unused thread has no
                     times at all, so a null is an ordinary value here. #}
                  <td class="text-secondary{% if column in outcome.numeric %} text-end{% endif %}">-</td>
                {% elif column in outcome.numeric %}
                  <td class="text-end">{{ value|round(1) if value is float else value }}</td>
                {% elif column in outcome.stamps %}
                  <td class="text-nowrap">{{ value.strftime("%Y-%m-%d %H:%M:%S.") }}{{ "%03d"|format(value.microsecond // 1000) }}</td>
                {% else %}
                  <td>{{ value }}</td>
                {% endif %}
              {% endfor %}
            </tr>
          {% endfor %}
        </tbody>
      </table>
    </div>
  {% endif %}
</div>