"""Regression coverage for #2454 active-session stale sidebar spinner.

The backend can already reconcile stale stream state and return `/api/sessions`
rows with `is_streaming: false`, `active_stream_id: null`, and
`pending_user_message: null`. The remaining bug is frontend-local: the current
open session can keep `S.busy = true`, so `_isSessionLocallyStreaming()` still
makes the sidebar row render as streaming even after the server says idle.
"""

from pathlib import Path
import json
import subprocess

REPO = Path(__file__).resolve().parents[1]
SESSIONS_SRC = (REPO / "static" / "sessions.js").read_text(encoding="utf-8")


def _function_body(src: str, signature: str) -> str:
    start = src.find(signature)
    assert start != -1, f"missing {signature}"
    brace = src.find("{", start)
    assert brace != -1, f"missing opening brace for {signature}"
    depth = 0
    for i in range(brace, len(src)):
        ch = src[i]
        if ch == "{":
            depth += 1
        elif ch == "}":
            depth -= 1
            if depth == 0:
                return src[brace + 1 : i]
    raise AssertionError(f"could not extract function body for {signature}")


def test_active_session_idle_reconcile_clears_stale_busy_and_inflight_state():
    helper_body = _function_body(SESSIONS_SRC, "function _isServerIdleSessionRow(")
    body = _function_body(SESSIONS_SRC, "function _reconcileActiveSessionIdleStateFromList(")

    assert "serverRows" in body, "reconcile must inspect raw /api/sessions rows before optimistic merging"
    assert "S.session.session_id" in body, "reconcile must target the currently active session"
    assert "_sendInProgress" in body, "cleanup must not interrupt a send that has not received stream_id yet"
    assert "_isServerIdleSessionRow(serverRow)" in body, "server idle metadata must gate the cleanup"
    assert "!s.is_streaming" in helper_body, "server idle helper must require is_streaming=false"
    assert "!s.active_stream_id" in helper_body, "server idle helper must require no active stream id"
    assert "!s.pending_user_message" in helper_body, "server idle helper must require no pending user text"
    assert "!s.pending_started_at" in helper_body, "server idle helper must require no pending turn marker"
    assert "S.busy=false" in body, "stale local busy state must be cleared"
    assert "S.activeStreamId=null" in body, "stale active stream id must be cleared"
    assert "delete INFLIGHT[sid]" in body, "stale active-session inflight cache must be purged"
    assert "clearInflightState(sid)" in body, "persisted inflight cache must be cleared too"
    assert "_sessionStreamingById.set(sid, false)" in body, "observed active streaming state must be reset"
    assert "_forgetObservedStreamingSession(sid)" in body, "persisted observed streaming marker must be cleared"
    assert "updateSendBtn()" in body, "composer controls must reflect the idle state after cleanup"
    assert "hideApprovalCard(true)" in body, "stale approval UI must be cleared when server says the run is idle"
    assert "hideLiveRunStatus(sid)" in body, "stale live footer must be cleared when server says the run is idle"
    assert "clearLiveToolCards()" in body, "stale live-only tool cards must not survive idle reconciliation"
    assert "_scheduleActiveSessionIdleReload(sid)" in body, (
        "idle reconciliation must reload the current transcript from server truth "
        "so missed stream_end events do not leave the active pane stale"
    )


def test_effective_streaming_ignores_stale_raw_active_stream_ids():
    local_body = _function_body(SESSIONS_SRC, "function _isSessionLocallyStreaming(")
    pending_body = _function_body(SESSIONS_SRC, "function _hasPendingUserMessageSignal(")
    effective_body = _function_body(SESSIONS_SRC, "function _isSessionEffectivelyStreaming(")

    assert "s.active_stream_id" not in effective_body
    assert "_hasPendingUserMessageSignal(s)" in effective_body
    assert "s.pending_started_at" not in effective_body

    script = f"""
let S = {{ session: null, busy: false }};
function _isSessionLocallyStreaming(s) {{{local_body}}}
function _hasPendingUserMessageSignal(s) {{{pending_body}}}
function _isSessionEffectivelyStreaming(s) {{{effective_body}}}
const rows = {{
  serverStreaming: _isSessionEffectivelyStreaming({{session_id:'child', is_streaming:true, active_stream_id:'stream-1'}}),
  staleActiveStream: _isSessionEffectivelyStreaming({{session_id:'child', is_streaming:false, active_stream_id:'dead-stream'}}),
  pendingUser: _isSessionEffectivelyStreaming({{session_id:'child', pending_user_message:'working'}}),
  pendingFlag: _isSessionEffectivelyStreaming({{session_id:'child', has_pending_user_message:true}}),
  pendingStartedOnly: _isSessionEffectivelyStreaming({{session_id:'child', pending_started_at:123}}),
  idle: _isSessionEffectivelyStreaming({{session_id:'child'}}),
}};
console.log(JSON.stringify(rows));
"""
    result = subprocess.run(["node", "-e", script], check=True, capture_output=True, text=True)
    assert json.loads(result.stdout) == {
        "serverStreaming": True,
        "staleActiveStream": False,
        "pendingUser": True,
        "pendingFlag": True,
        "pendingStartedOnly": False,
        "idle": False,
    }


def test_active_session_idle_reconcile_schedules_forced_transcript_reload():
    helper_body = _function_body(SESSIONS_SRC, "function _scheduleActiveSessionIdleReload(")

    assert "setTimeout(async () =>" in helper_body
    assert "S.session.session_id !== sid" in helper_body
    assert "S.busy || S.activeStreamId" in helper_body
    assert "loadSession(sid, {force:true, externalRefreshReason:'idle-reconcile'})" in helper_body


def test_session_list_payload_reconciles_active_idle_state_before_optimistic_merge_and_render():
    body = _function_body(SESSIONS_SRC, "function _applySessionListPayload(")

    filter_pos = body.find("const serverSessions=_optimisticallyRemovedSessionIds.size")
    reconcile_pos = body.find("_reconcileActiveSessionIdleStateFromList(serverSessions)")
    merge_pos = body.find("_allSessions = _mergeOptimisticFirstTurnSessions")
    render_pos = body.find("renderSessionListFromCache()")

    assert filter_pos != -1, "payload application must filter optimistic removals before row reconciliation"
    assert reconcile_pos != -1, "active-session idle reconciliation must run for refreshed rows"
    assert merge_pos != -1, "session rows must still be applied from /api/sessions"
    assert render_pos != -1, "payload application must still render from cache"
    assert filter_pos < reconcile_pos < merge_pos < render_pos, (
        "local S.busy/INFLIGHT state must be reconciled against raw server rows "
        "before optimistic merging can re-label a stale active session as streaming"
    )


def test_optimistic_merge_does_not_resurrect_server_idle_session_from_stale_cache():
    helper_body = _function_body(SESSIONS_SRC, "function _isServerIdleSessionRow(")
    local_body = _function_body(SESSIONS_SRC, "function _isSessionLocallyStreaming(")
    optimistic_body = _function_body(SESSIONS_SRC, "function _isOptimisticFirstTurnSessionRow(")
    merge_body = _function_body(SESSIONS_SRC, "function _mergeOptimisticFirstTurnSessions(")

    assert "fetchedIsServerIdle" in merge_body, "merge must detect server-idle fetched rows"
    assert "active_stream_id:fetchedIsServerIdle?null" in merge_body
    assert "pending_user_message:fetchedIsServerIdle?null" in merge_body
    assert "pending_started_at:fetchedIsServerIdle?null" in merge_body
    assert "is_streaming:fetchedIsServerIdle?false" in merge_body

    script = f"""
let S = {{ session: null, busy: false }};
let _sessionStreamingById = new Map();
let _allSessions = [{{
  session_id: 'dogfood-session',
  title: 'Dogfood Docs Routing Review',
  message_count: 50,
  last_message_at: 1000,
  updated_at: 1000,
  active_stream_id: 'stale-stream',
  pending_user_message: 'stale pending text',
  pending_started_at: 900,
  is_streaming: true,
}}];
function _isServerIdleSessionRow(s) {{{helper_body}}}
function _isSessionLocallyStreaming(s) {{{local_body}}}
function _isOptimisticFirstTurnSessionRow(s) {{{optimistic_body}}}
function _mergeOptimisticFirstTurnSessions(fetchedSessions) {{{merge_body}}}
const merged = _mergeOptimisticFirstTurnSessions([{{
  session_id: 'dogfood-session',
  title: 'Dogfood Docs Routing Review',
  message_count: 50,
  last_message_at: 1100,
  updated_at: 1100,
  active_stream_id: null,
  pending_user_message: null,
  pending_started_at: null,
  is_streaming: false,
}}]);
console.log(JSON.stringify(merged[0]));
"""
    result = subprocess.run(["node", "-e", script], check=True, capture_output=True, text=True)
    row = json.loads(result.stdout)

    assert row["session_id"] == "dogfood-session"
    assert row["message_count"] == 50
    assert row["active_stream_id"] is None
    assert row["pending_user_message"] is None
    assert row["pending_started_at"] is None
    assert row["is_streaming"] is False


def test_optimistic_merge_preserves_server_running_state_when_local_cache_is_stale():
    """If the server still says running, stale local optimism must not hide the spinner."""
    helper_body = _function_body(SESSIONS_SRC, "function _isServerIdleSessionRow(")
    local_body = _function_body(SESSIONS_SRC, "function _isSessionLocallyStreaming(")
    optimistic_body = _function_body(SESSIONS_SRC, "function _isOptimisticFirstTurnSessionRow(")
    keep_body = _function_body(SESSIONS_SRC, "function _shouldKeepLocalOnlyOptimisticSessionRow(")
    drop_body = _function_body(SESSIONS_SRC, "function _dropStaleOptimisticSessionRow(")
    owner_body = _function_body(SESSIONS_SRC, "function _hasOwnedOpenLiveStream(")
    merge_body = _function_body(SESSIONS_SRC, "function _mergeOptimisticFirstTurnSessions(")

    script = f"""
let S = {{ session: null, busy: false }};
let _sendInProgress = false;
let _sendInProgressSid = null;
let INFLIGHT = {{}};
let _sessionStreamingById = new Map();
let _allSessions = [{{
  session_id: 'dogfood-session',
  title: 'Local stale optimistic row',
  message_count: 1,
  last_message_at: 1000,
  updated_at: 1000,
  active_stream_id: 'stale-local-stream',
  pending_user_message: 'stale pending text',
  pending_started_at: 900,
  is_streaming: true,
}}];
function _isServerIdleSessionRow(s) {{{helper_body}}}
function _isSessionLocallyStreaming(s) {{{local_body}}}
function _isOptimisticFirstTurnSessionRow(s) {{{optimistic_body}}}
function _shouldKeepLocalOnlyOptimisticSessionRow(local) {{{keep_body}}}
function _hasOwnedOpenLiveStream(sid) {{{owner_body}}}
function _dropStaleOptimisticSessionRow(sid) {{{drop_body}}}
function _mergeOptimisticFirstTurnSessions(fetchedSessions) {{{merge_body}}}
const merged = _mergeOptimisticFirstTurnSessions([{{
  session_id: 'dogfood-session',
  title: 'Server running row',
  message_count: 2,
  last_message_at: 1100,
  updated_at: 1100,
  active_stream_id: null,
  pending_user_message: null,
  pending_started_at: null,
  is_streaming: true,
}}]);
console.log(JSON.stringify(merged[0]));
"""
    result = subprocess.run(["node", "-e", script], check=True, capture_output=True, text=True)
    row = json.loads(result.stdout)

    assert row["session_id"] == "dogfood-session"
    assert row["title"] == "Server running row"
    assert row["message_count"] == 2
    assert row["is_streaming"] is True