"""Tests for MuseHub web UI endpoints.

Covers (compare view):
- test_compare_page_renders — GET /{owner}/{slug}/compare/{base}...{head} returns 200
- test_compare_page_no_auth_required — compare page accessible without JWT
- test_compare_page_invalid_ref_404 — refs without ... separator return 404
- test_compare_page_unknown_owner_404 — unknown owner/slug returns 404
- test_compare_page_includes_radar — SSR: all five dimension names present in HTML (replaces JS radar)
- test_compare_page_includes_piano_roll — SSR: dimension table header columns in HTML (replaces piano roll JS)
- test_compare_page_includes_emotion_diff — SSR: Change delta column present (replaces emotion diff JS)
- test_compare_page_includes_commit_list — SSR: all dimension rows present (replaces commit list JS)
- test_compare_page_includes_create_pr_button — SSR: both ref names in heading (replaces PR button CTA)
- test_compare_json_response — SSR: response is text/html with dimension data (no JSON negotiation)
- test_compare_unknown_ref_404 — unknown ref returns 404


Covers acceptance criteria (commit list page):
- test_commits_list_page_returns_200 — GET /{owner}/{repo}/commits returns HTML
- test_commits_list_page_shows_commit_sha — SHA of seeded commit appears in page
- test_commits_list_page_shows_commit_message — message appears in page
- test_commits_list_page_dag_indicator — DAG node element present
- test_commits_list_page_pagination_links — Older/Newer nav links present when multi-page
- test_commits_list_page_branch_selector — branch <select> present when branches exist
- test_commits_list_page_json_content_negotiation — ?format=json returns CommitListResponse
- test_commits_list_page_json_pagination — ?format=json&per_page=1&page=2 returns page 2
- test_commits_list_page_branch_filter_html — ?branch=main filters to that branch
- test_commits_list_page_empty_state — repo with no commits shows empty state
- test_commits_list_page_merge_indicator — merge commit shows merge indicator
- test_commits_list_page_graph_link — link to DAG graph page present

Covers the minimum acceptance criteria and :
- test_ui_repo_page_returns_200 — GET /{repo_id} returns HTML
- test_ui_commit_page_shows_artifact_links — commit page HTML mentions img/download
- test_ui_pr_list_page_returns_200 — PR list page renders without error
- test_ui_issue_list_page_returns_200 — Issue list page renders without error
- test_ui_issue_list_has_open_closed_tabs — Open/Closed tab buttons present
- test_ui_issue_list_has_sort_controls — Sort buttons (newest/oldest/most-commented) present
- test_ui_issue_list_has_label_filter_js — Client-side label filter JS present
- test_ui_issue_list_has_body_preview_js — Body preview helper and CSS class present
- test_ui_issue_detail_has_comment_section — Comment thread section below issue body
- test_ui_issue_detail_has_render_comments_js — buildCommentThread() renders the comment thread
- test_ui_issue_detail_has_submit_comment_js — submitComment() posts new comments
- test_ui_issue_detail_has_delete_comment_js — deleteComment() removes own comments
- test_ui_issue_detail_has_reply_support_js — startReply() enables threaded replies
- test_ui_issue_detail_comment_section_below_body — comment section follows issue body card
- test_ui_pr_list_has_comment_badge_js — PR list has comment count badge JS
- test_ui_pr_list_has_reaction_pills_js — PR list has reaction pills JS
- test_ui_issue_list_has_reaction_pills_js — Issue list has reaction pills JS
- test_ui_issue_list_eager_social_signals — Issue list eagerly pre-fetches social signals
- test_context_page_renders — context viewer page returns 200 HTML
- test_context_json_response — JSON returns MuseHubContextResponse structure
- test_context_includes_musical_state — response includes active_tracks field
- test_context_unknown_ref_404 — nonexistent ref returns 404

Covers acceptance criteria (tree browser):
- test_tree_root_lists_directories
- test_tree_subdirectory_lists_files
- test_tree_file_icons_by_type
- test_tree_breadcrumbs_correct
- test_tree_json_response
- test_tree_unknown_ref_404

Covers acceptance criteria (embed player):
- test_embed_page_renders — GET /{repo_id}/embed/{ref} returns 200
- test_embed_no_auth_required — Public embed accessible without JWT
- test_embed_page_x_frame_options — Response sets X-Frame-Options: ALLOWALL
- test_embed_page_contains_player_ui — Player elements present in embed HTML

Covers (emotion map page), migrated to owner/slug routing:
- test_emotion_page_renders — GET /{owner}/{repo_slug}/insights/{ref}/emotion returns 200
- test_emotion_page_no_auth_required — emotion UI page accessible without JWT
- test_emotion_page_includes_charts — page embeds valence-arousal plot and axis labels
- test_emotion_page_includes_filters — page includes primary emotion and confidence display
- test_emotion_json_response — JSON endpoint returns emotion map with required fields
- test_emotion_trajectory — cross-commit trajectory data is present and ordered
- test_emotion_drift_distances — drift list has one entry per consecutive commit pair

Covers (rich event cards in activity feed):
- test_feed_page_returns_200 — GET /feed returns 200 HTML
- test_feed_page_no_raw_json_payload — page does not render raw JSON.stringify of payload
- test_feed_page_has_event_meta_for_all_types — EVENT_META covers all 8 event types
- test_feed_page_has_data_notif_id_attribute — cards carry data-notif-id for mark-as-read hook
- test_feed_page_has_unread_indicator — unread highlight border logic present
- test_feed_page_has_actor_avatar_logic — actorAvatar / actorHsl helper present
- test_feed_page_has_relative_timestamp — fmtRelative called in card rendering

Covers (mark-as-read UX in activity feed):
- test_feed_page_has_mark_one_read_function — markOneRead() defined for per-card action
- test_feed_page_has_mark_all_read_function — markAllRead() defined for bulk action
- test_feed_page_has_decrement_nav_badge_function — decrementNavBadge() keeps badge in sync
- test_feed_page_mark_read_btn_targets_notification_endpoint — calls POST /notifications/{id}/read
- test_feed_page_mark_all_btn_targets_read_all_endpoint — calls POST /notifications/read-all
- test_feed_page_mark_all_btn_present_in_template — mark-all-read-btn element in page HTML
- test_feed_page_mark_read_updates_nav_badge — nav-notif-badge updated after mark-all

UI routes require no JWT auth (they return HTML shells whose JS handles auth).
The HTML content tests assert structural markers present in every rendered page.

Covers (release detail comment threads):
- test_ui_release_detail_has_comment_section — Discussion section present in HTML
- test_ui_release_detail_has_render_comments_js — renderComments/submitComment/deleteComment JS present
- test_ui_release_detail_comment_uses_release_target_type — target_type='release' used in JS
- test_ui_release_detail_has_reply_thread_js — toggleReplyForm/submitReply for thread support

Covers (commit comment threads):
- test_commit_page_has_comment_section_html — comments-section container present in HTML
- test_commit_page_has_comment_js_functions — renderComments/submitComment/deleteComment/loadComments JS present
- test_commit_page_comment_calls_load_on_startup — loadComments() called at page startup
- test_commit_page_comment_uses_correct_api_path — fetches /comments?target_type=commit
- test_commit_page_comment_has_avatar_logic — avatarColor() HSL helper present
- test_commit_page_comment_has_new_comment_form — new-comment textarea form present
- test_commit_page_comment_has_discussion_heading"Discussion" heading present

Covers regression for PR #282 (owner/slug URL scheme):
- test_ui_nav_links_use_owner_slug_not_uuid_* — every page handler injects
  ``const base = '/{owner}/{slug}'`` not a UUID-based path.
- test_ui_unknown_owner_slug_returns_404 — bad owner/slug → 404.

Covers (analysis dashboard):
- test_analysis_dashboard_renders — GET /{owner}/{slug}/insights/{ref} returns 200
- test_analysis_dashboard_no_auth_required — accessible without JWT
- test_analysis_dashboard_all_dimension_labels — 10 dimension labels present in HTML
- test_analysis_dashboard_sparkline_logic_present — sparkline JS present
- test_analysis_dashboard_card_links_to_dimensions — /insights/ path in page
See also test_musehub_analysis.py::test_analysis_aggregate_endpoint_returns_all_dimensions

Covers (branch list and tag browser):
- test_branches_page_lists_all — GET /{owner}/{slug}/branches returns 200 HTML
- test_branches_default_marked — default branch badge present in JSON response
- test_branches_compare_link — compare link JS present on branches page
- test_branches_new_pr_button — new pull request link JS present
- test_branches_json_response — JSON returns BranchDetailListResponse with ahead/behind
- test_tags_page_lists_all — GET /{owner}/{slug}/tags returns 200 HTML
- test_tags_namespace_filter — namespace filter JS present on tags page
- test_tags_json_response — JSON returns TagListResponse with namespace grouping

Covers (audio player — listen page):
- test_listen_page_renders — GET /{owner}/{slug}/view/{ref} returns 200
- test_listen_page_no_auth_required — listen page accessible without JWT
- test_listen_page_contains_waveform_ui — waveform container and controls present
- test_listen_page_contains_play_button — play button element present in HTML
- test_listen_page_contains_speed_selector — speed selector element present
- test_listen_page_contains_ab_loop_ui — A/B loop controls present
- test_listen_page_loads_wavesurfer_vendor — page loads vendored wavesurfer.min.js (no CDN)
- test_listen_page_loads_audio_player_js — page loads audio-player.js component script
- test_listen_track_page_renders — GET /{owner}/{slug}/view/{ref}/{path} returns 200
- test_listen_track_page_has_track_path_in_js — track path injected into page JS context
- test_listen_page_unknown_repo_404 — bad owner/slug → 404
- test_listen_page_keyboard_shortcuts_documented — keyboard shortcuts mentioned in page
"""
from __future__ import annotations

from datetime import UTC, datetime, timedelta, timezone

import pytest
from httpx import AsyncClient
from sqlalchemy.ext.asyncio import AsyncSession

from musehub.db.musehub_models import (
    MusehubBranch,
    MusehubCommit,
    MusehubFollow,
    MusehubFork,
    MusehubObject,
    MusehubProfile,
    MusehubRelease,
    MusehubRepo,
    MusehubSession,
    MusehubStar,
    MusehubWatch,
)


# ---------------------------------------------------------------------------
# Helpers
# ---------------------------------------------------------------------------


async def _make_repo(db_session: AsyncSession) -> str:
    """Seed a minimal repo and return its repo_id."""
    repo = MusehubRepo(
        name="test-beats",
        owner="testuser",
        slug="test-beats",
        visibility="private",
        owner_user_id="test-owner",
    )
    db_session.add(repo)
    await db_session.commit()
    await db_session.refresh(repo)
    return str(repo.repo_id)


_TEST_USER_ID = "550e8400-e29b-41d4-a716-446655440000"


async def _make_profile(db_session: AsyncSession, username: str = "testmusician") -> MusehubProfile:
    """Seed a minimal profile and return it."""
    profile = MusehubProfile(
        user_id=_TEST_USER_ID,
        username=username,
        bio="Test bio",
        avatar_url=None,
        pinned_repo_ids=[],
    )
    db_session.add(profile)
    await db_session.commit()
    await db_session.refresh(profile)
    return profile


async def _make_public_repo(db_session: AsyncSession) -> str:
    """Seed a public repo for the test user and return its repo_id."""
    repo = MusehubRepo(
        name="public-beats",
        owner="testuser",
        slug="public-beats",
        visibility="public",
        owner_user_id=_TEST_USER_ID,
    )
    db_session.add(repo)
    await db_session.commit()
    await db_session.refresh(repo)
    return str(repo.repo_id)


# ---------------------------------------------------------------------------
# UI route tests (no auth required — routes return HTML)
# ---------------------------------------------------------------------------


@pytest.mark.anyio
async def test_ui_repo_page_returns_200(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /{repo_id} returns 200 HTML without requiring a JWT."""
    repo_id = await _make_repo(db_session)
    response = await client.get("/testuser/test-beats")
    assert response.status_code == 200
    assert "text/html" in response.headers["content-type"]
    body = response.text
    # Verify shared chrome is present
    assert "MuseHub" in body
    assert "test-beats" in body  # repo slug is shown in the page header/title
    # Verify page-specific content is present (repo home page — file tree + clone section)
    assert "file-tree" in body or "Empty repository" in body


@pytest.mark.anyio
async def test_ui_commit_page_shows_artifact_links(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /{owner}/{slug}/commits/{commit_id} returns SSR HTML for a known commit.

    Post-SSR migration (issue #583): commit_page() now requires the commit to exist in the
    DB (returns 404 otherwise) and renders metadata + comments server-side.
    """
    from datetime import datetime, timezone
    from musehub.db.musehub_models import MusehubCommit

    repo_id = await _make_repo(db_session)
    commit_id = "abc1234567890abcdef1234567890abcdef12345678"
    commit = MusehubCommit(
        commit_id=commit_id,
        repo_id=repo_id,
        branch="main",
        parent_ids=[],
        message="Add bridge section",
        author="testuser",
        timestamp=datetime.now(tz=timezone.utc),
    )
    db_session.add(commit)
    await db_session.commit()

    response = await client.get(f"/testuser/test-beats/commits/{commit_id}")
    assert response.status_code == 200
    assert "text/html" in response.headers["content-type"]
    body = response.text
    # SSR: commit message and metadata appear server-side
    assert "Add bridge section" in body
    assert "testuser" in body
    # Diff link is always present (view/play link only appears when audio_url is set)
    assert f"/commits/{commit_id}/diff" in body


@pytest.mark.anyio
async def test_ui_pr_list_page_returns_200(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /{repo_id}/pulls returns 200 HTML without requiring a JWT."""
    repo_id = await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/pulls")
    assert response.status_code == 200
    assert "text/html" in response.headers["content-type"]
    body = response.text
    assert "Pull Requests" in body
    assert "MuseHub" in body
    # State filter select element must be present in the JS
    assert "state" in body


@pytest.mark.anyio
async def test_ui_pr_list_has_state_tabs(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """PR list page includes Open, Merged, Closed, and All HTMX tab links with counts."""
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/pulls")
    assert response.status_code == 200
    body = response.text
    assert "Open" in body
    assert "Merged" in body
    assert "Closed" in body
    assert "All" in body
    assert "state=merged" in body


@pytest.mark.anyio
async def test_ui_pr_list_has_body_preview_js(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """PR list page SSR renders PR body previews via the pr_rows fragment."""
    import uuid
    from musehub.db.musehub_models import MusehubPullRequest
    repo_id = await _make_repo(db_session)
    pr_id = uuid.uuid4().hex
    db_session.add(MusehubPullRequest(
        pr_id=pr_id, repo_id=repo_id, title="Preview PR",
        body="This is the body preview text.", state="open",
        from_branch="feat/preview", to_branch="main", author="testuser",
    ))
    await db_session.commit()
    response = await client.get("/testuser/test-beats/pulls")
    assert response.status_code == 200
    body = response.text
    assert "pr-rows" in body
    assert "Preview PR" in body


@pytest.mark.anyio
async def test_ui_pr_list_has_branch_pills(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """PR list page SSR renders branch-pill indicators for from/to branches."""
    import uuid
    from musehub.db.musehub_models import MusehubPullRequest
    repo_id = await _make_repo(db_session)
    pr_id = uuid.uuid4().hex
    db_session.add(MusehubPullRequest(
        pr_id=pr_id, repo_id=repo_id, title="Branch pills PR", body="",
        state="open", from_branch="feat/my-feature", to_branch="main", author="testuser",
    ))
    await db_session.commit()
    response = await client.get("/testuser/test-beats/pulls")
    assert response.status_code == 200
    body = response.text
    assert "branch-pill" in body
    assert "feat/my-feature" in body


@pytest.mark.anyio
async def test_ui_pr_list_has_sort_controls(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """PR list page HTML includes Newest and Oldest sort buttons."""
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/pulls")
    assert response.status_code == 200
    body = response.text
    assert "Newest" in body
    assert "Oldest" in body
    assert "sort-btn" in body


@pytest.mark.anyio
async def test_ui_pr_list_has_merged_badge_markup(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """PR list page SSR renders a Merged badge with merge commit short-SHA link for merged PRs."""
    import uuid
    from musehub.db.musehub_models import MusehubPullRequest
    repo_id = await _make_repo(db_session)
    pr_id = uuid.uuid4().hex
    commit_id = uuid.uuid4().hex
    db_session.add(MusehubPullRequest(
        pr_id=pr_id, repo_id=repo_id, title="Merged PR", body="",
        state="merged", from_branch="feat/merged", to_branch="main",
        author="testuser", merge_commit_id=commit_id,
    ))
    await db_session.commit()
    response = await client.get("/testuser/test-beats/pulls?state=merged")
    assert response.status_code == 200
    body = response.text
    assert "Merged" in body
    assert commit_id[:8] in body


@pytest.mark.anyio
async def test_ui_pr_list_has_closed_badge_markup(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """PR list page SSR renders a Closed badge for closed PRs."""
    import uuid
    from musehub.db.musehub_models import MusehubPullRequest
    repo_id = await _make_repo(db_session)
    pr_id = uuid.uuid4().hex
    db_session.add(MusehubPullRequest(
        pr_id=pr_id, repo_id=repo_id, title="Closed PR", body="",
        state="closed", from_branch="feat/closed", to_branch="main", author="testuser",
    ))
    await db_session.commit()
    response = await client.get("/testuser/test-beats/pulls?state=closed")
    assert response.status_code == 200
    body = response.text
    assert "Closed" in body


@pytest.mark.anyio
async def test_ui_issue_list_page_returns_200(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /{repo_id}/issues returns 200 HTML without requiring a JWT."""
    repo_id = await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/issues")
    assert response.status_code == 200
    assert "text/html" in response.headers["content-type"]
    body = response.text
    assert "Issues" in body
    assert "MuseHub" in body


@pytest.mark.anyio
async def test_ui_issue_list_has_open_closed_tabs(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Issue list page HTML includes Open and Closed stat bars with counts."""
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/issues")
    assert response.status_code == 200
    body = response.text
    assert "Open" in body
    assert "Closed" in body
    assert "isl-stat-num" in body


@pytest.mark.anyio
async def test_ui_issue_list_has_sort_controls(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Issue list page HTML includes Newest, Oldest, and Most commented sort controls."""
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/issues")
    assert response.status_code == 200
    body = response.text
    assert "Newest" in body
    assert "Oldest" in body
    assert "Most commented" in body
    assert "isl-filter-select" in body


@pytest.mark.anyio
async def test_ui_issue_list_has_label_filter_js(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Issue list page HTML includes filter controls in the filter bar."""
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/issues")
    assert response.status_code == 200
    body = response.text
    assert "issue-filter-form" in body
    assert "isl-filters" in body


@pytest.mark.anyio
async def test_ui_issue_list_has_body_preview_js(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Issue list page HTML dispatches the issue-list TypeScript module and renders structure."""
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/issues")
    assert response.status_code == 200
    body = response.text
    # bodyPreview is now in app.js (TypeScript module); check the page dispatch JSON and structure
    assert '"page": "issue-list"' in body
    assert "isl-layout" in body


@pytest.mark.anyio
async def test_ui_pr_list_has_comment_badge_js(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """PR list page renders the SSR tab counts and HTMX state filters."""
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/pulls")
    assert response.status_code == 200
    body = response.text
    assert "prl-tab-ct" in body
    assert "pr-rows" in body
    assert "hx-get" in body


@pytest.mark.anyio
async def test_ui_pr_list_has_reaction_pills_js(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """PR list page renders the SSR open/merged/closed state tabs."""
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/pulls")
    assert response.status_code == 200
    body = response.text
    assert "state=open" in body
    assert "state=merged" in body


@pytest.mark.anyio
async def test_ui_issue_list_has_reaction_pills_js(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Issue list page renders the SSR filter sidebar."""
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/issues")
    assert response.status_code == 200
    body = response.text
    assert "filter-sidebar" in body or "filter-select" in body
    assert "hx-get" in body


@pytest.mark.anyio
async def test_ui_issue_list_eager_social_signals(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Issue list page renders the SSR issue rows container."""
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/issues")
    assert response.status_code == 200
    body = response.text
    assert "issue-rows" in body or "Issues" in body
    assert "hx-get" in body


@pytest.mark.anyio
async def test_ui_pr_detail_page_returns_200(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /{owner}/{slug}/pulls/{pr_id} returns 200 HTML."""
    import uuid
    from musehub.db.musehub_models import MusehubPullRequest
    repo_id = await _make_repo(db_session)
    pr_id = uuid.uuid4().hex
    db_session.add(MusehubPullRequest(
        pr_id=pr_id, repo_id=repo_id, title="Add blues riff", body="",
        state="open", from_branch="feat/blues", to_branch="main", author="testuser",
    ))
    await db_session.commit()
    response = await client.get(f"/testuser/test-beats/pulls/{pr_id}")
    assert response.status_code == 200
    assert "text/html" in response.headers["content-type"]
    body = response.text
    assert "MuseHub" in body
    assert "Merge pull request" in body


@pytest.mark.anyio
async def test_ui_pr_detail_page_has_comment_section(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """PR detail page includes the SSR comment thread section."""
    import uuid
    from musehub.db.musehub_models import MusehubPullRequest
    repo_id = await _make_repo(db_session)
    pr_id = uuid.uuid4().hex
    db_session.add(MusehubPullRequest(
        pr_id=pr_id, repo_id=repo_id, title="Comment test PR", body="",
        state="open", from_branch="feat/comments", to_branch="main", author="testuser",
    ))
    await db_session.commit()
    response = await client.get(f"/testuser/test-beats/pulls/{pr_id}")
    assert response.status_code == 200
    body = response.text
    assert "pr-comments" in body
    assert "comment-block" in body or "Leave a review comment" in body


@pytest.mark.anyio
async def test_ui_pr_detail_page_has_reaction_bar(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """PR detail page includes the HTMX merge controls and comment form."""
    import uuid
    from musehub.db.musehub_models import MusehubPullRequest
    repo_id = await _make_repo(db_session)
    pr_id = uuid.uuid4().hex
    db_session.add(MusehubPullRequest(
        pr_id=pr_id, repo_id=repo_id, title="Reaction test PR", body="",
        state="open", from_branch="feat/react", to_branch="main", author="testuser",
    ))
    await db_session.commit()
    response = await client.get(f"/testuser/test-beats/pulls/{pr_id}")
    assert response.status_code == 200
    body = response.text
    assert "pd-layout" in body
    assert "merge-section" in body


@pytest.mark.anyio
async def test_pr_detail_shows_diff_radar(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """PR detail page HTML contains the musical diff section."""
    import uuid
    from musehub.db.musehub_models import MusehubPullRequest
    repo_id = await _make_repo(db_session)
    pr_id = uuid.uuid4().hex
    db_session.add(MusehubPullRequest(
        pr_id=pr_id, repo_id=repo_id, title="Diff radar PR", body="",
        state="open", from_branch="feat/diff", to_branch="main", author="testuser",
    ))
    await db_session.commit()
    response = await client.get(f"/testuser/test-beats/pulls/{pr_id}")
    assert response.status_code == 200
    body = response.text
    # diff-stat CSS class is in app.css (SCSS); verify structural layout class instead
    assert "pd-layout" in body
    assert "pd-branch-pill" in body


@pytest.mark.anyio
async def test_pr_detail_audio_ab(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """PR detail page HTML contains the branch pills (from/to branch info)."""
    import uuid
    from musehub.db.musehub_models import MusehubPullRequest
    repo_id = await _make_repo(db_session)
    pr_id = uuid.uuid4().hex
    db_session.add(MusehubPullRequest(
        pr_id=pr_id, repo_id=repo_id, title="Audio AB PR", body="",
        state="open", from_branch="feat/audio", to_branch="main", author="testuser",
    ))
    await db_session.commit()
    response = await client.get(f"/testuser/test-beats/pulls/{pr_id}")
    assert response.status_code == 200
    body = response.text
    assert "branch-pill" in body
    assert "feat/audio" in body
    assert "main" in body


@pytest.mark.anyio
async def test_pr_detail_merge_strategies(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """PR detail page HTML contains the HTMX merge strategy buttons."""
    import uuid
    from musehub.db.musehub_models import MusehubPullRequest
    repo_id = await _make_repo(db_session)
    pr_id = uuid.uuid4().hex
    db_session.add(MusehubPullRequest(
        pr_id=pr_id, repo_id=repo_id, title="Merge strategy PR", body="",
        state="open", from_branch="feat/merge", to_branch="main", author="testuser",
    ))
    await db_session.commit()
    response = await client.get(f"/testuser/test-beats/pulls/{pr_id}")
    assert response.status_code == 200
    body = response.text
    assert "merge_commit" in body
    assert "squash" in body
    assert "rebase" in body
    assert "hx-post" in body


@pytest.mark.anyio
async def test_pr_detail_json_response(
    client: AsyncClient,
    db_session: AsyncSession,
    auth_headers: dict[str, str],
) -> None:
    """PR detail page ?format=json returns structured diff data for agent consumption."""
    from datetime import datetime, timezone

    from musehub.db.musehub_models import MusehubBranch, MusehubCommit, MusehubPullRequest

    repo_id = await _make_repo(db_session)
    commit_id = "aabbccddeeff00112233445566778899aabbccdd"
    commit = MusehubCommit(
        commit_id=commit_id,
        repo_id=repo_id,
        branch="feat/blues-riff",
        parent_ids=[],
        message="Add harmonic chord progression in Dm",
        author="musician",
        timestamp=datetime.now(tz=timezone.utc),
    )
    branch = MusehubBranch(
        repo_id=repo_id,
        name="feat/blues-riff",
        head_commit_id=commit_id,
    )
    db_session.add(commit)
    db_session.add(branch)
    import uuid
    pr_id = uuid.uuid4().hex
    pr = MusehubPullRequest(
        pr_id=pr_id,
        repo_id=repo_id,
        title="Add blues riff",
        body="",
        state="open",
        from_branch="feat/blues-riff",
        to_branch="main",
        author="musician",
    )
    db_session.add(pr)
    await db_session.commit()

    response = await client.get(
        f"/testuser/test-beats/pulls/{pr_id}?format=json",
        headers=auth_headers,
    )
    assert response.status_code == 200
    data = response.json()
    # Must include dimension scores and overall score
    assert "dimensions" in data
    assert "overallScore" in data
    assert isinstance(data["dimensions"], list)
    assert len(data["dimensions"]) == 5
    assert data["prId"] == pr_id
    assert data["fromBranch"] == "feat/blues-riff"
    assert data["toBranch"] == "main"
    # Each dimension must have the expected fields
    dim = data["dimensions"][0]
    assert "dimension" in dim
    assert "score" in dim
    assert "level" in dim
    assert "deltaLabel" in dim


# ---------------------------------------------------------------------------
# Tests for musehub_divergence service helpers
# ---------------------------------------------------------------------------


def test_extract_affected_sections_empty_when_no_section_keywords() -> None:
    """affected_sections returns [] when no commit message mentions a section keyword."""
    from musehub.services.musehub_divergence import extract_affected_sections

    messages = (
        "Add jazzy chord progression in Dm",
        "Rework drum pattern for more swing",
        "Fix melody pitch drift on lead synth",
    )
    assert extract_affected_sections(messages) == []


def test_extract_affected_sections_finds_mentioned_keywords() -> None:
    """affected_sections returns only section keywords actually present in commit messages."""
    from musehub.services.musehub_divergence import extract_affected_sections

    messages = (
        "Rewrite chorus melody to be more catchy",
        "Add tension to the bridge section",
        "Clean up drum loop in verse 2",
    )
    result = extract_affected_sections(messages)
    assert "Chorus" in result
    assert "Bridge" in result
    assert "Verse" in result
    # Keywords NOT mentioned should not appear
    assert "Intro" not in result
    assert "Outro" not in result


def test_extract_affected_sections_case_insensitive() -> None:
    """Section keyword matching is case-insensitive."""
    from musehub.services.musehub_divergence import extract_affected_sections

    messages = ("CHORUS rework", "New INTRO material", "bridge transition")
    result = extract_affected_sections(messages)
    assert "Chorus" in result
    assert "Intro" in result
    assert "Bridge" in result


def test_extract_affected_sections_deduplicates() -> None:
    """Each keyword appears at most once even when mentioned in multiple commits."""
    from musehub.services.musehub_divergence import extract_affected_sections

    messages = ("fix chorus", "rewrite chorus progression", "shorten chorus tail")
    result = extract_affected_sections(messages)
    assert result.count("Chorus") == 1


def test_build_pr_diff_response_affected_sections_from_commits() -> None:
    """build_pr_diff_response populates affected_sections from commit messages, not score."""
    from musehub.services.musehub_divergence import (
        MuseHubDimensionDivergence,
        MuseHubDivergenceLevel,
        MuseHubDivergenceResult,
        build_pr_diff_response,
    )

    structural_dim = MuseHubDimensionDivergence(
        dimension="structural",
        level=MuseHubDivergenceLevel.HIGH,
        score=0.9,
        description="High structural divergence",
        branch_a_commits=3,
        branch_b_commits=0,
    )
    other_dims = tuple(
        MuseHubDimensionDivergence(
            dimension=dim,
            level=MuseHubDivergenceLevel.NONE,
            score=0.0,
            description=f"No {dim} changes.",
            branch_a_commits=0,
            branch_b_commits=0,
        )
        for dim in ("melodic", "harmonic", "rhythmic", "dynamic")
    )
    result = MuseHubDivergenceResult(
        repo_id="repo-1",
        branch_a="main",
        branch_b="feat/new-structure",
        common_ancestor="abc123",
        dimensions=(structural_dim,) + other_dims,
        overall_score=0.18,
        # No section keywords in any commit message → affected_sections should be []
        all_messages=("Add chord progression", "Refine drum groove"),
    )

    response = build_pr_diff_response(
        pr_id="pr-abc",
        from_branch="feat/new-structure",
        to_branch="main",
        result=result,
    )

    assert response.affected_sections == []
    assert response.overall_score == 0.18
    assert len(response.dimensions) == 5


def test_build_pr_diff_response_affected_sections_present_when_mentioned() -> None:
    """build_pr_diff_response returns affected_sections when commits mention section keywords."""
    from musehub.services.musehub_divergence import (
        MuseHubDimensionDivergence,
        MuseHubDivergenceLevel,
        MuseHubDivergenceResult,
        build_pr_diff_response,
    )

    dims = tuple(
        MuseHubDimensionDivergence(
            dimension=dim,
            level=MuseHubDivergenceLevel.NONE,
            score=0.0,
            description=f"No {dim} changes.",
            branch_a_commits=0,
            branch_b_commits=0,
        )
        for dim in ("melodic", "harmonic", "rhythmic", "structural", "dynamic")
    )
    result = MuseHubDivergenceResult(
        repo_id="repo-2",
        branch_a="main",
        branch_b="feat/chorus-rework",
        common_ancestor="def456",
        dimensions=dims,
        overall_score=0.0,
        all_messages=("Rework the chorus hook", "Add bridge leading into outro"),
    )

    response = build_pr_diff_response(
        pr_id="pr-def",
        from_branch="feat/chorus-rework",
        to_branch="main",
        result=result,
    )

    assert "Chorus" in response.affected_sections
    assert "Bridge" in response.affected_sections
    assert "Outro" in response.affected_sections
    assert "Verse" not in response.affected_sections


def test_build_zero_diff_response_returns_empty_affected_sections() -> None:
    """build_zero_diff_response always returns [] for affected_sections."""
    from musehub.services.musehub_divergence import build_zero_diff_response

    response = build_zero_diff_response(
        pr_id="pr-zero",
        repo_id="repo-zero",
        from_branch="feat/empty",
        to_branch="main",
    )

    assert response.affected_sections == []
    assert response.overall_score == 0.0
    assert all(d.score == 0.0 for d in response.dimensions)
    assert len(response.dimensions) == 5


@pytest.mark.anyio
async def test_diff_api_affected_sections_empty_without_section_keywords(
    client: AsyncClient,
    db_session: AsyncSession,
    auth_headers: dict[str, str],
) -> None:
    """GET /diff returns affected_sections=[] when commit messages mention no section keywords."""
    import uuid
    from datetime import datetime, timezone

    from musehub.db.musehub_models import MusehubBranch, MusehubCommit, MusehubPullRequest

    repo_id = await _make_repo(db_session)
    commit_id = uuid.uuid4().hex
    commit = MusehubCommit(
        commit_id=commit_id,
        repo_id=repo_id,
        branch="feat/harmonic-twist",
        parent_ids=[],
        message="Add jazzy chord progression in Dm",
        author="musician",
        timestamp=datetime.now(tz=timezone.utc),
    )
    branch = MusehubBranch(
        repo_id=repo_id,
        name="feat/harmonic-twist",
        head_commit_id=commit_id,
    )
    pr_id = uuid.uuid4().hex
    pr = MusehubPullRequest(
        pr_id=pr_id,
        repo_id=repo_id,
        title="Harmonic twist",
        body="",
        state="open",
        from_branch="feat/harmonic-twist",
        to_branch="main",
        author="musician",
    )
    db_session.add_all([commit, branch, pr])
    await db_session.commit()

    response = await client.get(
        f"/api/v1/repos/{repo_id}/pull-requests/{pr_id}/diff",
        headers=auth_headers,
    )
    assert response.status_code == 200
    data = response.json()
    assert data["affectedSections"] == []


@pytest.mark.anyio
async def test_diff_api_affected_sections_populated_from_commit_message(
    client: AsyncClient,
    db_session: AsyncSession,
    auth_headers: dict[str, str],
) -> None:
    """GET /diff returns affected_sections populated from commit messages mentioning sections."""
    import uuid
    from datetime import datetime, timezone

    from musehub.db.musehub_models import MusehubBranch, MusehubCommit, MusehubPullRequest

    repo_id = await _make_repo(db_session)
    # main branch needs at least one commit for compute_hub_divergence to succeed
    main_commit_id = uuid.uuid4().hex
    main_commit = MusehubCommit(
        commit_id=main_commit_id,
        repo_id=repo_id,
        branch="main",
        parent_ids=[],
        message="Initial composition",
        author="musician",
        timestamp=datetime.now(tz=timezone.utc),
    )
    main_branch = MusehubBranch(
        repo_id=repo_id,
        name="main",
        head_commit_id=main_commit_id,
    )
    commit_id = uuid.uuid4().hex
    commit = MusehubCommit(
        commit_id=commit_id,
        repo_id=repo_id,
        branch="feat/chorus-rework",
        parent_ids=[main_commit_id],
        message="Rewrite the chorus to be more energetic and add new bridge",
        author="musician",
        timestamp=datetime.now(tz=timezone.utc),
    )
    branch = MusehubBranch(
        repo_id=repo_id,
        name="feat/chorus-rework",
        head_commit_id=commit_id,
    )
    pr_id = uuid.uuid4().hex
    pr = MusehubPullRequest(
        pr_id=pr_id,
        repo_id=repo_id,
        title="Chorus rework",
        body="",
        state="open",
        from_branch="feat/chorus-rework",
        to_branch="main",
        author="musician",
    )
    db_session.add_all([main_commit, main_branch, commit, branch, pr])
    await db_session.commit()

    response = await client.get(
        f"/api/v1/repos/{repo_id}/pull-requests/{pr_id}/diff",
        headers=auth_headers,
    )
    assert response.status_code == 200
    data = response.json()
    sections = data["affectedSections"]
    assert "Chorus" in sections
    assert "Bridge" in sections
    assert "Verse" not in sections


@pytest.mark.anyio
async def test_ui_diff_json_affected_sections_from_commit_message(
    client: AsyncClient,
    db_session: AsyncSession,
    auth_headers: dict[str, str],
) -> None:
    """PR detail ?format=json returns affected_sections derived from commit messages."""
    import uuid
    from datetime import datetime, timezone

    from musehub.db.musehub_models import MusehubBranch, MusehubCommit, MusehubPullRequest

    repo_id = await _make_repo(db_session)
    # main branch needs at least one commit for compute_hub_divergence to succeed
    main_commit_id = uuid.uuid4().hex
    main_commit = MusehubCommit(
        commit_id=main_commit_id,
        repo_id=repo_id,
        branch="main",
        parent_ids=[],
        message="Initial composition",
        author="musician",
        timestamp=datetime.now(tz=timezone.utc),
    )
    main_branch = MusehubBranch(
        repo_id=repo_id,
        name="main",
        head_commit_id=main_commit_id,
    )
    commit_id = uuid.uuid4().hex
    commit = MusehubCommit(
        commit_id=commit_id,
        repo_id=repo_id,
        branch="feat/verse-update",
        parent_ids=[main_commit_id],
        message="Extend verse 2 with new melodic motif",
        author="musician",
        timestamp=datetime.now(tz=timezone.utc),
    )
    branch = MusehubBranch(
        repo_id=repo_id,
        name="feat/verse-update",
        head_commit_id=commit_id,
    )
    pr_id = uuid.uuid4().hex
    pr = MusehubPullRequest(
        pr_id=pr_id,
        repo_id=repo_id,
        title="Verse update",
        body="",
        state="open",
        from_branch="feat/verse-update",
        to_branch="main",
        author="musician",
    )
    db_session.add_all([main_commit, main_branch, commit, branch, pr])
    await db_session.commit()

    response = await client.get(
        f"/testuser/test-beats/pulls/{pr_id}?format=json",
        headers=auth_headers,
    )
    assert response.status_code == 200
    data = response.json()
    assert "Verse" in data["affectedSections"]
    assert "Chorus" not in data["affectedSections"]


@pytest.mark.anyio
async def test_ui_issue_detail_page_returns_200(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /{owner}/{slug}/issues/{number} returns 200 HTML."""
    from musehub.db.musehub_models import MusehubIssue
    repo_id = await _make_repo(db_session)
    db_session.add(MusehubIssue(
        repo_id=repo_id, number=1, title="Test issue", body="",
        state="open", labels=[], author="testuser",
    ))
    await db_session.commit()
    response = await client.get("/testuser/test-beats/issues/1")
    assert response.status_code == 200
    assert "text/html" in response.headers["content-type"]
    body = response.text
    assert "MuseHub" in body
    assert "Close issue" in body


@pytest.mark.anyio
async def test_ui_issue_detail_has_comment_section(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Issue detail page includes the SSR comment thread section."""
    from musehub.db.musehub_models import MusehubIssue
    repo_id = await _make_repo(db_session)
    db_session.add(MusehubIssue(
        repo_id=repo_id, number=1, title="Test issue", body="",
        state="open", labels=[], author="testuser",
    ))
    await db_session.commit()
    response = await client.get("/testuser/test-beats/issues/1")
    assert response.status_code == 200
    body = response.text
    assert "Discussion" in body
    assert "issue-comments" in body


@pytest.mark.anyio
async def test_ui_issue_detail_has_render_comments_js(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Issue detail page includes HTMX comment thread with /comments endpoint."""
    from musehub.db.musehub_models import MusehubIssue
    repo_id = await _make_repo(db_session)
    db_session.add(MusehubIssue(
        repo_id=repo_id, number=1, title="Test issue", body="",
        state="open", labels=[], author="testuser",
    ))
    await db_session.commit()
    response = await client.get("/testuser/test-beats/issues/1")
    assert response.status_code == 200
    body = response.text
    assert "/comments" in body
    assert "hx-post" in body


@pytest.mark.anyio
async def test_ui_issue_detail_has_submit_comment_js(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Issue detail page includes the HTMX new-comment form."""
    from musehub.db.musehub_models import MusehubIssue
    repo_id = await _make_repo(db_session)
    db_session.add(MusehubIssue(
        repo_id=repo_id, number=1, title="Test issue", body="",
        state="open", labels=[], author="testuser",
    ))
    await db_session.commit()
    response = await client.get("/testuser/test-beats/issues/1")
    assert response.status_code == 200
    body = response.text
    assert "Leave a comment" in body
    assert "Comment" in body


@pytest.mark.anyio
async def test_ui_issue_detail_has_delete_comment_js(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Issue detail page renders the issue body and comment count."""
    from musehub.db.musehub_models import MusehubIssue
    repo_id = await _make_repo(db_session)
    db_session.add(MusehubIssue(
        repo_id=repo_id, number=1, title="Test issue", body="",
        state="open", labels=[], author="testuser",
    ))
    await db_session.commit()
    response = await client.get("/testuser/test-beats/issues/1")
    assert response.status_code == 200
    body = response.text
    assert "id-body-card" in body
    assert "comment" in body


@pytest.mark.anyio
async def test_ui_issue_detail_has_reply_support_js(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Issue detail page renders the issue detail grid layout."""
    from musehub.db.musehub_models import MusehubIssue
    repo_id = await _make_repo(db_session)
    db_session.add(MusehubIssue(
        repo_id=repo_id, number=1, title="Test issue", body="",
        state="open", labels=[], author="testuser",
    ))
    await db_session.commit()
    response = await client.get("/testuser/test-beats/issues/1")
    assert response.status_code == 200
    body = response.text
    assert "id-layout" in body
    # comment section always rendered below the body card
    assert "id-comments-section" in body


@pytest.mark.anyio
async def test_ui_issue_detail_comment_section_below_body(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Comment section appears after the issue body card in document order."""
    from musehub.db.musehub_models import MusehubIssue
    repo_id = await _make_repo(db_session)
    db_session.add(MusehubIssue(
        repo_id=repo_id, number=1, title="Test issue", body="",
        state="open", labels=[], author="testuser",
    ))
    await db_session.commit()
    response = await client.get("/testuser/test-beats/issues/1")
    assert response.status_code == 200
    body = response.text
    body_pos = body.find("id-body-card")
    comments_pos = body.find("issue-comments")
    assert body_pos != -1, "id-body-card not found"
    assert comments_pos != -1, "issue-comments not found"
    assert comments_pos > body_pos, "comment section must appear after the issue body"


@pytest.mark.anyio
async def test_ui_repo_page_no_auth_required(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """UI routes must be accessible without an Authorization header."""
    repo_id = await _make_repo(db_session)
    response = await client.get("/testuser/test-beats")
    # Must NOT return 401 — HTML shell has no auth requirement
    assert response.status_code != 401
    assert response.status_code == 200


@pytest.mark.anyio
async def test_ui_pages_include_token_form(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Every UI page embeds the JWT token input form and app.js via base.html."""
    repo_id = await _make_repo(db_session)
    for path in [
        "/testuser/test-beats",
        "/testuser/test-beats/pulls",
        "/testuser/test-beats/issues",
        "/testuser/test-beats/releases",
    ]:
        response = await client.get(path)
        assert response.status_code == 200
        body = response.text
        assert "static/app.js" in body
        assert "token-form" in body


@pytest.mark.anyio
async def test_ui_release_list_page_returns_200(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /{owner}/{slug}/releases returns 200 HTML without requiring a JWT."""
    repo_id = await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/releases")
    assert response.status_code == 200
    assert "text/html" in response.headers["content-type"]
    body = response.text
    assert "Releases" in body
    assert "MuseHub" in body
    assert "testuser" in body


@pytest.mark.anyio
async def test_ui_release_list_page_shows_release_row(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Release list page renders a row for each release with tag and channel."""
    repo_id = await _make_repo(db_session)
    release = MusehubRelease(
        repo_id=repo_id, tag="v1.0.0", title="Version 1.0",
        body="", author="testuser",
        channel="stable",
        download_urls={},
    )
    db_session.add(release)
    await db_session.commit()
    response = await client.get("/testuser/test-beats/releases")
    assert response.status_code == 200
    body = response.text
    assert "v1.0.0" in body
    assert "Version 1.0" in body


@pytest.mark.anyio
async def test_ui_release_list_page_has_body_preview(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Release list page renders SSR body preview for releases that have notes."""
    repo_id = await _make_repo(db_session)
    release = MusehubRelease(
        repo_id=repo_id, tag="v1.0", title="Version 1.0",
        body="This is the release body preview text.", author="testuser",
    )
    db_session.add(release)
    await db_session.commit()
    response = await client.get("/testuser/test-beats/releases")
    assert response.status_code == 200
    body = response.text
    assert "This is the release body preview text." in body


@pytest.mark.anyio
async def test_ui_release_list_page_has_tag_badge(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Release list page renders a tag badge for each release."""
    repo_id = await _make_repo(db_session)
    release = MusehubRelease(
        repo_id=repo_id, tag="v2.0.0", title="Version 2.0",
        body="", author="testuser",
        download_urls={},
    )
    db_session.add(release)
    await db_session.commit()
    response = await client.get("/testuser/test-beats/releases")
    assert response.status_code == 200
    body = response.text
    assert "v2.0.0" in body


@pytest.mark.anyio
async def test_ui_release_list_page_has_commit_link(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Release list page links a release's commit_id to the commit detail page."""
    repo_id = await _make_repo(db_session)
    release = MusehubRelease(
        repo_id=repo_id, tag="v1.0", title="Version 1.0",
        body="", author="testuser", commit_id="abc1234567890",
    )
    db_session.add(release)
    await db_session.commit()
    response = await client.get("/testuser/test-beats/releases")
    assert response.status_code == 200
    body = response.text
    assert "/commits/" in body
    assert "abc1234567890" in body


@pytest.mark.anyio
async def test_ui_release_list_page_has_tag_colour_coding(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Release list page SSR colour-codes tags: stable vs pre-release CSS classes."""
    repo_id = await _make_repo(db_session)
    db_session.add(MusehubRelease(
        repo_id=repo_id, tag="v1.0", title="Stable Release",
        body="", author="testuser", channel="stable",
    ))
    db_session.add(MusehubRelease(
        repo_id=repo_id, tag="v2.0-beta", title="Beta Release",
        body="", author="testuser", channel="beta",
    ))
    await db_session.commit()
    response = await client.get("/testuser/test-beats/releases")
    assert response.status_code == 200
    body = response.text
    assert "Pre-release" in body


@pytest.mark.anyio
async def test_ui_release_detail_page_returns_200(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /{owner}/{slug}/releases/{tag} returns 200 HTML with download section."""
    repo_id = await _make_repo(db_session)
    release = MusehubRelease(
        repo_id=repo_id, tag="v1.0", title="Version 1.0",
        body="Initial release.", author="testuser",
    )
    db_session.add(release)
    await db_session.commit()
    response = await client.get("/testuser/test-beats/releases/v1.0")
    assert response.status_code == 200
    assert "text/html" in response.headers["content-type"]
    body = response.text
    assert "MuseHub" in body
    assert "Download" in body
    assert "v1.0" in body


@pytest.mark.anyio
async def test_ui_release_detail_has_comment_section(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Release detail page renders SSR release header and metadata."""
    repo_id = await _make_repo(db_session)
    release = MusehubRelease(
        repo_id=repo_id, tag="v1.0", title="Version 1.0",
        body="Initial release.", author="testuser",
    )
    db_session.add(release)
    await db_session.commit()
    response = await client.get("/testuser/test-beats/releases/v1.0")
    assert response.status_code == 200
    body = response.text
    assert "rd-header" in body
    assert "rd-title" in body


@pytest.mark.anyio
async def test_ui_release_detail_has_render_comments_js(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Release detail page renders SSR release notes section."""
    repo_id = await _make_repo(db_session)
    release = MusehubRelease(
        repo_id=repo_id, tag="v1.0", title="Version 1.0",
        body="Initial release.", author="testuser",
    )
    db_session.add(release)
    await db_session.commit()
    response = await client.get("/testuser/test-beats/releases/v1.0")
    assert response.status_code == 200
    body = response.text
    assert "Release Notes" in body
    assert "rd-stat" in body


@pytest.mark.anyio
async def test_ui_release_detail_comment_uses_release_target_type(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Release detail page renders the reaction bar with release target type."""
    repo_id = await _make_repo(db_session)
    release = MusehubRelease(
        repo_id=repo_id, tag="v1.0", title="Version 1.0",
        body="Initial release.", author="testuser",
    )
    db_session.add(release)
    await db_session.commit()
    response = await client.get("/testuser/test-beats/releases/v1.0")
    assert response.status_code == 200
    body = response.text
    assert "release" in body
    assert "v1.0" in body


@pytest.mark.anyio
async def test_ui_release_detail_has_reply_thread_js(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Release detail page renders SSR author and date metadata."""
    repo_id = await _make_repo(db_session)
    release = MusehubRelease(
        repo_id=repo_id, tag="v1.0", title="Version 1.0",
        body="Initial release.", author="testuser",
    )
    db_session.add(release)
    await db_session.commit()
    response = await client.get("/testuser/test-beats/releases/v1.0")
    assert response.status_code == 200
    body = response.text
    assert "meta-label" in body
    assert "Author" in body


@pytest.mark.anyio
async def test_ui_repo_page_shows_releases_button(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /{repo_id} includes a Releases navigation button."""
    repo_id = await _make_repo(db_session)
    response = await client.get("/testuser/test-beats")
    assert response.status_code == 200
    body = response.text
    assert "releases" in body.lower()


# ---------------------------------------------------------------------------
# Global search UI page tests
# ---------------------------------------------------------------------------


@pytest.mark.anyio
async def test_global_search_ui_page_returns_200(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /search returns 200 HTML (no auth required — HTML shell)."""
    response = await client.get("/search")
    assert response.status_code == 200
    assert "text/html" in response.headers["content-type"]
    body = response.text
    assert "Global Search" in body
    assert "MuseHub" in body


@pytest.mark.anyio
async def test_global_search_ui_page_no_auth_required(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /search must not return 401 — it is a static HTML shell."""
    response = await client.get("/search")
    assert response.status_code != 401
    assert response.status_code == 200


# ---------------------------------------------------------------------------
# Object listing endpoint tests (JSON, authed)
# ---------------------------------------------------------------------------


@pytest.mark.anyio
async def test_list_objects_returns_empty_for_new_repo(
    client: AsyncClient,
    db_session: AsyncSession,
    auth_headers: dict[str, str],
) -> None:
    """GET /api/v1/repos/{repo_id}/objects returns empty list for new repo."""
    repo_id = await _make_repo(db_session)
    response = await client.get(
        f"/api/v1/repos/{repo_id}/objects",
        headers=auth_headers,
    )
    assert response.status_code == 200
    assert response.json()["objects"] == []


@pytest.mark.anyio
async def test_list_objects_requires_auth(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /api/v1/repos/{repo_id}/objects returns 401 without auth."""
    repo_id = await _make_repo(db_session)
    response = await client.get(f"/api/v1/repos/{repo_id}/objects")
    assert response.status_code == 401


@pytest.mark.anyio
async def test_list_objects_404_for_unknown_repo(
    client: AsyncClient,
    db_session: AsyncSession,
    auth_headers: dict[str, str],
) -> None:
    """GET /api/v1/repos/{unknown}/objects returns 404."""
    response = await client.get(
        "/api/v1/repos/does-not-exist/objects",
        headers=auth_headers,
    )
    assert response.status_code == 404


@pytest.mark.anyio
async def test_get_object_content_404_for_unknown_object(
    client: AsyncClient,
    db_session: AsyncSession,
    auth_headers: dict[str, str],
) -> None:
    """GET /api/v1/repos/{repo_id}/objects/{unknown}/content returns 404."""
    repo_id = await _make_repo(db_session)
    response = await client.get(
        f"/api/v1/repos/{repo_id}/objects/sha256:notexist/content",
        headers=auth_headers,
    )
    assert response.status_code == 404


# ---------------------------------------------------------------------------
# Credits UI page tests
# DAG graph UI page tests
# ---------------------------------------------------------------------------


@pytest.mark.anyio
async def test_credits_page_renders(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /{owner}/{repo_slug}/credits returns 200 HTML without requiring a JWT."""
    repo_id = await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/credits")
    assert response.status_code == 200
    assert "text/html" in response.headers["content-type"]
    body = response.text
    assert "MuseHub" in body
    assert "Credits" in body


@pytest.mark.anyio


async def test_graph_page_renders(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /{repo_id}/graph returns 200 HTML without requiring a JWT."""
    repo_id = await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/graph")
    assert response.status_code == 200
    assert "text/html" in response.headers["content-type"]
    body = response.text
    assert "MuseHub" in body
    assert "graph" in body.lower()


# ---------------------------------------------------------------------------
# Context viewer tests
# ---------------------------------------------------------------------------

_FIXED_COMMIT_ID = "aabbccdd" * 8 # 64-char hex string


async def _make_repo_with_commit(db_session: AsyncSession) -> tuple[str, str]:
    """Seed a repo with one commit and return (repo_id, commit_id)."""
    repo = MusehubRepo(
        name="jazz-context-test",
        owner="testuser",
        slug="jazz-context-test",
        visibility="private",
        owner_user_id="test-owner",
    )
    db_session.add(repo)
    await db_session.flush()
    await db_session.refresh(repo)
    repo_id = str(repo.repo_id)

    commit = MusehubCommit(
        commit_id=_FIXED_COMMIT_ID,
        repo_id=repo_id,
        branch="main",
        parent_ids=[],
        message="Add bass and drums",
        author="test-musician",
        timestamp=datetime(2025, 1, 15, 12, 0, 0, tzinfo=timezone.utc),
    )
    db_session.add(commit)
    await db_session.commit()
    return repo_id, _FIXED_COMMIT_ID



@pytest.mark.anyio
async def test_credits_json_response(
    client: AsyncClient,
    db_session: AsyncSession,
    auth_headers: dict[str, str],
) -> None:
    """GET /api/v1/repos/{repo_id}/credits returns JSON with required fields."""
    repo_id = await _make_repo(db_session)
    response = await client.get(
        f"/api/v1/repos/{repo_id}/credits",
        headers=auth_headers,
    )
    assert response.status_code == 200
    body = response.json()
    assert "repoId" in body
    assert "contributors" in body
    assert "sort" in body
    assert "totalContributors" in body
    assert body["repoId"] == repo_id
    assert isinstance(body["contributors"], list)
    assert body["sort"] == "count"



@pytest.mark.anyio
async def test_context_json_response(
    client: AsyncClient,
    db_session: AsyncSession,
    auth_headers: dict[str, str],
) -> None:
    """GET /api/v1/repos/{repo_id}/context/{ref} returns MuseHubContextResponse."""
    repo_id, commit_id = await _make_repo_with_commit(db_session)
    response = await client.get(
        f"/api/v1/repos/{repo_id}/context/{commit_id}",
        headers=auth_headers,
    )
    assert response.status_code == 200
    body = response.json()
    assert "repoId" in body

    assert body["repoId"] == repo_id
    assert body["currentBranch"] == "main"
    assert "headCommit" in body
    assert body["headCommit"]["commitId"] == commit_id
    assert body["headCommit"]["author"] == "test-musician"
    assert "musicalState" in body
    assert "history" in body
    assert "missingElements" in body
    assert "suggestions" in body


@pytest.mark.anyio
async def test_credits_empty_state_json(
    client: AsyncClient,
    db_session: AsyncSession,
    auth_headers: dict[str, str],
) -> None:
    """Repo with no commits returns empty contributors list and totalContributors=0."""
    repo_id = await _make_repo(db_session)
    response = await client.get(
        f"/api/v1/repos/{repo_id}/credits",
        headers=auth_headers,
    )
    assert response.status_code == 200
    body = response.json()
    assert body["contributors"] == []
    assert body["totalContributors"] == 0


@pytest.mark.anyio
async def test_context_includes_musical_state(
    client: AsyncClient,
    db_session: AsyncSession,
    auth_headers: dict[str, str],
) -> None:

    """Context response includes musicalState with an activeTracks field."""
    repo_id, commit_id = await _make_repo_with_commit(db_session)
    response = await client.get(
        f"/api/v1/repos/{repo_id}/context/{commit_id}",
        headers=auth_headers,
    )
    assert response.status_code == 200
    musical_state = response.json()["musicalState"]
    assert "activeTracks" in musical_state
    assert isinstance(musical_state["activeTracks"], list)
    # Dimensions requiring MIDI analysis are None at this stage
    assert musical_state["key"] is None
    assert musical_state["tempoBpm"] is None


@pytest.mark.anyio
async def test_context_unknown_ref_404(
    client: AsyncClient,
    db_session: AsyncSession,
    auth_headers: dict[str, str],
) -> None:
    """GET /api/v1/repos/{repo_id}/context/{ref} returns 404 for unknown ref."""
    repo_id = await _make_repo(db_session)
    response = await client.get(
        f"/api/v1/repos/{repo_id}/context/deadbeef" + "0" * 56,
        headers=auth_headers,
    )
    assert response.status_code == 404


@pytest.mark.anyio
async def test_context_unknown_repo_404(
    client: AsyncClient,
    db_session: AsyncSession,
    auth_headers: dict[str, str],
) -> None:
    """GET /api/v1/repos/{unknown}/context/{ref} returns 404 for unknown repo."""
    response = await client.get(
        "/api/v1/repos/ghost-repo/context/deadbeef" + "0" * 56,
        headers=auth_headers,
    )
    assert response.status_code == 404


@pytest.mark.anyio
async def test_context_requires_auth(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /api/v1/repos/{repo_id}/context/{ref} returns 401 without auth."""
    repo_id = await _make_repo(db_session)
    response = await client.get(
        f"/api/v1/repos/{repo_id}/context/deadbeef" + "0" * 56,
    )
    assert response.status_code == 401



# ---------------------------------------------------------------------------
# Context page additional tests
# ---------------------------------------------------------------------------



# ---------------------------------------------------------------------------
# Embed player route tests
# ---------------------------------------------------------------------------





# ---------------------------------------------------------------------------
# Groove check page and endpoint tests

# ---------------------------------------------------------------------------



@pytest.mark.anyio
async def test_credits_page_contains_json_ld_injection_slug_route(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Credits page embeds JSON-LD structured data via slug route."""
    repo_id = await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/credits")
    assert response.status_code == 200
    body = response.text
    assert "application/ld+json" in body
    assert "schema.org" in body


@pytest.mark.anyio
async def test_credits_page_contains_sort_options_slug_route(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Credits page renders stat strip and contributor section via slug route."""
    repo_id = await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/credits")
    assert response.status_code == 200
    body = response.text
    # Stat strip is always rendered
    assert "Contributors" in body
    assert "crd-stat-strip" in body


@pytest.mark.anyio
async def test_credits_empty_state_message_in_page_slug_route(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Credits page renders the SSR empty state when there are no contributors."""
    repo_id = await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/credits")
    assert response.status_code == 200
    body = response.text
    assert "No contributors yet" in body


@pytest.mark.anyio
async def test_credits_no_auth_required_slug_route(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Credits page must be accessible without an Authorization header via slug route."""
    repo_id = await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/credits")
    assert response.status_code == 200
    assert response.status_code != 401


@pytest.mark.anyio
async def test_credits_page_contains_avatar_functions(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Credits page renders the SSR credits page structure."""
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/credits")
    assert response.status_code == 200
    body = response.text
    assert "Credits" in body
    assert "crd-page" in body


@pytest.mark.anyio
async def test_credits_page_contains_fetch_profile_function(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Credits page renders SSR credits layout with stat strip."""
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/credits")
    assert response.status_code == 200
    body = response.text
    assert "crd-stat-strip" in body
    assert "Contributors" in body


@pytest.mark.anyio
async def test_credits_page_contains_profile_link_pattern(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Credits page renders SSR credits structure and JSON-LD metadata."""
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/credits")
    assert response.status_code == 200
    body = response.text
    assert "Credits" in body
    assert "schema.org" in body



# ---------------------------------------------------------------------------
# Object listing endpoint tests (JSON, authed)
# ---------------------------------------------------------------------------





@pytest.mark.anyio
async def test_groove_check_endpoint_returns_json(
    client: AsyncClient,
    db_session: AsyncSession,
    auth_headers: dict[str, str],
) -> None:
    """GET /api/v1/repos/{repo_id}/groove-check returns JSON with required fields."""
    repo_id = await _make_repo(db_session)
    response = await client.get(
        f"/api/v1/repos/{repo_id}/groove-check",
        headers=auth_headers,
    )
    assert response.status_code == 200
    body = response.json()
    assert "commitRange" in body
    assert "threshold" in body
    assert "totalCommits" in body
    assert "flaggedCommits" in body
    assert "worstCommit" in body
    assert "entries" in body
    assert isinstance(body["entries"], list)


@pytest.mark.anyio
async def test_graph_no_auth_required(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Graph page must be accessible without an Authorization header (HTML shell)."""
    repo_id = await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/graph")
    assert response.status_code == 200
    assert response.status_code != 401


async def test_groove_check_endpoint_entries_have_required_fields(
    client: AsyncClient,
    db_session: AsyncSession,
    auth_headers: dict[str, str],
) -> None:
    """Groove check endpoint returns GrooveCheckResponse shape (stub: empty entries)."""
    repo_id = await _make_repo(db_session)
    response = await client.get(
        f"/api/v1/repos/{repo_id}/groove-check?limit=5",
        headers=auth_headers,
    )
    assert response.status_code == 200
    body = response.json()
    # Groove-check is a stub (TODO: integrate cgcardona/muse service API).
    # Validate the response envelope shape rather than entry counts.
    assert "totalCommits" in body
    assert "flaggedCommits" in body
    assert "entries" in body
    assert isinstance(body["entries"], list)
    assert "commitRange" in body
    assert "threshold" in body


@pytest.mark.anyio
async def test_groove_check_endpoint_requires_auth(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /api/v1/repos/{repo_id}/groove-check returns 401 without auth."""
    repo_id = await _make_repo(db_session)
    response = await client.get(f"/api/v1/repos/{repo_id}/groove-check")
    assert response.status_code == 401


@pytest.mark.anyio
async def test_groove_check_endpoint_404_for_unknown_repo(
    client: AsyncClient,
    db_session: AsyncSession,
    auth_headers: dict[str, str],
) -> None:
    """GET /api/v1/repos/{unknown}/groove-check returns 404."""
    response = await client.get(
        "/api/v1/repos/does-not-exist/groove-check",
        headers=auth_headers,
    )
    assert response.status_code == 404


@pytest.mark.anyio
async def test_groove_check_endpoint_respects_limit(
    client: AsyncClient,
    db_session: AsyncSession,
    auth_headers: dict[str, str],
) -> None:
    """Groove check endpoint returns at most ``limit`` entries."""
    repo_id = await _make_repo(db_session)
    response = await client.get(
        f"/api/v1/repos/{repo_id}/groove-check?limit=3",
        headers=auth_headers,
    )
    assert response.status_code == 200
    body = response.json()
    assert body["totalCommits"] <= 3
    assert len(body["entries"]) <= 3


@pytest.mark.anyio
async def test_groove_check_endpoint_custom_threshold(
    client: AsyncClient,
    db_session: AsyncSession,
    auth_headers: dict[str, str],
) -> None:
    """Groove check endpoint accepts a custom threshold parameter."""
    repo_id = await _make_repo(db_session)
    response = await client.get(
        f"/api/v1/repos/{repo_id}/groove-check?threshold=0.05",
        headers=auth_headers,
    )
    assert response.status_code == 200
    body = response.json()
    assert abs(body["threshold"] - 0.05) < 1e-9


@pytest.mark.anyio
async def test_repo_page_contains_groove_check_link(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Repo landing page includes an Insights link for the domain viewer."""
    repo_id = await _make_repo(db_session)
    response = await client.get("/testuser/test-beats")
    assert response.status_code == 200
    body = response.text
    assert "/insights/" in body


# ---------------------------------------------------------------------------
# User profile page tests (— pre-existing from dev, fixed here)
# ---------------------------------------------------------------------------


@pytest.mark.anyio
async def test_profile_page_renders(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /users/{username} returns 200 HTML for a known profile."""
    await _make_profile(db_session, "rockstar")
    response = await client.get("/rockstar")
    assert response.status_code == 200
    assert "text/html" in response.headers["content-type"]
    body = response.text
    assert "MuseHub" in body
    assert "@rockstar" in body
    # Contribution graph JS moved to app.js (TypeScript module); check page dispatch instead
    assert '"page": "user-profile"' in body


@pytest.mark.anyio
async def test_profile_no_auth_required_ui(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Profile UI page is publicly accessible without a JWT (returns 200, not 401)."""
    await _make_profile(db_session, "public-user")
    response = await client.get("/public-user")
    assert response.status_code == 200
    assert response.status_code != 401


@pytest.mark.anyio
async def test_profile_unknown_user_404(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /api/v1/users/{unknown} returns 404 for a non-existent profile."""
    response = await client.get("/api/v1/users/does-not-exist-xyz")
    assert response.status_code == 404


@pytest.mark.anyio
async def test_profile_json_response(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /api/v1/users/{username} returns a valid JSON profile with required fields."""
    await _make_profile(db_session, "jazzmaster")
    response = await client.get("/api/v1/users/jazzmaster")
    assert response.status_code == 200
    data = response.json()
    assert data["username"] == "jazzmaster"
    assert "repos" in data
    assert "contributionGraph" in data
    assert "sessionCredits" in data
    assert isinstance(data["sessionCredits"], int)
    assert isinstance(data["contributionGraph"], list)


@pytest.mark.anyio
async def test_profile_lists_repos(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /api/v1/users/{username} includes public repos in the response."""
    await _make_profile(db_session, "beatmaker")
    repo_id = await _make_public_repo(db_session)
    response = await client.get("/api/v1/users/beatmaker")
    assert response.status_code == 200
    data = response.json()
    repo_ids = [r["repoId"] for r in data["repos"]]
    assert repo_id in repo_ids


@pytest.mark.anyio
async def test_profile_create_and_update(
    client: AsyncClient,
    db_session: AsyncSession,
    auth_headers: dict[str, str],
) -> None:
    """POST /api/v1/users creates a profile; PUT updates it."""
    # Create profile
    resp = await client.post(
        "/api/v1/users",
        json={"username": "newartist", "bio": "Initial bio"},
        headers=auth_headers,
    )
    assert resp.status_code == 201
    data = resp.json()
    assert data["username"] == "newartist"
    assert data["bio"] == "Initial bio"

    # Update profile
    resp2 = await client.put(
        "/api/v1/users/newartist",
        json={"bio": "Updated bio"},
        headers=auth_headers,
    )
    assert resp2.status_code == 200
    assert resp2.json()["bio"] == "Updated bio"


@pytest.mark.anyio
async def test_profile_create_duplicate_username_409(
    client: AsyncClient,
    db_session: AsyncSession,
    auth_headers: dict[str, str],
) -> None:
    """POST /api/v1/users returns 409 when username is already taken."""
    await _make_profile(db_session, "takenname")
    resp = await client.post(
        "/api/v1/users",
        json={"username": "takenname"},
        headers=auth_headers,
    )
    assert resp.status_code == 409


@pytest.mark.anyio
async def test_profile_update_403_for_wrong_owner(
    client: AsyncClient,
    db_session: AsyncSession,
    auth_headers: dict[str, str],
) -> None:
    """PUT /api/v1/users/{username} returns 403 when caller doesn't own the profile."""
    # Create a profile owned by a DIFFERENT user
    other_profile = MusehubProfile(
        user_id="different-user-id-999",
        username="someoneelse",
        bio="not yours",
        pinned_repo_ids=[],
    )
    db_session.add(other_profile)
    await db_session.commit()

    resp = await client.put(
        "/api/v1/users/someoneelse",
        json={"bio": "hijacked"},
        headers=auth_headers,
    )
    assert resp.status_code == 403


@pytest.mark.anyio
async def test_profile_page_unknown_user_renders_404_inline(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /users/{unknown} returns 200 HTML (JS renders 404 inline)."""
    response = await client.get("/ghost-user-xyz")
    # The HTML shell always returns 200 — the JS fetches and handles the API 404
    assert response.status_code == 200
    assert "text/html" in response.headers["content-type"]


# ---------------------------------------------------------------------------
# Forked repos endpoint tests
# ---------------------------------------------------------------------------


@pytest.mark.anyio
async def test_profile_forked_repos_empty_list(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /api/v1/users/{username}/forks returns empty list when user has no forks."""
    await _make_profile(db_session, "freshuser")
    response = await client.get("/api/v1/users/freshuser/forks")
    assert response.status_code == 200
    data = response.json()
    assert data["forks"] == []
    assert data["total"] == 0


@pytest.mark.anyio
async def test_profile_forked_repos_returns_forks(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /api/v1/users/{username}/forks returns forked repos with source attribution."""
    await _make_profile(db_session, "forkuser")

    # Seed a source repo owned by another user
    source = MusehubRepo(
        name="original-track",
        owner="original-owner",
        slug="original-track",
        visibility="public",
        owner_user_id="original-owner-id",
    )
    db_session.add(source)
    await db_session.commit()
    await db_session.refresh(source)

    # Seed the fork repo owned by forkuser
    fork_repo = MusehubRepo(
        name="original-track",
        owner="forkuser",
        slug="original-track",
        visibility="public",
        owner_user_id=_TEST_USER_ID,
    )
    db_session.add(fork_repo)
    await db_session.commit()
    await db_session.refresh(fork_repo)

    # Seed the fork relationship
    fork = MusehubFork(
        source_repo_id=source.repo_id,
        fork_repo_id=fork_repo.repo_id,
        forked_by="forkuser",
    )
    db_session.add(fork)
    await db_session.commit()

    response = await client.get("/api/v1/users/forkuser/forks")
    assert response.status_code == 200
    data = response.json()
    assert data["total"] == 1
    assert len(data["forks"]) == 1
    entry = data["forks"][0]
    assert entry["sourceOwner"] == "original-owner"
    assert entry["sourceSlug"] == "original-track"
    assert entry["forkRepo"]["owner"] == "forkuser"
    assert entry["forkRepo"]["slug"] == "original-track"
    assert "forkId" in entry
    assert "forkedAt" in entry


@pytest.mark.anyio
async def test_profile_forked_repos_404_for_unknown_user(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /api/v1/users/{unknown}/forks returns 404 when user doesn't exist."""
    response = await client.get("/api/v1/users/ghost-no-profile/forks")
    assert response.status_code == 404


@pytest.mark.anyio
async def test_profile_forked_repos_no_auth_required(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /api/v1/users/{username}/forks is publicly accessible without a JWT."""
    await _make_profile(db_session, "public-forkuser")
    response = await client.get("/api/v1/users/public-forkuser/forks")
    assert response.status_code == 200
    assert response.status_code != 401




# ---------------------------------------------------------------------------
# Starred repos tab
# ---------------------------------------------------------------------------


@pytest.mark.anyio
async def test_profile_starred_repos_empty_list(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /api/v1/users/{username}/starred returns empty list when user has no stars."""
    await _make_profile(db_session, "freshstaruser")
    response = await client.get("/api/v1/users/freshstaruser/starred")
    assert response.status_code == 200
    data = response.json()
    assert data["starred"] == []
    assert data["total"] == 0


@pytest.mark.anyio
async def test_profile_starred_repos_returns_starred(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /api/v1/users/{username}/starred returns starred repos with full metadata."""
    await _make_profile(db_session, "stargazeruser")

    repo = MusehubRepo(
        name="awesome-groove",
        owner="someartist",
        slug="awesome-groove",
        visibility="public",
        owner_user_id="someartist-id",
        description="A great groove",
        key_signature="C major",
        tempo_bpm=120,
    )
    db_session.add(repo)
    await db_session.commit()
    await db_session.refresh(repo)

    star = MusehubStar(
        repo_id=repo.repo_id,
        user_id=_TEST_USER_ID,
    )
    db_session.add(star)
    await db_session.commit()

    response = await client.get("/api/v1/users/stargazeruser/starred")
    assert response.status_code == 200
    data = response.json()
    assert data["total"] == 1
    assert len(data["starred"]) == 1
    entry = data["starred"][0]
    assert entry["repo"]["owner"] == "someartist"
    assert entry["repo"]["slug"] == "awesome-groove"
    assert entry["repo"]["description"] == "A great groove"
    assert "starId" in entry
    assert "starredAt" in entry


@pytest.mark.anyio
async def test_profile_starred_repos_404_for_unknown_user(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /api/v1/users/{unknown}/starred returns 404 when user doesn't exist."""
    response = await client.get("/api/v1/users/ghost-no-star-profile/starred")
    assert response.status_code == 404


@pytest.mark.anyio
async def test_profile_starred_repos_no_auth_required(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /api/v1/users/{username}/starred is publicly accessible without a JWT."""
    await _make_profile(db_session, "public-staruser")
    response = await client.get("/api/v1/users/public-staruser/starred")
    assert response.status_code == 200
    assert response.status_code != 401


@pytest.mark.anyio
async def test_profile_starred_repos_ordered_newest_first(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /api/v1/users/{username}/starred returns stars newest first."""
    from datetime import timezone

    await _make_profile(db_session, "multistaruser")

    repo_a = MusehubRepo(
        name="track-alpha", owner="artist-a", slug="track-alpha",
        visibility="public", owner_user_id="artist-a-id",
    )
    repo_b = MusehubRepo(
        name="track-beta", owner="artist-b", slug="track-beta",
        visibility="public", owner_user_id="artist-b-id",
    )
    db_session.add_all([repo_a, repo_b])
    await db_session.commit()
    await db_session.refresh(repo_a)
    await db_session.refresh(repo_b)

    import datetime as dt
    star_a = MusehubStar(
        repo_id=repo_a.repo_id,
        user_id=_TEST_USER_ID,
        created_at=dt.datetime(2024, 1, 1, tzinfo=timezone.utc),
    )
    star_b = MusehubStar(
        repo_id=repo_b.repo_id,
        user_id=_TEST_USER_ID,
        created_at=dt.datetime(2024, 6, 1, tzinfo=timezone.utc),
    )
    db_session.add_all([star_a, star_b])
    await db_session.commit()

    response = await client.get("/api/v1/users/multistaruser/starred")
    assert response.status_code == 200
    data = response.json()
    assert data["total"] == 2
    # newest first: star_b (June) before star_a (January)
    assert data["starred"][0]["repo"]["slug"] == "track-beta"
    assert data["starred"][1]["repo"]["slug"] == "track-alpha"




# ---------------------------------------------------------------------------
# Watched repos tab
# ---------------------------------------------------------------------------


@pytest.mark.anyio
async def test_profile_watched_repos_empty_list(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /api/v1/users/{username}/watched returns empty list when user watches nothing."""
    await _make_profile(db_session, "freshwatchuser")
    response = await client.get("/api/v1/users/freshwatchuser/watched")
    assert response.status_code == 200
    data = response.json()
    assert data["watched"] == []
    assert data["total"] == 0


@pytest.mark.anyio
async def test_profile_watched_repos_returns_watched(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /api/v1/users/{username}/watched returns watched repos with full metadata."""
    await _make_profile(db_session, "watcheruser")

    repo = MusehubRepo(
        name="cool-composition",
        owner="composer",
        slug="cool-composition",
        visibility="public",
        owner_user_id="composer-id",
        description="A cool composition",
        key_signature="G minor",
        tempo_bpm=90,
    )
    db_session.add(repo)
    await db_session.commit()
    await db_session.refresh(repo)

    watch = MusehubWatch(
        repo_id=repo.repo_id,
        user_id=_TEST_USER_ID,
    )
    db_session.add(watch)
    await db_session.commit()

    response = await client.get("/api/v1/users/watcheruser/watched")
    assert response.status_code == 200
    data = response.json()
    assert data["total"] == 1
    assert len(data["watched"]) == 1
    entry = data["watched"][0]
    assert entry["repo"]["owner"] == "composer"
    assert entry["repo"]["slug"] == "cool-composition"
    assert entry["repo"]["description"] == "A cool composition"
    assert "watchId" in entry
    assert "watchedAt" in entry


@pytest.mark.anyio
async def test_profile_watched_repos_404_for_unknown_user(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /api/v1/users/{unknown}/watched returns 404 when user doesn't exist."""
    response = await client.get("/api/v1/users/ghost-no-watch-profile/watched")
    assert response.status_code == 404


@pytest.mark.anyio
async def test_profile_watched_repos_no_auth_required(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /api/v1/users/{username}/watched is publicly accessible without a JWT."""
    await _make_profile(db_session, "public-watchuser")
    response = await client.get("/api/v1/users/public-watchuser/watched")
    assert response.status_code == 200
    assert response.status_code != 401


@pytest.mark.anyio
async def test_profile_watched_repos_ordered_newest_first(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /api/v1/users/{username}/watched returns watches newest first."""
    import datetime as dt
    from datetime import timezone

    await _make_profile(db_session, "multiwatchuser")

    repo_a = MusehubRepo(
        name="song-alpha", owner="band-a", slug="song-alpha",
        visibility="public", owner_user_id="band-a-id",
    )
    repo_b = MusehubRepo(
        name="song-beta", owner="band-b", slug="song-beta",
        visibility="public", owner_user_id="band-b-id",
    )
    db_session.add_all([repo_a, repo_b])
    await db_session.commit()
    await db_session.refresh(repo_a)
    await db_session.refresh(repo_b)

    watch_a = MusehubWatch(
        repo_id=repo_a.repo_id,
        user_id=_TEST_USER_ID,
        created_at=dt.datetime(2024, 1, 1, tzinfo=timezone.utc),
    )
    watch_b = MusehubWatch(
        repo_id=repo_b.repo_id,
        user_id=_TEST_USER_ID,
        created_at=dt.datetime(2024, 6, 1, tzinfo=timezone.utc),
    )
    db_session.add_all([watch_a, watch_b])
    await db_session.commit()

    response = await client.get("/api/v1/users/multiwatchuser/watched")
    assert response.status_code == 200
    data = response.json()
    assert data["total"] == 2
    # newest first: watch_b (June) before watch_a (January)
    assert data["watched"][0]["repo"]["slug"] == "song-beta"
    assert data["watched"][1]["repo"]["slug"] == "song-alpha"




@pytest.mark.anyio
async def test_timeline_page_renders(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /{repo_id}/timeline returns 200 HTML without requiring a JWT."""
    repo_id = await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/timeline")
    assert response.status_code == 200
    assert "text/html" in response.headers["content-type"]
    body = response.text
    assert "MuseHub" in body
    assert "timeline" in body.lower()
    assert repo_id[:8] in body


@pytest.mark.anyio
async def test_timeline_page_no_auth_required(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Timeline UI route must be accessible without an Authorization header."""
    repo_id = await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/timeline")
    assert response.status_code != 401
    assert response.status_code == 200


@pytest.mark.anyio
async def test_timeline_page_contains_layer_controls(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Timeline page embeds toggleable layer controls for all four layers."""
    repo_id = await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/timeline")
    assert response.status_code == 200
    body = response.text
    assert "Commits" in body
    assert "Emotion" in body
    assert "Sections" in body
    assert "Tracks" in body


@pytest.mark.anyio
async def test_timeline_page_contains_zoom_controls(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Timeline page embeds day/week/month/all zoom buttons."""
    repo_id = await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/timeline")
    assert response.status_code == 200
    body = response.text
    assert "Day" in body
    assert "Week" in body
    assert "Month" in body
    assert "All" in body


@pytest.mark.anyio
async def test_timeline_page_includes_token_form(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Timeline page includes the JWT token form and app.js via base.html."""
    repo_id = await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/timeline")
    assert response.status_code == 200
    body = response.text
    assert "static/app.js" in body
    assert "token-form" in body


@pytest.mark.anyio
async def test_timeline_page_contains_overlay_toggles(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Timeline page must include Sessions, PRs, and Releases layer toggle checkboxes.

    Regression test — before this fix the timeline had no
    overlay markers for repo lifecycle events (sessions, PR merges, releases).
    """
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/timeline")
    assert response.status_code == 200
    body = response.text
    # All three new overlay toggle labels must be present.
    assert "Sessions" in body
    assert "PRs" in body
    assert "Releases" in body


@pytest.mark.anyio
async def test_timeline_page_overlay_js_variables(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Timeline page dispatches the TypeScript timeline module and passes server config.

    Overlay rendering (sessions, PRs, releases) is handled by pages/timeline.ts;
    the template emits config via the page_json block so the module knows what
    to fetch. All JS is external — we check the server-rendered JSON data block.
    """
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/timeline")
    assert response.status_code == 200
    body = response.text
    assert '"page": "timeline"' in body
    assert '"repoId"' in body
    assert "baseUrl" in body


@pytest.mark.anyio
async def test_timeline_page_overlay_fetch_calls(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Timeline page renders the SSR layer-toggle toolbar with correct labels.

    API fetch calls for sessions, merged PRs, and releases are made by the
    TypeScript module (pages/timeline.ts), not inline script — asserting on
    them in the HTML is an anti-pattern.  Instead, verify that the SSR
    toolbar labels appear so users can toggle the overlay layers.
    """
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/timeline")
    assert response.status_code == 200
    body = response.text
    assert "Sessions" in body
    assert "PRs" in body
    assert "Releases" in body


@pytest.mark.anyio
async def test_timeline_page_overlay_legend(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Timeline page legend must describe the three new overlay marker types."""
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/timeline")
    assert response.status_code == 200
    body = response.text
    # Colour labels in the legend.
    assert "teal" in body.lower()
    assert "gold" in body.lower()


@pytest.mark.anyio
async def test_timeline_pr_markers_use_merged_at_for_positioning(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Timeline page renders and the TypeScript module receives the server config.

    The mergedAt vs createdAt positioning logic lives in pages/timeline.ts —
    asserting on inline JS property access is an anti-pattern since the code
    now lives in the compiled TypeScript bundle, not in the HTML.
    This test guards that the page loads and the TS module is dispatched.
    """
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/timeline")
    assert response.status_code == 200
    body = response.text
    assert '"page": "timeline"' in body
    assert '"repoId"' in body


@pytest.mark.anyio
async def test_pr_response_includes_merged_at_after_merge(
    client: AsyncClient,
    db_session: AsyncSession,
    auth_headers: dict[str, str],
) -> None:
    """PRResponse must expose merged_at set to the merge timestamp (not None) after merge.

    Regression test: before this fix merged_at was absent from
    PRResponse, forcing the timeline to fall back to createdAt.
    """
    from datetime import datetime, timezone

    from musehub.services import musehub_pull_requests, musehub_repository

    repo_id = await _make_repo(db_session)

    # Create two branches with commits so the merge can proceed.
    import uuid as _uuid

    from musehub.db import musehub_models as dbm

    commit_a_id = _uuid.uuid4().hex
    commit_main_id = _uuid.uuid4().hex

    commit_a = dbm.MusehubCommit(
        commit_id=commit_a_id,
        repo_id=repo_id,
        branch="feat/test-merge",
        parent_ids=[],
        message="test commit on feature branch",
        author="tester",
        timestamp=datetime.now(timezone.utc),
    )
    branch_a = dbm.MusehubBranch(
        repo_id=repo_id, name="feat/test-merge", head_commit_id=commit_a_id
    )
    db_session.add(commit_a)
    db_session.add(branch_a)

    commit_main = dbm.MusehubCommit(
        commit_id=commit_main_id,
        repo_id=repo_id,
        branch="main",
        parent_ids=[],
        message="initial commit on main",
        author="tester",
        timestamp=datetime.now(timezone.utc),
    )
    branch_main = dbm.MusehubBranch(
        repo_id=repo_id, name="main", head_commit_id=commit_main_id
    )
    db_session.add(commit_main)
    db_session.add(branch_main)
    await db_session.flush()

    pr = await musehub_pull_requests.create_pr(
        db_session,
        repo_id=repo_id,
        title="Test merge PR",
        from_branch="feat/test-merge",
        to_branch="main",
        body="",
        author="tester",
    )
    await db_session.flush()

    before_merge = datetime.now(timezone.utc)
    merged_pr = await musehub_pull_requests.merge_pr(
        db_session, repo_id, pr.pr_id, merge_strategy="merge_commit"
    )
    after_merge = datetime.now(timezone.utc)

    assert merged_pr.merged_at is not None, "merged_at must be set after merge"
    # merged_at must be a timezone-aware datetime between before and after the merge call.
    merged_at = merged_pr.merged_at
    if merged_at.tzinfo is None:
        merged_at = merged_at.replace(tzinfo=timezone.utc)
    assert before_merge <= merged_at <= after_merge, (
        f"merged_at {merged_at} is outside the expected range [{before_merge}, {after_merge}]"
    )
    assert merged_pr.state == "merged"


# ---------------------------------------------------------------------------
# Embed player route tests
# ---------------------------------------------------------------------------


_UTC = timezone.utc


@pytest.mark.anyio
async def test_graph_page_contains_dag_js(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Graph page embeds the client-side DAG renderer JavaScript."""
    repo_id = await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/graph")
    assert response.status_code == 200
    body = response.text
    assert '"page": "graph"' in body
    assert "dag-viewport" in body


@pytest.mark.anyio
async def test_graph_page_contains_session_ring_js(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Graph page loads successfully and dispatches the TypeScript graph module.

    Session markers and reaction counts are rendered by the compiled TypeScript
    bundle — asserting on inline JS constant names (SESSION_RING_COLOR etc.) is
    an anti-pattern since those symbols live in the .ts source, not the HTML.
    """
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/graph")
    assert response.status_code == 200
    body = response.text
    assert "MuseHub" in body


@pytest.mark.anyio
async def test_session_list_page_returns_200(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /{repo_id}/sessions returns 200 HTML without requiring a JWT."""
    repo_id = await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/sessions")
    assert response.status_code == 200
    assert "text/html" in response.headers["content-type"]
    body = response.text
    assert "MuseHub" in body
    assert "Sessions" in body
    assert "static/app.js" in body


@pytest.mark.anyio
async def test_session_detail_renders(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /{owner}/{repo_slug}/sessions/{session_id} returns 200 HTML."""
    repo_id = await _make_repo(db_session)
    session_id = await _make_session(db_session, repo_id)
    response = await client.get(f"/testuser/test-beats/sessions/{session_id}")
    assert response.status_code == 200
    assert "text/html" in response.headers["content-type"]
    body = response.text
    assert "MuseHub" in body
    assert "Session" in body
    assert session_id[:8] in body


@pytest.mark.anyio
async def test_session_detail_participants(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Session detail page renders the Participants sidebar section."""
    repo_id = await _make_repo(db_session)
    session_id = await _make_session(db_session, repo_id, participants=["alice", "bob"])
    response = await client.get(f"/testuser/test-beats/sessions/{session_id}")
    assert response.status_code == 200
    body = response.text
    assert "Participants" in body
    assert "alice" in body


@pytest.mark.anyio
async def test_session_detail_commits(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Session detail page renders commit pills when commits are present."""
    repo_id = await _make_repo(db_session)
    session_id = await _make_session(
        db_session, repo_id, commits=["abc1234567890", "def9876543210"]
    )
    response = await client.get(f"/testuser/test-beats/sessions/{session_id}")
    assert response.status_code == 200
    body = response.text
    assert "Commits" in body
    assert "commit-pill" in body


@pytest.mark.anyio
async def test_session_detail_404_for_unknown_session(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Session detail route returns HTTP 404 for an unknown session ID.

    The route is fully SSR — it performs a real DB lookup and returns 404
    rather than a JS shell that handles missing data client-side.
    """
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/sessions/does-not-exist-1234")
    assert response.status_code == 404


@pytest.mark.anyio
async def test_session_detail_shows_intent(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Session detail page renders the intent field when present."""
    repo_id = await _make_repo(db_session)
    session_id = await _make_session(db_session, repo_id, intent="ambient soundscape")
    response = await client.get(f"/testuser/test-beats/sessions/{session_id}")
    assert response.status_code == 200
    assert "ambient soundscape" in response.text


@pytest.mark.anyio
async def test_session_detail_shows_location(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Session detail page renders the location field when present."""
    repo_id = await _make_repo(db_session)
    session_id = await _make_session(db_session, repo_id)
    response = await client.get(f"/testuser/test-beats/sessions/{session_id}")
    assert response.status_code == 200
    assert "Studio A" in response.text


@pytest.mark.anyio
async def test_session_detail_shows_meta_labels(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Session detail page renders the meta-label / meta-value row layout."""
    repo_id = await _make_repo(db_session)
    session_id = await _make_session(db_session, repo_id)
    response = await client.get(f"/testuser/test-beats/sessions/{session_id}")
    assert response.status_code == 200
    body = response.text
    assert "meta-label" in body
    assert "meta-value" in body
    assert "Started" in body


@pytest.mark.anyio
async def test_session_detail_active_shows_live_badge(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Session detail page shows a live badge for an active session."""
    repo_id = await _make_repo(db_session)
    session_id = await _make_session(db_session, repo_id, is_active=True)
    response = await client.get(f"/testuser/test-beats/sessions/{session_id}")
    assert response.status_code == 200
    body = response.text
    assert "live" in body
    assert "session-live-dot" in body


@pytest.mark.anyio
async def test_session_detail_ended_shows_badge(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Session detail page shows 'ended' badge for a completed session."""
    repo_id = await _make_repo(db_session)
    session_id = await _make_session(db_session, repo_id, is_active=False)
    response = await client.get(f"/testuser/test-beats/sessions/{session_id}")
    assert response.status_code == 200
    assert "ended" in response.text


@pytest.mark.anyio
async def test_session_detail_shows_notes(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Session detail page renders closing notes when present."""
    repo_id = await _make_repo(db_session)
    session_id = await _make_session(
        db_session, repo_id, notes="Great vibe, revisit the bridge section."
    )
    response = await client.get(f"/testuser/test-beats/sessions/{session_id}")
    assert response.status_code == 200
    assert "Great vibe, revisit the bridge section." in response.text


async def _make_session(
    db_session: AsyncSession,
    repo_id: str,
    *,
    started_offset_seconds: int = 0,
    is_active: bool = False,
    intent: str = "jazz composition",
    participants: list[str] | None = None,
    commits: list[str] | None = None,
    notes: str = "",
) -> str:
    """Seed a MusehubSession and return its session_id."""
    start = datetime(2025, 1, 1, 12, 0, 0, tzinfo=timezone.utc)
    from datetime import timedelta

    started_at = start + timedelta(seconds=started_offset_seconds)
    ended_at = None if is_active else started_at + timedelta(hours=1)
    row = MusehubSession(
        repo_id=repo_id,
        started_at=started_at,
        ended_at=ended_at,
        participants=participants or ["producer-a"],
        commits=commits or [],
        notes=notes,
        intent=intent,
        location="Studio A",
        is_active=is_active,
    )
    db_session.add(row)
    await db_session.commit()
    await db_session.refresh(row)
    return str(row.session_id)


@pytest.mark.anyio
async def test_sessions_json_response(
    client: AsyncClient,
    db_session: AsyncSession,
    auth_headers: dict[str, str],
) -> None:
    """GET /api/v1/repos/{repo_id}/sessions returns session list with metadata."""
    repo_id = await _make_repo(db_session)
    session_id = await _make_session(db_session, repo_id, intent="jazz solo")

    response = await client.get(
        f"/api/v1/repos/{repo_id}/sessions",
        headers=auth_headers,
    )
    assert response.status_code == 200
    data = response.json()
    assert "sessions" in data
    assert "total" in data
    assert data["total"] == 1
    sess = data["sessions"][0]
    assert sess["sessionId"] == session_id
    assert sess["intent"] == "jazz solo"
    assert sess["location"] == "Studio A"
    assert sess["isActive"] is False
    assert sess["durationSeconds"] == pytest.approx(3600.0)


@pytest.mark.anyio
async def test_sessions_newest_first(
    client: AsyncClient,
    db_session: AsyncSession,
    auth_headers: dict[str, str],
) -> None:
    """Sessions are returned newest-first (active sessions appear before ended sessions)."""
    repo_id = await _make_repo(db_session)
    # older ended session
    await _make_session(db_session, repo_id, started_offset_seconds=0, intent="older")
    # newer ended session
    await _make_session(db_session, repo_id, started_offset_seconds=3600, intent="newer")
    # active session (should surface first regardless of time)
    await _make_session(
        db_session, repo_id, started_offset_seconds=100, is_active=True, intent="live"
    )

    response = await client.get(
        f"/api/v1/repos/{repo_id}/sessions",
        headers=auth_headers,
    )
    assert response.status_code == 200
    sessions = response.json()["sessions"]
    assert len(sessions) == 3
    # Active session must come first
    assert sessions[0]["isActive"] is True
    assert sessions[0]["intent"] == "live"
    # Then newest ended session
    assert sessions[1]["intent"] == "newer"
    assert sessions[2]["intent"] == "older"


@pytest.mark.anyio
async def test_sessions_empty_for_new_repo(
    client: AsyncClient,
    db_session: AsyncSession,
    auth_headers: dict[str, str],
) -> None:
    """GET /api/v1/repos/{repo_id}/sessions returns empty list for new repo."""
    repo_id = await _make_repo(db_session)
    response = await client.get(
        f"/api/v1/repos/{repo_id}/sessions",
        headers=auth_headers,
    )
    assert response.status_code == 200
    data = response.json()
    assert data["sessions"] == []
    assert data["total"] == 0


@pytest.mark.anyio
async def test_sessions_requires_auth(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /api/v1/repos/{repo_id}/sessions returns 401 without auth."""
    repo_id = await _make_repo(db_session)
    response = await client.get(f"/api/v1/repos/{repo_id}/sessions")
    assert response.status_code == 401


@pytest.mark.anyio
async def test_sessions_404_for_unknown_repo(
    client: AsyncClient,
    db_session: AsyncSession,
    auth_headers: dict[str, str],
) -> None:
    """GET /api/v1/repos/{unknown}/sessions returns 404."""
    response = await client.get(
        "/api/v1/repos/does-not-exist/sessions",
        headers=auth_headers,
    )
    assert response.status_code == 404


@pytest.mark.anyio
async def test_create_session_returns_201(
    client: AsyncClient,
    db_session: AsyncSession,
    auth_headers: dict[str, str],
) -> None:
    """POST /api/v1/repos/{repo_id}/sessions creates a session and returns 201."""
    repo_id = await _make_repo(db_session)
    payload = {
        "participants": ["producer-a", "collab-b"],
        "intent": "house beat experiment",
        "location": "Remote – Berlin",
        "isActive": True,
    }
    response = await client.post(
        f"/api/v1/repos/{repo_id}/sessions",
        json=payload,
        headers=auth_headers,
    )
    assert response.status_code == 201
    data = response.json()
    assert data["isActive"] is True
    assert data["intent"] == "house beat experiment"
    assert data["location"] == "Remote \u2013 Berlin"
    assert data["participants"] == ["producer-a", "collab-b"]
    assert "sessionId" in data


@pytest.mark.anyio
async def test_stop_session_marks_ended(
    client: AsyncClient,
    db_session: AsyncSession,
    auth_headers: dict[str, str],
) -> None:
    """POST /api/v1/repos/{repo_id}/sessions/{session_id}/stop closes a live session."""
    repo_id = await _make_repo(db_session)
    session_id = await _make_session(db_session, repo_id, is_active=True)

    response = await client.post(
        f"/api/v1/repos/{repo_id}/sessions/{session_id}/stop",
        json={},
        headers=auth_headers,
    )
    assert response.status_code == 200
    data = response.json()
    assert data["isActive"] is False
    assert data["endedAt"] is not None
    assert data["durationSeconds"] is not None


@pytest.mark.anyio
async def test_active_session_has_null_duration(
    client: AsyncClient,
    db_session: AsyncSession,
    auth_headers: dict[str, str],
) -> None:
    """Active sessions must have durationSeconds=null (session still in progress)."""
    repo_id = await _make_repo(db_session)
    await _make_session(db_session, repo_id, is_active=True)

    response = await client.get(
        f"/api/v1/repos/{repo_id}/sessions",
        headers=auth_headers,
    )
    assert response.status_code == 200
    sess = response.json()["sessions"][0]
    assert sess["isActive"] is True
    assert sess["durationSeconds"] is None


@pytest.mark.anyio
async def test_session_response_includes_commits_and_notes(
    client: AsyncClient,
    db_session: AsyncSession,
    auth_headers: dict[str, str],
) -> None:
    """SessionResponse includes commits list and notes field in the JSON payload."""
    repo_id = await _make_repo(db_session)
    commit_ids = ["abc123", "def456", "ghi789"]
    closing_notes = "Great session, nailed the groove."
    await _make_session(
        db_session,
        repo_id,
        intent="funk groove",
        commits=commit_ids,
        notes=closing_notes,
    )

    response = await client.get(
        f"/api/v1/repos/{repo_id}/sessions",
        headers=auth_headers,
    )
    assert response.status_code == 200
    sess = response.json()["sessions"][0]
    assert sess["commits"] == commit_ids
    assert sess["notes"] == closing_notes


@pytest.mark.anyio
async def test_session_response_commits_field_present(
    client: AsyncClient,
    db_session: AsyncSession,
    auth_headers: dict[str, str],
) -> None:
    """Sessions API response includes the 'commits' field for each session.

    Regression guard: the graph page uses the session commits
    list to build the session→commit index (buildSessionMap). If this field
    is absent or empty when commits exist, no session rings will appear on
    the DAG graph.
    """
    repo_id = await _make_repo(db_session)
    commit_ids = ["abc123def456abc123def456abc123de", "feedbeeffeedbeefdead000000000001"]
    row = MusehubSession(
        repo_id=repo_id,
        started_at=datetime(2025, 3, 1, 10, 0, 0, tzinfo=timezone.utc),
        ended_at=datetime(2025, 3, 1, 11, 0, 0, tzinfo=timezone.utc),
        participants=["artist-a"],
        intent="session with commits",
        location="Studio B",
        is_active=False,
        commits=commit_ids,
    )
    db_session.add(row)
    await db_session.commit()
    await db_session.refresh(row)

    response = await client.get(
        f"/api/v1/repos/{repo_id}/sessions",
        headers=auth_headers,
    )
    assert response.status_code == 200
    sessions = response.json()["sessions"]
    assert len(sessions) == 1
    sess = sessions[0]
    assert "commits" in sess, "'commits' field missing from SessionResponse"
    assert sess["commits"] == commit_ids, "commits field does not match seeded commit IDs"


@pytest.mark.anyio
async def test_session_response_empty_commits_and_notes_defaults(
    client: AsyncClient,
    db_session: AsyncSession,
    auth_headers: dict[str, str],
) -> None:
    """SessionResponse defaults commits to [] and notes to '' when absent."""
    repo_id = await _make_repo(db_session)
    await _make_session(db_session, repo_id, intent="defaults check")

    response = await client.get(
        f"/api/v1/repos/{repo_id}/sessions",
        headers=auth_headers,
    )
    assert response.status_code == 200
    sess = response.json()["sessions"][0]
    assert sess["commits"] == []
    assert sess["notes"] == ""


@pytest.mark.anyio
async def test_session_list_page_contains_avatar_markup(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Sessions list page renders participant names when a session has participants."""
    repo_id = await _make_repo(db_session)
    await _make_session(db_session, repo_id, participants=["producer-a", "bassist"])
    response = await client.get("/testuser/test-beats/sessions")
    assert response.status_code == 200
    body = response.text
    assert "producer-a" in body


@pytest.mark.anyio
async def test_session_list_page_contains_commit_pill_markup(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Sessions list page renders a commit count when a session has commits."""
    repo_id = await _make_repo(db_session)
    await _make_session(db_session, repo_id, commits=["abc123", "def456"])
    response = await client.get("/testuser/test-beats/sessions")
    assert response.status_code == 200
    body = response.text
    assert "commit" in body


@pytest.mark.anyio
async def test_session_list_page_contains_live_indicator_markup(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Sessions list page renders the live dot badge for an active session."""
    repo_id = await _make_repo(db_session)
    await _make_session(db_session, repo_id, is_active=True)
    response = await client.get("/testuser/test-beats/sessions")
    assert response.status_code == 200
    body = response.text
    assert "session-live-dot" in body
    assert "live" in body


@pytest.mark.anyio
async def test_session_list_page_contains_notes_preview_markup(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Sessions list page renders the session notes text when a session has notes."""
    repo_id = await _make_repo(db_session)
    await _make_session(db_session, repo_id, notes="Recorded the main piano riff")
    response = await client.get("/testuser/test-beats/sessions")
    assert response.status_code == 200
    body = response.text
    assert "Recorded the main piano riff" in body


@pytest.mark.anyio
async def test_session_list_page_contains_location_tag_markup(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Sessions list page renders location icon when a session has a location set."""
    repo_id = await _make_repo(db_session)
    await _make_session(db_session, repo_id)  # _make_session sets location="Studio A"
    response = await client.get("/testuser/test-beats/sessions")
    assert response.status_code == 200
    body = response.text
    assert "session-row" in body
    assert "Studio A" in body










# ---------------------------------------------------------------------------
# Form and structure page tests
# ---------------------------------------------------------------------------


@pytest.mark.anyio
async def test_form_structure_page_renders(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /{repo_id}/form-structure/{ref} returns 200 HTML without auth."""
    repo_id = await _make_repo(db_session)
    ref = "abc1234567890abcdef"
    response = await client.get(f"/{repo_id}/form-structure/{ref}")
    assert response.status_code == 200
    assert "text/html" in response.headers["content-type"]
    body = response.text
    assert "MuseHub" in body
    assert "Form" in body


@pytest.mark.anyio
async def test_form_structure_page_no_auth_required(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Form-structure UI page must be accessible without an Authorization header."""
    repo_id = await _make_repo(db_session)
    ref = "deadbeef1234"
    response = await client.get(f"/{repo_id}/form-structure/{ref}")
    assert response.status_code != 401
    assert response.status_code == 200


@pytest.mark.anyio
async def test_form_structure_page_contains_section_map(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Form-structure page renders section map container and dispatches the TS module."""
    repo_id = await _make_repo(db_session)
    ref = "cafebabe1234"
    response = await client.get(f"/{repo_id}/form-structure/{ref}")
    assert response.status_code == 200
    body = response.text
    assert "Section Map" in body
    assert "section-map-content" in body


@pytest.mark.anyio
async def test_form_structure_page_contains_repetition_panel(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Form-structure page renders repetition panel container and dispatches the TS module."""
    repo_id = await _make_repo(db_session)
    ref = "feedface0123"
    response = await client.get(f"/{repo_id}/form-structure/{ref}")
    assert response.status_code == 200
    body = response.text
    assert "Repetition" in body
    assert "repetition-content" in body


@pytest.mark.anyio
async def test_form_structure_page_contains_heatmap(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Form-structure page renders section comparison container and dispatches the TS module."""
    repo_id = await _make_repo(db_session)
    ref = "deadcafe5678"
    response = await client.get(f"/{repo_id}/form-structure/{ref}")
    assert response.status_code == 200
    body = response.text
    assert "Section Comparison" in body
    assert "heatmap-content" in body


@pytest.mark.anyio
async def test_form_structure_page_includes_token_form(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Form-structure page includes the JWT token form and app.js via base.html."""
    repo_id = await _make_repo(db_session)
    ref = "babe1234abcd"
    response = await client.get(f"/{repo_id}/form-structure/{ref}")
    assert response.status_code == 200
    body = response.text
    assert "app.js" in body
    assert "token-form" in body





@pytest.mark.anyio
async def test_form_structure_json_404_unknown_repo(
    client: AsyncClient,
    db_session: AsyncSession,
    auth_headers: dict[str, str],
) -> None:
    """GET /api/v1/repos/{unknown}/form-structure/{ref} returns 404."""
    response = await client.get(
        "/api/v1/repos/does-not-exist/form-structure/abc123",
        headers=auth_headers,
    )
    assert response.status_code == 404



# ---------------------------------------------------------------------------
# Emotion map page tests (migrated to owner/slug routing)
# ---------------------------------------------------------------------------

_EMOTION_REF = "deadbeef12345678"









# ---------------------------------------------------------------------------
# owner/slug navigation link correctness (regression for PR #282)
# ---------------------------------------------------------------------------


@pytest.mark.anyio
async def test_ui_nav_links_use_owner_slug_not_uuid_repo_page(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Repo page must inject owner/slug base URL, not the internal UUID.

    Before the fix, every handler except repo_page used ``const base =
    '/' + repoId``. That produced UUID-based hrefs that 404 under
    the new /{owner}/{repo_slug} routing. This test guards the regression.
    """
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats")
    assert response.status_code == 200
    body = response.text
    # JS base variable must use owner/slug, not UUID concatenation
    assert '"/testuser/test-beats"' in body
    # UUID-concatenation pattern must NOT appear
    assert "'/' + repoId" not in body


@pytest.mark.anyio
async def test_ui_nav_links_use_owner_slug_not_uuid_commit_page(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Commit page back-to-repo link must use owner/slug, not internal UUID."""
    from datetime import datetime, timezone

    repo_id = await _make_repo(db_session)
    commit_id = "abc1234567890123456789012345678901234567"
    commit = MusehubCommit(
        commit_id=commit_id,
        repo_id=repo_id,
        branch="main",
        parent_ids=[],
        message="Test commit",
        author="testuser",
        timestamp=datetime.now(tz=timezone.utc),
    )
    db_session.add(commit)
    await db_session.commit()

    response = await client.get(f"/testuser/test-beats/commits/{commit_id}")
    assert response.status_code == 200
    body = response.text
    assert "/testuser/test-beats" in body
    assert "'/' + repoId" not in body


@pytest.mark.anyio
async def test_ui_nav_links_use_owner_slug_not_uuid_graph_page(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Graph page back-to-repo link must use owner/slug, not internal UUID."""
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/graph")
    assert response.status_code == 200
    body = response.text
    assert '"/testuser/test-beats"' in body
    assert "'/' + repoId" not in body


@pytest.mark.anyio
async def test_ui_nav_links_use_owner_slug_not_uuid_pr_list_page(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """PR list page navigation must use owner/slug, not internal UUID."""
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/pulls")
    assert response.status_code == 200
    body = response.text
    assert '"/testuser/test-beats"' in body
    assert "'/' + repoId" not in body


@pytest.mark.anyio
async def test_ui_nav_links_use_owner_slug_not_uuid_releases_page(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Releases page navigation must use owner/slug, not internal UUID."""
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/releases")
    assert response.status_code == 200
    body = response.text
    assert '"/testuser/test-beats"' in body
    assert "'/' + repoId" not in body


@pytest.mark.anyio
async def test_ui_unknown_owner_slug_returns_404(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /{unknown-owner}/{unknown-slug} must return 404."""
    response = await client.get("/nobody/nonexistent-repo")
    assert response.status_code == 404


# ---------------------------------------------------------------------------
# Issue #199 — Design System Tests
# ---------------------------------------------------------------------------


@pytest.mark.anyio
async def test_design_tokens_css_served(client: AsyncClient) -> None:
    """GET /static/app.css must return 200 with CSS design tokens.

    All CSS (design tokens, components, layout, icons, music) is consolidated
    into app.css. Verifies the bundle is reachable and contains the expected
    custom properties (--bg-base, --color-accent, etc.).
    """
    response = await client.get("/static/app.css")
    assert response.status_code == 200
    assert "text/css" in response.headers.get("content-type", "")
    body = response.text
    assert "--bg-base" in body
    assert "--color-accent" in body
    assert "--dim-harmonic" in body


@pytest.mark.anyio
async def test_components_css_served(client: AsyncClient) -> None:
    """GET /static/app.css contains component classes (.badge, .btn, .card).

    CSS is consolidated into app.css — no separate components.css file exists.
    """
    response = await client.get("/static/app.css")
    assert response.status_code == 200
    assert "text/css" in response.headers.get("content-type", "")
    body = response.text
    assert ".badge" in body
    assert ".btn" in body
    assert ".card" in body


@pytest.mark.anyio
async def test_layout_css_served(client: AsyncClient) -> None:
    """GET /static/app.css contains layout classes (.container etc.)."""
    response = await client.get("/static/app.css")
    assert response.status_code == 200
    assert "text/css" in response.headers.get("content-type", "")
    assert ".container" in response.text


@pytest.mark.anyio
async def test_icons_css_served(client: AsyncClient) -> None:
    """GET /static/app.css contains icon classes (.icon-mid etc.)."""
    response = await client.get("/static/app.css")
    assert response.status_code == 200
    assert "text/css" in response.headers.get("content-type", "")
    assert ".icon-mid" in response.text


@pytest.mark.anyio
async def test_music_css_served(client: AsyncClient) -> None:
    """GET /static/app.css contains music viewer classes (.piano-roll etc.)."""
    response = await client.get("/static/app.css")
    assert response.status_code == 200
    assert "text/css" in response.headers.get("content-type", "")
    assert ".piano-roll" in response.text


@pytest.mark.anyio
async def test_repo_page_uses_design_system(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Repo page HTML must reference the design system stylesheet via base.html.

    app.css is the bundled design system stylesheet loaded by base.html.
    """
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats")
    assert response.status_code == 200
    body = response.text
    assert "/static/app.css" in body


@pytest.mark.anyio
async def test_responsive_meta_tag_present_repo_page(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Repo page must include a viewport meta tag for mobile responsiveness."""
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats")
    assert response.status_code == 200
    assert 'name="viewport"' in response.text


@pytest.mark.anyio
async def test_responsive_meta_tag_present_pr_page(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """PR list page must include a viewport meta tag for mobile responsiveness."""
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/pulls")
    assert response.status_code == 200
    assert 'name="viewport"' in response.text


@pytest.mark.anyio
async def test_responsive_meta_tag_present_issues_page(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Issues page must include a viewport meta tag for mobile responsiveness."""
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/issues")
    assert response.status_code == 200
    assert 'name="viewport"' in response.text


@pytest.mark.anyio
async def test_design_tokens_css_contains_dimension_colors(
    client: AsyncClient,
) -> None:
    """app.css must define all MIDI analysis dimension color tokens.

    Two families of dimension tokens exist:
    - Analysis dimensions (harmonic, rhythmic, melodic, structural, dynamic) —
      used in radar charts and diff heatmaps.
    - MIDI note dimensions (a–e) — used in piano roll track coloring.
    Each dimension has a base token and a muted variant.
    Missing tokens silently break analysis and piano roll visualisations.
    """
    response = await client.get("/static/app.css")
    assert response.status_code == 200
    body = response.text
    # Analysis dimensions
    for dim in ("harmonic", "rhythmic", "melodic", "structural", "dynamic"):
        assert f"--dim-{dim}:" in body, f"Missing analysis dimension token --dim-{dim}"
        assert f"--dim-{dim}-muted:" in body, f"Missing muted variant --dim-{dim}-muted"
    # MIDI note dimensions
    for note in ("a", "b", "c", "d", "e"):
        assert f"--dim-{note}:" in body, f"Missing MIDI note dimension token --dim-{note}"
        assert f"--dim-{note}-muted:" in body, f"Missing muted variant --dim-{note}-muted"
    # Base dimension color
    assert "--dim-color:" in body, "Missing base --dim-color token"


@pytest.mark.anyio
async def test_design_tokens_css_contains_track_colors(
    client: AsyncClient,
) -> None:
    """app.css must define all 8 track color tokens (--track-0 through --track-7)."""
    response = await client.get("/static/app.css")
    assert response.status_code == 200
    body = response.text
    for i in range(8):
        assert f"--track-{i}:" in body, f"Missing track color token --track-{i}"


@pytest.mark.anyio
async def test_badge_variants_in_components_css(client: AsyncClient) -> None:
    """app.css must define all required badge variants including .badge-clean and .badge-dirty."""
    response = await client.get("/static/app.css")
    assert response.status_code == 200
    body = response.text
    for variant in ("open", "closed", "merged", "active", "clean", "dirty"):
        assert f".badge-{variant}" in body, f"Missing badge variant .badge-{variant}"


@pytest.mark.anyio
async def test_file_type_icons_in_icons_css(client: AsyncClient) -> None:
    """app.css must define icon classes for all required file types."""
    response = await client.get("/static/app.css")
    assert response.status_code == 200
    body = response.text
    for ext in ("mid", "mp3", "wav", "json", "webp", "xml", "abc"):
        assert f".icon-{ext}" in body, f"Missing file-type icon .icon-{ext}"


@pytest.mark.anyio
async def test_no_inline_css_on_repo_page(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Repo page must NOT embed the old monolithic CSS string inline.

    Regression test: verifies the _CSS removal was not accidentally reverted.
    The old _CSS block contained the literal string 'background: #0d1117'
    inside a <style> tag in the <head>. After the design system migration,
    all styling comes from external files.
    """
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats")
    body = response.text
    # Find the <head> section — inline CSS should not appear there
    head_end = body.find("</head>")
    head_section = body[:head_end] if head_end != -1 else body
    # The old monolithic block started with "box-sizing: border-box"
    # If it appears inside <head>, the migration has been reverted.
    assert "box-sizing: border-box; margin: 0; padding: 0;" not in head_section


# ---------------------------------------------------------------------------
# Analysis dashboard UI tests
# ---------------------------------------------------------------------------


@pytest.mark.anyio
async def test_analysis_dashboard_renders(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /{owner}/{repo_slug}/insights/{ref} returns 200 HTML without a JWT."""
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/insights/main")
    assert response.status_code == 200
    assert "text/html" in response.headers["content-type"]
    body = response.text
    assert "MuseHub" in body
    assert "Insights" in body
    assert "test-beats" in body


@pytest.mark.anyio
async def test_analysis_dashboard_no_auth_required(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Analysis dashboard HTML shell must be accessible without an Authorization header."""
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/insights/main")
    assert response.status_code == 200
    assert response.status_code != 401


@pytest.mark.anyio
async def test_analysis_dashboard_all_dimension_labels(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Insights dashboard renders correctly for a generic repo.

    For generic repos (no domain), the page renders the Insights shell with
    the repo and ref information available. Dimension labels are shown for
    domain-specific repos (MIDI/Code) via HTMX fragments.
    """
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/insights/main")
    assert response.status_code == 200
    body = response.text
    assert "Insights" in body
    assert "test-beats" in body
    assert "testuser" in body


@pytest.mark.anyio
async def test_analysis_dashboard_sparkline_logic_present(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Insights dashboard renders with the insights nav and ref pill in SSR HTML.

    Updated for domain-agnostic architecture: the dashboard renders insights.html
    which contains the Insights heading and ref/repo info. Dimension cards are
    served via HTMX for domain-specific repos.
    """
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/insights/main")
    assert response.status_code == 200
    body = response.text
    assert "Insights" in body
    assert "test-beats" in body
    assert "/insights/" in body


@pytest.mark.anyio
async def test_analysis_dashboard_card_links_to_dimensions(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Each dimension card must link to the per-dimension analysis detail page.

    The card href is built client-side from ``base + '/insights/' + ref + '/' + id``,
    so the JS template string must reference ``/insights/`` as the path segment.
    """
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/insights/main")
    assert response.status_code == 200
    body = response.text
    assert "/insights/" in body




# ---------------------------------------------------------------------------
# Motifs browser page — # ---------------------------------------------------------------------------








# ---------------------------------------------------------------------------
# Content negotiation & repo home page tests — / #203
# ---------------------------------------------------------------------------


@pytest.mark.anyio
async def test_repo_page_html_default(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /{owner}/{repo_slug} with no Accept header returns HTML by default."""
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats")
    assert response.status_code == 200
    assert "text/html" in response.headers["content-type"]
    body = response.text
    assert "MuseHub" in body
    assert "testuser" in body
    assert "test-beats" in body


@pytest.mark.anyio
async def test_repo_home_shows_stats(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Repo home page renders SSR stat grid with commit count, branches, files, size."""
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats")
    assert response.status_code == 200
    body = response.text
    assert "rh-stat-grid" in body
    assert "Commits" in body


@pytest.mark.anyio
async def test_repo_home_recent_commits(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Repo home page links to commit history via the Explore sidebar and stat grid."""
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats")
    assert response.status_code == 200
    body = response.text
    assert "History" in body
    assert "Commits" in body



@pytest.mark.anyio
async def test_repo_page_json_accept(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /{owner}/{repo_slug} with Accept: application/json returns JSON repo data."""
    await _make_repo(db_session)
    response = await client.get(
        "/testuser/test-beats",
        headers={"Accept": "application/json"},
    )
    assert response.status_code == 200
    assert "application/json" in response.headers["content-type"]
    data = response.json()
    # RepoResponse fields serialised as camelCase
    assert "repoId" in data or "repo_id" in data or "slug" in data or "name" in data


@pytest.mark.anyio
async def test_commits_page_json_format_param(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /{owner}/{repo_slug}/commits?format=json returns JSON commit list."""
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/commits?format=json")
    assert response.status_code == 200
    assert "application/json" in response.headers["content-type"]
    data = response.json()
    # CommitListResponse has commits (list) and total (int)
    assert "commits" in data
    assert "total" in data
    assert isinstance(data["commits"], list)


@pytest.mark.anyio
async def test_json_response_camelcase(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """JSON response from repo page uses camelCase keys matching API convention."""
    await _make_repo(db_session)
    response = await client.get(
        "/testuser/test-beats",
        headers={"Accept": "application/json"},
    )
    assert response.status_code == 200
    data = response.json()
    # All top-level keys must be camelCase — no underscores allowed in field names
    # (Pydantic by_alias=True serialises snake_case fields as camelCase)
    snake_keys = [k for k in data if "_" in k]
    assert snake_keys == [], f"Expected camelCase keys but found snake_case: {snake_keys}"


@pytest.mark.anyio
async def test_commits_list_html_default(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /{owner}/{repo_slug}/commits with no Accept header returns HTML."""
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/commits")
    assert response.status_code == 200
    assert "text/html" in response.headers["content-type"]


# ---------------------------------------------------------------------------
# Tree browser tests — # ---------------------------------------------------------------------------


async def _seed_tree_fixtures(db_session: AsyncSession) -> str:
    """Seed a public repo with a branch and objects for tree browser tests.

    Creates:
    - repo: testuser/tree-test (public)
    - branch: main (head pointing at a dummy commit)
    - objects: tracks/bass.mid, tracks/keys.mp3, metadata.json, cover.webp
    Returns repo_id.
    """
    repo = MusehubRepo(
        name="tree-test",
        owner="testuser",
        slug="tree-test",
        visibility="public",
        owner_user_id="test-owner",
    )
    db_session.add(repo)
    await db_session.flush()

    commit = MusehubCommit(
        commit_id="abc123def456",
        repo_id=str(repo.repo_id),
        message="initial",
        branch="main",
        author="testuser",
        timestamp=datetime.now(tz=UTC),
    )
    db_session.add(commit)

    branch = MusehubBranch(
        repo_id=str(repo.repo_id),
        name="main",
        head_commit_id="abc123def456",
    )
    db_session.add(branch)

    for path, size in [
        ("tracks/bass.mid", 2048),
        ("tracks/keys.mp3", 8192),
        ("metadata.json", 512),
        ("cover.webp", 4096),
    ]:
        obj = MusehubObject(
            object_id=f"sha256:{path.replace('/', '_')}",
            repo_id=str(repo.repo_id),
            path=path,
            size_bytes=size,
            disk_path=f"/tmp/{path.replace('/', '_')}",
        )
        db_session.add(obj)

    await db_session.commit()
    return str(repo.repo_id)


@pytest.mark.anyio
async def test_tree_root_lists_directories(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /{owner}/{repo}/tree/{ref} returns 200 HTML with tree JS."""
    await _seed_tree_fixtures(db_session)
    response = await client.get("/testuser/tree-test/tree/main")
    assert response.status_code == 200
    assert "text/html" in response.headers["content-type"]
    body = response.text
    assert "tree" in body
    assert '"page": "tree"' in body


@pytest.mark.anyio
async def test_tree_subdirectory_lists_files(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /{owner}/{repo}/tree/{ref}/tracks returns 200 HTML for the subdirectory."""
    await _seed_tree_fixtures(db_session)
    response = await client.get("/testuser/tree-test/tree/main/tracks")
    assert response.status_code == 200
    assert "text/html" in response.headers["content-type"]
    body = response.text
    assert "tracks" in body
    assert '"page": "tree"' in body


@pytest.mark.anyio
async def test_tree_file_icons_by_type(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Tree template includes JS that maps extensions to file-type icons."""
    await _seed_tree_fixtures(db_session)
    response = await client.get("/testuser/tree-test/tree/main")
    assert response.status_code == 200
    body = response.text
    # tree.ts handles file-type icon mapping client-side; SSR provides page config
    assert '"page": "tree"' in body


@pytest.mark.anyio
async def test_tree_breadcrumbs_correct(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Tree page breadcrumb contains owner, repo, tree, and ref."""
    await _seed_tree_fixtures(db_session)
    response = await client.get("/testuser/tree-test/tree/main")
    assert response.status_code == 200
    body = response.text
    assert "testuser" in body
    assert "tree-test" in body
    assert "tree" in body
    assert "main" in body


@pytest.mark.anyio
async def test_tree_json_response(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /api/v1/repos/{repo_id}/tree/{ref} returns JSON with tree entries."""
    repo_id = await _seed_tree_fixtures(db_session)
    response = await client.get(
        f"/api/v1/repos/{repo_id}/tree/main"
        f"?owner=testuser&repo_slug=tree-test"
    )
    assert response.status_code == 200
    data = response.json()
    assert "entries" in data
    assert data["ref"] == "main"
    assert data["dirPath"] == ""
    # Root should show: 'tracks' dir, 'metadata.json', 'cover.webp'
    names = {e["name"] for e in data["entries"]}
    assert "tracks" in names
    assert "metadata.json" in names
    assert "cover.webp" in names
    # 'bass.mid' should NOT appear at root (it's under tracks/)
    assert "bass.mid" not in names
    # tracks entry must be a directory
    tracks_entry = next(e for e in data["entries"] if e["name"] == "tracks")
    assert tracks_entry["type"] == "dir"
    assert tracks_entry["sizeBytes"] is None


@pytest.mark.anyio
async def test_tree_unknown_ref_404(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /api/v1/repos/{repo_id}/tree/{unknown_ref} returns 404."""
    repo_id = await _seed_tree_fixtures(db_session)
    response = await client.get(
        f"/api/v1/repos/{repo_id}/tree/does-not-exist"
        f"?owner=testuser&repo_slug=tree-test"
    )
    assert response.status_code == 404


# ---------------------------------------------------------------------------
# Harmony analysis page tests — # ---------------------------------------------------------------------------












# Listen page tests
# ---------------------------------------------------------------------------


async def _seed_listen_fixtures(db_session: AsyncSession) -> str:
    """Seed a repo with audio objects for listen-page tests; return repo_id."""
    repo = MusehubRepo(
        name="listen-test",
        owner="testuser",
        slug="listen-test",
        visibility="public",
        owner_user_id="test-owner",
    )
    db_session.add(repo)
    await db_session.commit()
    await db_session.refresh(repo)
    repo_id = str(repo.repo_id)

    for path, size in [
        ("mix/full_mix.mp3", 204800),
        ("tracks/bass.mp3", 51200),
        ("tracks/keys.mp3", 61440),
        ("tracks/bass.webp", 8192),
    ]:
        obj = MusehubObject(
            object_id=f"sha256:{path.replace('/', '_')}",
            repo_id=repo_id,
            path=path,
            size_bytes=size,
            disk_path=f"/tmp/{path.replace('/', '_')}",
        )
        db_session.add(obj)
    await db_session.commit()
    return repo_id


@pytest.mark.anyio
async def test_listen_page_full_mix(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /{owner}/{repo}/view/{ref} and /insights/{ref} both return 200.

    /view/* is an alias for /insights — same handler, same page, no redirect.
    """
    await _seed_listen_fixtures(db_session)
    ref = "main"
    # /view URL is an alias — returns 200 directly (no redirect)
    response = await client.get(f"/testuser/listen-test/view/{ref}")
    assert response.status_code == 200
    assert "text/html" in response.headers["content-type"]
    assert "MuseHub" in response.text
    # Canonical /insights URL also returns 200
    response2 = await client.get(f"/testuser/listen-test/insights/{ref}")
    assert response2.status_code == 200
    assert "MuseHub" in response2.text


@pytest.mark.anyio
async def test_listen_page_track_listing(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Insights page (aliases /view) renders the domain viewer container server-side."""
    await _seed_listen_fixtures(db_session)
    ref = "main"
    response = await client.get(f"/testuser/listen-test/view/{ref}")
    assert response.status_code == 200
    body = response.text
    # Insights page rendered SSR
    assert "ins-page" in body


@pytest.mark.anyio
async def test_listen_page_no_renders_fallback(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """View page renders successfully for a repo with no committed objects."""
    # Repo with no objects at all
    repo = MusehubRepo(
        name="silent-repo",
        owner="testuser",
        slug="silent-repo",
        visibility="public",
        owner_user_id="test-owner",
    )
    db_session.add(repo)
    await db_session.commit()

    response = await client.get("/testuser/silent-repo/view/main")
    assert response.status_code == 200
    body = response.text
    # Insights page (aliases /view) renders successfully
    assert "ins-page" in body or "MuseHub" in body


@pytest.mark.anyio
async def test_listen_page_json_response(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /{owner}/{repo}/view/{ref} returns HTML (insights page, /view is an alias)."""
    await _seed_listen_fixtures(db_session)
    ref = "main"
    response = await client.get(f"/testuser/listen-test/view/{ref}")
    assert response.status_code == 200
    assert "text/html" in response.headers["content-type"]
    assert "MuseHub" in response.text


# ---------------------------------------------------------------------------
# Issue #366 — musehub_listen service function (direct unit tests)
# ---------------------------------------------------------------------------





# ---------------------------------------------------------------------------
# Issue #206 — Commit list page
# ---------------------------------------------------------------------------

_COMMIT_LIST_OWNER = "commitowner"
_COMMIT_LIST_SLUG = "commit-list-repo"
_SHA_MAIN_1 = "aa001122334455667788990011223344556677889900"
_SHA_MAIN_2 = "bb001122334455667788990011223344556677889900"
_SHA_MAIN_MERGE = "cc001122334455667788990011223344556677889900"
_SHA_FEAT = "ff001122334455667788990011223344556677889900"


async def _seed_commit_list_repo(
    db_session: AsyncSession,
) -> str:
    """Seed a repo with 2 commits on main, 1 merge commit, and 1 on feat branch."""
    repo = MusehubRepo(
        name=_COMMIT_LIST_SLUG,
        owner=_COMMIT_LIST_OWNER,
        slug=_COMMIT_LIST_SLUG,
        visibility="public",
        owner_user_id="commit-owner-uid",
    )
    db_session.add(repo)
    await db_session.flush()
    repo_id = str(repo.repo_id)

    branch_main = MusehubBranch(repo_id=repo_id, name="main", head_commit_id=_SHA_MAIN_MERGE)
    branch_feat = MusehubBranch(repo_id=repo_id, name="feat/drums", head_commit_id=_SHA_FEAT)
    db_session.add_all([branch_main, branch_feat])

    now = datetime.now(UTC)
    commits = [
        MusehubCommit(
            commit_id=_SHA_MAIN_1,
            repo_id=repo_id,
            branch="main",
            parent_ids=[],
            message="feat(bass): root commit with walking bass line",
            author="composer@muse.app",
            timestamp=now - timedelta(hours=4),
        ),
        MusehubCommit(
            commit_id=_SHA_MAIN_2,
            repo_id=repo_id,
            branch="main",
            parent_ids=[_SHA_MAIN_1],
            message="feat(keys): add rhodes chord voicings in verse",
            author="composer@muse.app",
            timestamp=now - timedelta(hours=2),
        ),
        MusehubCommit(
            commit_id=_SHA_MAIN_MERGE,
            repo_id=repo_id,
            branch="main",
            parent_ids=[_SHA_MAIN_2, _SHA_FEAT],
            message="merge(feat/drums): integrate drum pattern into main",
            author="composer@muse.app",
            timestamp=now - timedelta(hours=1),
        ),
        MusehubCommit(
            commit_id=_SHA_FEAT,
            repo_id=repo_id,
            branch="feat/drums",
            parent_ids=[_SHA_MAIN_1],
            message="feat(drums): add kick and snare pattern at 120 BPM",
            author="drummer@muse.app",
            timestamp=now - timedelta(hours=3),
        ),
    ]
    db_session.add_all(commits)
    await db_session.commit()
    return repo_id


@pytest.mark.anyio
async def test_commits_list_page_returns_200(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /{owner}/{repo}/commits returns 200 HTML."""
    await _seed_commit_list_repo(db_session)
    resp = await client.get(f"/{_COMMIT_LIST_OWNER}/{_COMMIT_LIST_SLUG}/commits")
    assert resp.status_code == 200
    assert "text/html" in resp.headers["content-type"]
    assert "MuseHub" in resp.text


@pytest.mark.anyio
async def test_commits_list_page_shows_commit_sha(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Commit SHA (first 8 chars) appears in the rendered HTML."""
    await _seed_commit_list_repo(db_session)
    resp = await client.get(f"/{_COMMIT_LIST_OWNER}/{_COMMIT_LIST_SLUG}/commits")
    assert resp.status_code == 200
    # All 4 commits should appear (per_page=30 default, total=4)
    assert _SHA_MAIN_1[:8] in resp.text
    assert _SHA_MAIN_2[:8] in resp.text
    assert _SHA_MAIN_MERGE[:8] in resp.text
    assert _SHA_FEAT[:8] in resp.text


@pytest.mark.anyio
async def test_commits_list_page_shows_commit_message(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Commit messages appear truncated in commit rows."""
    await _seed_commit_list_repo(db_session)
    resp = await client.get(f"/{_COMMIT_LIST_OWNER}/{_COMMIT_LIST_SLUG}/commits")
    assert resp.status_code == 200
    assert "walking bass line" in resp.text
    assert "rhodes chord voicings" in resp.text


@pytest.mark.anyio
async def test_commits_list_page_dag_indicator(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """DAG node CSS class is present in the HTML for every commit row."""
    await _seed_commit_list_repo(db_session)
    resp = await client.get(f"/{_COMMIT_LIST_OWNER}/{_COMMIT_LIST_SLUG}/commits")
    assert resp.status_code == 200
    assert "dag-node" in resp.text
    assert "commit-list-row" in resp.text


@pytest.mark.anyio
async def test_commits_list_page_merge_indicator(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Merge commits display the merge indicator and dag-node-merge class."""
    await _seed_commit_list_repo(db_session)
    resp = await client.get(f"/{_COMMIT_LIST_OWNER}/{_COMMIT_LIST_SLUG}/commits")
    assert resp.status_code == 200
    assert "dag-node-merge" in resp.text
    assert "merge" in resp.text.lower()


@pytest.mark.anyio
async def test_commits_list_page_branch_selector(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Branch <select> dropdown is present when the repo has branches."""
    await _seed_commit_list_repo(db_session)
    resp = await client.get(f"/{_COMMIT_LIST_OWNER}/{_COMMIT_LIST_SLUG}/commits")
    assert resp.status_code == 200
    # Select element with branch options
    assert "branch-sel" in resp.text
    assert "main" in resp.text
    assert "feat/drums" in resp.text


@pytest.mark.anyio
async def test_commits_list_page_graph_link(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Link to the DAG graph page is present."""
    await _seed_commit_list_repo(db_session)
    resp = await client.get(f"/{_COMMIT_LIST_OWNER}/{_COMMIT_LIST_SLUG}/commits")
    assert resp.status_code == 200
    assert "/graph" in resp.text


@pytest.mark.anyio
async def test_commits_list_page_pagination_links(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Pagination nav links appear when total exceeds per_page."""
    await _seed_commit_list_repo(db_session)
    # Request per_page=2 so 4 commits produce 2 pages
    resp = await client.get(
        f"/{_COMMIT_LIST_OWNER}/{_COMMIT_LIST_SLUG}/commits?per_page=2&page=1"
    )
    assert resp.status_code == 200
    body = resp.text
    # "Older" link should be active (page 1 has no "Newer")
    assert "Older" in body
    # "Newer" should be disabled on page 1
    assert "Newer" in body
    assert "page=2" in body


@pytest.mark.anyio
async def test_commits_list_page_pagination_page2(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Page 2 renders with Newer navigation active."""
    await _seed_commit_list_repo(db_session)
    resp = await client.get(
        f"/{_COMMIT_LIST_OWNER}/{_COMMIT_LIST_SLUG}/commits?per_page=2&page=2"
    )
    assert resp.status_code == 200
    body = resp.text
    assert "page=1" in body # "Newer" link points back to page 1


@pytest.mark.anyio
async def test_commits_list_page_branch_filter_html(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """?branch=main returns only main-branch commits in HTML."""
    await _seed_commit_list_repo(db_session)
    resp = await client.get(
        f"/{_COMMIT_LIST_OWNER}/{_COMMIT_LIST_SLUG}/commits?branch=main"
    )
    assert resp.status_code == 200
    body = resp.text
    # main commits appear
    assert _SHA_MAIN_1[:8] in body
    assert _SHA_MAIN_2[:8] in body
    assert _SHA_MAIN_MERGE[:8] in body
    # feat/drums commit should NOT appear when filtered to main
    assert _SHA_FEAT[:8] not in body


@pytest.mark.anyio
async def test_commits_list_page_json_content_negotiation(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """?format=json returns CommitListResponse JSON with commits and total."""
    await _seed_commit_list_repo(db_session)
    resp = await client.get(
        f"/{_COMMIT_LIST_OWNER}/{_COMMIT_LIST_SLUG}/commits?format=json"
    )
    assert resp.status_code == 200
    assert "application/json" in resp.headers["content-type"]
    body = resp.json()
    assert "commits" in body
    assert "total" in body
    assert body["total"] == 4
    assert len(body["commits"]) == 4
    # Commits are newest first; merge commit has timestamp now-1h (most recent)
    commit_ids = [c["commitId"] for c in body["commits"]]
    assert commit_ids[0] == _SHA_MAIN_MERGE


@pytest.mark.anyio
async def test_commits_list_page_json_pagination(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """JSON with per_page=1&page=2 returns the second commit."""
    await _seed_commit_list_repo(db_session)
    resp = await client.get(
        f"/{_COMMIT_LIST_OWNER}/{_COMMIT_LIST_SLUG}/commits"
        "?format=json&per_page=1&page=2"
    )
    assert resp.status_code == 200
    body = resp.json()
    assert body["total"] == 4
    assert len(body["commits"]) == 1
    # Page 2 (newest-first) is the second most-recent commit.
    # Newest: _SHA_MAIN_MERGE (now-1h), then _SHA_MAIN_2 (now-2h)
    assert body["commits"][0]["commitId"] == _SHA_MAIN_2


@pytest.mark.anyio
async def test_commits_list_page_empty_state(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """A repo with no commits shows the empty state message."""
    repo = MusehubRepo(
        name="empty-repo",
        owner="emptyowner",
        slug="empty-repo",
        visibility="public",
        owner_user_id="empty-owner-uid",
    )
    db_session.add(repo)
    await db_session.commit()

    resp = await client.get("/emptyowner/empty-repo/commits")
    assert resp.status_code == 200
    assert "No commits yet" in resp.text or "muse push" in resp.text


# ---------------------------------------------------------------------------



# ---------------------------------------------------------------------------
# Commit detail enhancements — # ---------------------------------------------------------------------------


async def _seed_commit_detail_fixtures(
    db_session: AsyncSession,
) -> tuple[str, str, str]:
    """Seed a public repo with a parent commit and a child commit.

    Returns (repo_id, parent_commit_id, child_commit_id).
    """
    repo = MusehubRepo(
        name="commit-detail-test",
        owner="testuser",
        slug="commit-detail-test",
        visibility="public",
        owner_user_id="test-owner",
    )
    db_session.add(repo)
    await db_session.flush()
    repo_id = str(repo.repo_id)

    branch = MusehubBranch(
        repo_id=repo_id,
        name="main",
        head_commit_id=None,
    )
    db_session.add(branch)

    parent_commit_id = "aaaa0000111122223333444455556666aaaabbbb"
    child_commit_id = "bbbb1111222233334444555566667777bbbbcccc"

    parent_commit = MusehubCommit(
        repo_id=repo_id,
        commit_id=parent_commit_id,
        branch="main",
        parent_ids=[],
        message="init: establish harmonic foundation in C major\n\nKey: C major\nBPM: 120\nMeter: 4/4",
        author="testuser",
        timestamp=datetime.now(UTC) - timedelta(hours=2),
        snapshot_id=None,
    )
    child_commit = MusehubCommit(
        repo_id=repo_id,
        commit_id=child_commit_id,
        branch="main",
        parent_ids=[parent_commit_id],
        message="feat(keys): add melodic piano phrase in D minor\n\nKey: D minor\nBPM: 132\nMeter: 3/4\nSection: verse",
        author="testuser",
        timestamp=datetime.now(UTC) - timedelta(hours=1),
        snapshot_id=None,
    )
    db_session.add(parent_commit)
    db_session.add(child_commit)
    await db_session.commit()
    return repo_id, parent_commit_id, child_commit_id


@pytest.mark.anyio
async def test_commit_detail_page_renders_enhanced_metadata(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Commit detail page SSR renders commit header fields (SHA, author, branch, parent link)."""
    await _seed_commit_detail_fixtures(db_session)
    sha = "bbbb1111222233334444555566667777bbbbcccc"
    response = await client.get(f"/testuser/commit-detail-test/commits/{sha}")
    assert response.status_code == 200
    assert "text/html" in response.headers["content-type"]
    body = response.text
    # SSR commit header — short SHA present
    assert "bbbb1111" in body
    # Author field rendered server-side
    assert "testuser" in body
    # Parent SHA navigation link present
    assert "aaaa0000" in body


@pytest.mark.anyio
async def test_commit_detail_audio_shell_with_snapshot_id(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Commit with snapshot_id gets a WaveSurfer shell rendered by the server."""
    from datetime import datetime, timezone

    _repo_id, _parent_id, _child_id = await _seed_commit_detail_fixtures(db_session)
    repo = MusehubRepo(
        name="audio-test-repo",
        owner="testuser",
        slug="audio-test-repo",
        visibility="public",
        owner_user_id="test-owner",
    )
    db_session.add(repo)
    await db_session.flush()
    snap_id = "sha256:deadbeef12345678deadbeef12345678deadbeef12345678deadbeef12345678"
    commit_with_audio = MusehubCommit(
        commit_id="cccc2222333344445555666677778888ccccdddd",
        repo_id=str(repo.repo_id),
        branch="main",
        parent_ids=[],
        message="Commit with audio snapshot",
        author="testuser",
        timestamp=datetime.now(tz=timezone.utc),
        snapshot_id=snap_id,
    )
    db_session.add(commit_with_audio)
    await db_session.commit()

    response = await client.get(
        f"/testuser/audio-test-repo/commits/cccc2222333344445555666677778888ccccdddd"
    )
    assert response.status_code == 200
    body = response.text
    # Commit page renders successfully; audio shell shown only for piano_roll domain repos
    assert "audio-test-repo" in body
    assert "Commit with audio snapshot" in body


@pytest.mark.anyio
async def test_commit_detail_ssr_message_present_in_body(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Commit message text is rendered in the SSR page body (replaces JS renderCommitBody)."""
    await _seed_commit_detail_fixtures(db_session)
    sha = "bbbb1111222233334444555566667777bbbbcccc"
    response = await client.get(f"/testuser/commit-detail-test/commits/{sha}")
    assert response.status_code == 200
    body = response.text
    # SSR renders the commit message directly — no JS renderCommitBody needed
    assert "feat(keys): add melodic piano phrase in D minor" in body


@pytest.mark.anyio
async def test_commit_detail_diff_summary_endpoint_returns_five_dimensions(
    client: AsyncClient,
    db_session: AsyncSession,
    auth_headers: dict[str, str],
) -> None:
    """GET /api/v1/repos/{repo_id}/commits/{sha}/diff-summary returns 5 dimensions."""
    repo_id, _parent_id, child_id = await _seed_commit_detail_fixtures(db_session)
    response = await client.get(
        f"/api/v1/repos/{repo_id}/commits/{child_id}/diff-summary",
        headers=auth_headers,
    )
    assert response.status_code == 200
    data = response.json()
    assert data["commitId"] == child_id
    assert data["parentId"] == _parent_id
    assert "dimensions" in data
    assert len(data["dimensions"]) == 5
    dim_names = {d["dimension"] for d in data["dimensions"]}
    assert dim_names == {"harmonic", "rhythmic", "melodic", "structural", "dynamic"}
    for dim in data["dimensions"]:
        assert 0.0 <= dim["score"] <= 1.0
        assert dim["label"] in {"none", "low", "medium", "high"}
        assert dim["color"] in {"dim-none", "dim-low", "dim-medium", "dim-high"}
    assert "overallScore" in data
    assert 0.0 <= data["overallScore"] <= 1.0


@pytest.mark.anyio
async def test_commit_detail_diff_summary_root_commit_scores_one(
    client: AsyncClient,
    db_session: AsyncSession,
    auth_headers: dict[str, str],
) -> None:
    """Diff summary for a root commit (no parent) scores all dimensions at 1.0."""
    repo_id, parent_id, _child_id = await _seed_commit_detail_fixtures(db_session)
    response = await client.get(
        f"/api/v1/repos/{repo_id}/commits/{parent_id}/diff-summary",
        headers=auth_headers,
    )
    assert response.status_code == 200
    data = response.json()
    assert data["parentId"] is None
    for dim in data["dimensions"]:
        assert dim["score"] == 1.0
        assert dim["label"] == "high"


@pytest.mark.anyio
async def test_commit_detail_diff_summary_keyword_detection(
    client: AsyncClient,
    db_session: AsyncSession,
    auth_headers: dict[str, str],
) -> None:
    """Diff summary detects melodic keyword in child commit message."""
    repo_id, _parent_id, child_id = await _seed_commit_detail_fixtures(db_session)
    response = await client.get(
        f"/api/v1/repos/{repo_id}/commits/{child_id}/diff-summary",
        headers=auth_headers,
    )
    assert response.status_code == 200
    data = response.json()
    melodic_dim = next(d for d in data["dimensions"] if d["dimension"] == "melodic")
    # child commit message contains "melodic" keyword → non-zero score
    assert melodic_dim["score"] > 0.0


@pytest.mark.anyio
async def test_commit_detail_diff_summary_unknown_commit_404(
    client: AsyncClient,
    db_session: AsyncSession,
    auth_headers: dict[str, str],
) -> None:
    """Diff summary for unknown commit ID returns 404."""
    repo_id, _p, _c = await _seed_commit_detail_fixtures(db_session)
    response = await client.get(
        f"/api/v1/repos/{repo_id}/commits/deadbeefdeadbeefdeadbeef/diff-summary",
        headers=auth_headers, )
    assert response.status_code == 404


# ---------------------------------------------------------------------------
# Commit comment threads — # ---------------------------------------------------------------------------


@pytest.mark.anyio
async def test_commit_page_has_comment_section_html(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Commit detail page HTML includes the HTMX comment target container."""
    from datetime import datetime, timezone

    repo_id = await _make_repo(db_session)
    commit_id = "abc1234567890abcdef1234567890abcdef12345678"
    commit = MusehubCommit(
        commit_id=commit_id,
        repo_id=repo_id,
        branch="main",
        parent_ids=[],
        message="Add chorus section",
        author="testuser",
        timestamp=datetime.now(tz=timezone.utc),
    )
    db_session.add(commit)
    await db_session.commit()

    response = await client.get(f"/testuser/test-beats/commits/{commit_id}")
    assert response.status_code == 200
    body = response.text
    # SSR replaces JS-loaded comment section with a server-rendered HTMX target
    assert "commit-comments" in body
    assert "hx-target" in body


@pytest.mark.anyio
async def test_commit_page_has_htmx_comment_form(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Commit detail page has an HTMX-driven comment form (replaces old JS comment functions)."""
    from datetime import datetime, timezone

    repo_id = await _make_repo(db_session)
    commit_id = "abc1234567890abcdef1234567890abcdef12345678"
    commit = MusehubCommit(
        commit_id=commit_id,
        repo_id=repo_id,
        branch="main",
        parent_ids=[],
        message="Add chorus section",
        author="testuser",
        timestamp=datetime.now(tz=timezone.utc),
    )
    db_session.add(commit)
    await db_session.commit()

    response = await client.get(f"/testuser/test-beats/commits/{commit_id}")
    assert response.status_code == 200
    body = response.text
    # HTMX form replaces JS renderComments/submitComment/loadComments
    assert "hx-post" in body
    assert "hx-target" in body
    assert "textarea" in body


@pytest.mark.anyio
async def test_commit_page_comment_htmx_target_present(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """HTMX comment target div is present for server-side comment injection."""
    from datetime import datetime, timezone

    repo_id = await _make_repo(db_session)
    commit_id = "abc1234567890abcdef1234567890abcdef12345678"
    commit = MusehubCommit(
        commit_id=commit_id,
        repo_id=repo_id,
        branch="main",
        parent_ids=[],
        message="Add chorus section",
        author="testuser",
        timestamp=datetime.now(tz=timezone.utc),
    )
    db_session.add(commit)
    await db_session.commit()

    response = await client.get(f"/testuser/test-beats/commits/{commit_id}")
    assert response.status_code == 200
    body = response.text
    assert 'id="commit-comments"' in body


@pytest.mark.anyio
async def test_commit_page_comment_htmx_posts_to_comments_endpoint(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """HTMX form posts to the commit comments endpoint (replaces old JS API fetch)."""
    from datetime import datetime, timezone

    repo_id = await _make_repo(db_session)
    commit_id = "abc1234567890abcdef1234567890abcdef12345678"
    commit = MusehubCommit(
        commit_id=commit_id,
        repo_id=repo_id,
        branch="main",
        parent_ids=[],
        message="Add chorus section",
        author="testuser",
        timestamp=datetime.now(tz=timezone.utc),
    )
    db_session.add(commit)
    await db_session.commit()

    response = await client.get(f"/testuser/test-beats/commits/{commit_id}")
    assert response.status_code == 200
    body = response.text
    assert "hx-post" in body
    assert "/comments" in body


@pytest.mark.anyio
async def test_commit_page_comment_has_ssr_avatar(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Commit page SSR comment thread renders avatar initials via server-side template."""
    from datetime import datetime, timezone

    repo_id = await _make_repo(db_session)
    commit_id = "abc1234567890abcdef1234567890abcdef12345678"
    commit = MusehubCommit(
        commit_id=commit_id,
        repo_id=repo_id,
        branch="main",
        parent_ids=[],
        message="Add chorus section",
        author="testuser",
        timestamp=datetime.now(tz=timezone.utc),
    )
    db_session.add(commit)
    await db_session.commit()

    response = await client.get(f"/testuser/test-beats/commits/{commit_id}")
    assert response.status_code == 200
    body = response.text
    # comment-avatar only rendered when comments exist; check commit page structure
    assert "commit-detail" in body or "page-data" in body


@pytest.mark.anyio
async def test_commit_page_comment_has_htmx_form_elements(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Commit page HTMX comment form has textarea and submit button."""
    from datetime import datetime, timezone

    repo_id = await _make_repo(db_session)
    commit_id = "abc1234567890abcdef1234567890abcdef12345678"
    commit = MusehubCommit(
        commit_id=commit_id,
        repo_id=repo_id,
        branch="main",
        parent_ids=[],
        message="Add chorus section",
        author="testuser",
        timestamp=datetime.now(tz=timezone.utc),
    )
    db_session.add(commit)
    await db_session.commit()

    response = await client.get(f"/testuser/test-beats/commits/{commit_id}")
    assert response.status_code == 200
    body = response.text
    # HTMX form replaces old new-comment-form/new-comment-body/comment-submit-btn
    assert 'name="body"' in body
    assert "btn-primary" in body
    assert "Comment" in body


@pytest.mark.anyio
async def test_commit_page_comment_section_shows_count_heading(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Commit page SSR comment section shows a count heading (replaces 'Discussion' heading)."""
    from datetime import datetime, timezone

    repo_id = await _make_repo(db_session)
    commit_id = "abc1234567890abcdef1234567890abcdef12345678"
    commit = MusehubCommit(
        commit_id=commit_id,
        repo_id=repo_id,
        branch="main",
        parent_ids=[],
        message="Add chorus section",
        author="testuser",
        timestamp=datetime.now(tz=timezone.utc),
    )
    db_session.add(commit)
    await db_session.commit()

    response = await client.get(f"/testuser/test-beats/commits/{commit_id}")
    assert response.status_code == 200
    body = response.text
    assert "comment" in body


# ---------------------------------------------------------------------------
# Commit detail enhancements — ref URL links, DB tags in panel, prose
# summary
# ---------------------------------------------------------------------------


@pytest.mark.anyio
async def test_commit_page_ssr_renders_commit_message(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Commit message is rendered server-side (replaces JS ref-tag / tagPill rendering)."""
    from datetime import datetime, timezone

    repo_id = await _make_repo(db_session)
    commit_id = "abc1234567890abcdef1234567890abcdef12345678"
    commit = MusehubCommit(
        commit_id=commit_id,
        repo_id=repo_id,
        branch="main",
        parent_ids=[],
        message="Unique groove message XYZ",
        author="testuser",
        timestamp=datetime.now(tz=timezone.utc),
    )
    db_session.add(commit)
    await db_session.commit()

    response = await client.get(f"/testuser/test-beats/commits/{commit_id}")
    assert response.status_code == 200
    body = response.text
    # SSR renders commit message directly — no JS tagPill/isRefUrl needed
    assert "Unique groove message XYZ" in body


@pytest.mark.anyio
async def test_commit_page_ssr_renders_author_metadata(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Commit author and branch appear in the SSR metadata grid (replaces JS muse-tags panel)."""
    from datetime import datetime, timezone

    repo_id = await _make_repo(db_session)
    commit_id = "abc1234567890abcdef1234567890abcdef12345678"
    commit = MusehubCommit(
        commit_id=commit_id,
        repo_id=repo_id,
        branch="main",
        parent_ids=[],
        message="Add chorus section",
        author="jazzproducer",
        timestamp=datetime.now(tz=timezone.utc),
    )
    db_session.add(commit)
    await db_session.commit()

    response = await client.get(f"/testuser/test-beats/commits/{commit_id}")
    assert response.status_code == 200
    body = response.text
    # SSR metadata grid shows author — no JS loadMuseTagsPanel needed
    assert "jazzproducer" in body


@pytest.mark.anyio
async def test_commit_page_no_audio_shell_when_no_snapshot(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Commit page without snapshot_id omits WaveSurfer shell (replaces buildProseSummary check)."""
    from datetime import datetime, timezone

    repo_id = await _make_repo(db_session)
    commit_id = "abc1234567890abcdef1234567890abcdef12345678"
    commit = MusehubCommit(
        commit_id=commit_id,
        repo_id=repo_id,
        branch="main",
        parent_ids=[],
        message="Add chorus section",
        author="testuser",
        timestamp=datetime.now(tz=timezone.utc),
        snapshot_id=None,
    )
    db_session.add(commit)
    await db_session.commit()

    response = await client.get(f"/testuser/test-beats/commits/{commit_id}")
    assert response.status_code == 200
    body = response.text
    assert "commit-waveform" not in body


# ---------------------------------------------------------------------------
# Audio player — listen page tests
# ---------------------------------------------------------------------------


@pytest.mark.anyio
async def test_listen_page_renders(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /{owner}/{slug}/view/{ref} must return 200 HTML."""
    await _make_repo(db_session)
    ref = "abc1234567890abcdef"
    response = await client.get(f"/testuser/test-beats/view/{ref}")
    assert response.status_code == 200
    assert "text/html" in response.headers["content-type"]


@pytest.mark.anyio
async def test_listen_page_no_auth_required(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Listen page must be accessible without an Authorization header."""
    await _make_repo(db_session)
    ref = "deadbeef1234"
    response = await client.get(f"/testuser/test-beats/view/{ref}")
    assert response.status_code != 401
    assert response.status_code == 200


@pytest.mark.anyio
async def test_listen_page_contains_waveform_ui(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Listen page HTML must contain the page config for listen.ts."""
    await _make_repo(db_session)
    ref = "cafebabe1234"
    response = await client.get(f"/testuser/test-beats/view/{ref}")
    assert response.status_code == 200
    body = response.text
    assert '"viewerType"' in body


@pytest.mark.anyio
async def test_listen_page_contains_play_button(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Listen page must dispatch the listen.ts module via page config."""
    await _make_repo(db_session)
    ref = "feed1234abcdef"
    response = await client.get(f"/testuser/test-beats/view/{ref}")
    assert response.status_code == 200
    body = response.text
    assert '"viewerType"' in body


@pytest.mark.anyio
async def test_listen_page_contains_speed_selector(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Listen page must dispatch the listen.ts module (speed selector is client-side)."""
    await _make_repo(db_session)
    ref = "1a2b3c4d5e6f7890"
    response = await client.get(f"/testuser/test-beats/view/{ref}")
    assert response.status_code == 200
    body = response.text
    assert '"viewerType"' in body


@pytest.mark.anyio
async def test_listen_page_contains_ab_loop_ui(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Listen page must dispatch the listen.ts module (A/B loop controls are client-side)."""
    await _make_repo(db_session)
    ref = "aabbccddeeff0011"
    response = await client.get(f"/testuser/test-beats/view/{ref}")
    assert response.status_code == 200
    body = response.text
    assert '"viewerType"' in body


@pytest.mark.anyio
async def test_listen_page_loads_wavesurfer_vendor(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Listen page must dispatch the listen.ts module (WaveSurfer loaded via app.js bundle)."""
    await _make_repo(db_session)
    ref = "112233445566778899"
    response = await client.get(f"/testuser/test-beats/view/{ref}")
    assert response.status_code == 200
    body = response.text
    # WaveSurfer is now bundled/loaded by listen.ts, not as a separate script tag
    assert '"viewerType"' in body
    # wavesurfer must NOT be loaded from an external CDN
    assert "unpkg.com/wavesurfer" not in body
    assert "cdn.jsdelivr.net/wavesurfer" not in body
    assert "cdnjs.cloudflare.com/ajax/libs/wavesurfer" not in body


@pytest.mark.anyio
async def test_listen_page_loads_audio_player_js(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Listen page must dispatch the listen.ts module (audio player is now bundled in app.js)."""
    await _make_repo(db_session)
    ref = "99aabbccddeeff00"
    response = await client.get(f"/testuser/test-beats/view/{ref}")
    assert response.status_code == 200
    body = response.text
    assert '"viewerType"' in body


@pytest.mark.anyio
async def test_listen_track_page_renders(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /{owner}/{slug}/view/{ref}/{path} must return 200."""
    await _make_repo(db_session)
    ref = "feedface0011aabb"
    response = await client.get(
        f"/testuser/test-beats/view/{ref}/tracks/bass.mp3"
    )
    assert response.status_code == 200
    assert "text/html" in response.headers["content-type"]


@pytest.mark.anyio
async def test_listen_track_page_has_track_path_in_js(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Track path is passed via page config JSON to listen.ts, not as a JS variable."""
    await _make_repo(db_session)
    ref = "00aabbccddeeff11"
    track = "tracks/lead-guitar.mp3"
    response = await client.get(
        f"/testuser/test-beats/view/{ref}/{track}"
    )
    assert response.status_code == 200
    body = response.text
    assert '"viewerType"' in body
    assert "lead-guitar.mp3" in body


@pytest.mark.anyio
async def test_listen_page_unknown_repo_404(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET listen page with nonexistent owner/slug must return 404."""
    response = await client.get(
        "/nobody/nonexistent-repo/view/abc123"
    )
    assert response.status_code == 404


@pytest.mark.anyio
async def test_listen_page_keyboard_shortcuts_documented(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Listen page dispatches listen.ts (keyboard shortcuts handled client-side)."""
    await _make_repo(db_session)
    ref = "cafe0011aabb2233"
    response = await client.get(f"/testuser/test-beats/view/{ref}")
    assert response.status_code == 200
    body = response.text
    assert '"viewerType"' in body


# ---------------------------------------------------------------------------
# Compare view
# ---------------------------------------------------------------------------




@pytest.mark.anyio
async def test_compare_page_invalid_ref_404(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Compare path without '...' separator returns 404."""
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/compare/mainfeature")
    assert response.status_code == 404


@pytest.mark.anyio
async def test_compare_page_unknown_owner_404(
    client: AsyncClient,
) -> None:
    """Unknown owner/slug combination returns 404 on compare page."""
    response = await client.get("/nobody/norepo/compare/main...feature")
    assert response.status_code == 404








# ---------------------------------------------------------------------------
# Issue #208 — Branch list and tag browser tests
# ---------------------------------------------------------------------------


async def _make_repo_with_branches(
    db_session: AsyncSession,
) -> tuple[str, str, str]:
    """Seed a repo with two branches (main + feature) and return (repo_id, owner, slug)."""
    repo = MusehubRepo(
        name="branch-test",
        owner="testuser",
        slug="branch-test",
        visibility="private",
        owner_user_id="test-owner",
    )
    db_session.add(repo)
    await db_session.flush()
    repo_id = str(repo.repo_id)

    main_branch = MusehubBranch(repo_id=repo_id, name="main", head_commit_id="aaa000")
    feat_branch = MusehubBranch(repo_id=repo_id, name="feat/jazz-bridge", head_commit_id="bbb111")
    db_session.add_all([main_branch, feat_branch])

    # Two commits on main, one unique commit on feat/jazz-bridge
    now = datetime.now(UTC)
    c1 = MusehubCommit(
        commit_id="aaa000",
        repo_id=repo_id,
        branch="main",
        parent_ids=[],
        message="Initial commit",
        author="composer@muse.app",
        timestamp=now,
    )
    c2 = MusehubCommit(
        commit_id="aaa001",
        repo_id=repo_id,
        branch="main",
        parent_ids=["aaa000"],
        message="Add bridge",
        author="composer@muse.app",
        timestamp=now,
    )
    c3 = MusehubCommit(
        commit_id="bbb111",
        repo_id=repo_id,
        branch="feat/jazz-bridge",
        parent_ids=["aaa000"],
        message="Add jazz chord",
        author="composer@muse.app",
        timestamp=now,
    )
    db_session.add_all([c1, c2, c3])
    await db_session.commit()
    return repo_id, "testuser", "branch-test"


async def _make_repo_with_releases(
    db_session: AsyncSession,
) -> tuple[str, str, str]:
    """Seed a repo with namespaced releases used as tags."""
    repo = MusehubRepo(
        name="tag-test",
        owner="testuser",
        slug="tag-test",
        visibility="private",
        owner_user_id="test-owner",
    )
    db_session.add(repo)
    await db_session.flush()
    repo_id = str(repo.repo_id)

    now = datetime.now(UTC)
    releases = [
        MusehubRelease(
            repo_id=repo_id, tag="emotion:happy", title="Happy vibes", body="",
            commit_id="abc001", author="composer", created_at=now, download_urls={},
        ),
        MusehubRelease(
            repo_id=repo_id, tag="genre:jazz", title="Jazz release", body="",
            commit_id="abc002", author="composer", created_at=now, download_urls={},
        ),
        MusehubRelease(
            repo_id=repo_id, tag="v1.0", title="Version 1.0", body="",
            commit_id="abc003", author="composer", created_at=now, download_urls={},
        ),
    ]
    db_session.add_all(releases)
    await db_session.commit()
    return repo_id, "testuser", "tag-test"


@pytest.mark.anyio
async def test_branches_page_lists_all(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /{owner}/{slug}/branches returns 200 HTML."""
    await _make_repo_with_branches(db_session)
    resp = await client.get("/testuser/branch-test/branches")
    assert resp.status_code == 200
    assert "text/html" in resp.headers["content-type"]
    body = resp.text
    assert "MuseHub" in body
    # Page-specific JS identifiers
    assert "branch-row" in body or "branches" in body.lower()


@pytest.mark.anyio
async def test_branches_default_marked(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """JSON response marks the default branch with isDefault=true."""
    await _make_repo_with_branches(db_session)
    resp = await client.get(
        "/testuser/branch-test/branches",
        headers={"Accept": "application/json"},
    )
    assert resp.status_code == 200
    data = resp.json()
    assert "branches" in data
    default_branches = [b for b in data["branches"] if b.get("isDefault")]
    assert len(default_branches) == 1
    assert default_branches[0]["name"] == "main"


@pytest.mark.anyio
async def test_branches_compare_link(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Branches page HTML contains compare link JavaScript."""
    await _make_repo_with_branches(db_session)
    resp = await client.get("/testuser/branch-test/branches")
    assert resp.status_code == 200
    body = resp.text
    # The JS template must reference the compare URL pattern
    assert "compare" in body.lower()


@pytest.mark.anyio
async def test_branches_new_pr_button(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Branches page HTML contains New Pull Request link JavaScript."""
    await _make_repo_with_branches(db_session)
    resp = await client.get("/testuser/branch-test/branches")
    assert resp.status_code == 200
    body = resp.text
    assert "Pull Request" in body


@pytest.mark.anyio
async def test_branches_json_response(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """JSON response includes branches with ahead/behind counts and divergence placeholder."""
    await _make_repo_with_branches(db_session)
    resp = await client.get(
        "/testuser/branch-test/branches?format=json",
    )
    assert resp.status_code == 200
    data = resp.json()
    assert "branches" in data
    assert "defaultBranch" in data
    assert data["defaultBranch"] == "main"

    branches_by_name = {b["name"]: b for b in data["branches"]}
    assert "main" in branches_by_name
    assert "feat/jazz-bridge" in branches_by_name

    main = branches_by_name["main"]
    assert main["isDefault"] is True
    assert main["aheadCount"] == 0
    assert main["behindCount"] == 0

    feat = branches_by_name["feat/jazz-bridge"]
    assert feat["isDefault"] is False
    # feat has 1 unique commit (bbb111); main has 2 commits (aaa000, aaa001) not shared with feat
    assert feat["aheadCount"] == 1
    assert feat["behindCount"] == 2

    # Divergence is a placeholder (all None)
    div = feat["divergence"]
    assert div["melodic"] is None
    assert div["harmonic"] is None


@pytest.mark.anyio
async def test_tags_page_lists_all(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /{owner}/{slug}/tags returns 200 HTML."""
    await _make_repo_with_releases(db_session)
    resp = await client.get("/testuser/tag-test/tags")
    assert resp.status_code == 200
    assert "text/html" in resp.headers["content-type"]
    body = resp.text
    assert "MuseHub" in body
    assert "Tags" in body


@pytest.mark.anyio
async def test_tags_namespace_filter(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Tags page HTML includes namespace filter dropdown JavaScript."""
    await _make_repo_with_releases(db_session)
    resp = await client.get("/testuser/tag-test/tags")
    assert resp.status_code == 200
    body = resp.text
    # Namespace filter select element is rendered by JS
    assert "ns-filter" in body or "namespace" in body.lower()
    # Namespace icons present
    assert "&#127768;" in body or "emotion" in body


@pytest.mark.anyio
async def test_tags_json_response(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """JSON response returns TagListResponse with namespace grouping."""
    await _make_repo_with_releases(db_session)
    resp = await client.get(
        "/testuser/tag-test/tags?format=json",
    )
    assert resp.status_code == 200
    data = resp.json()
    assert "tags" in data
    assert "namespaces" in data

    # All three releases become tags
    assert len(data["tags"]) == 3

    tags_by_name = {t["tag"]: t for t in data["tags"]}
    assert "emotion:happy" in tags_by_name
    assert "genre:jazz" in tags_by_name
    assert "v1.0" in tags_by_name

    assert tags_by_name["emotion:happy"]["namespace"] == "emotion"
    assert tags_by_name["genre:jazz"]["namespace"] == "genre"
    assert tags_by_name["v1.0"]["namespace"] == "version"

    # Namespaces are sorted
    assert sorted(data["namespaces"]) == data["namespaces"]
    assert "emotion" in data["namespaces"]
    assert "genre" in data["namespaces"]
    assert "version" in data["namespaces"]



# ---------------------------------------------------------------------------
# Arrangement matrix page — # ---------------------------------------------------------------------------


# ---------------------------------------------------------------------------
# Piano roll page tests — # ---------------------------------------------------------------------------


@pytest.mark.anyio
async def test_arrange_page_returns_200(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /{owner}/{slug}/view/{ref} returns 200 HTML without a JWT."""
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/view/HEAD")
    assert response.status_code == 200
    assert "text/html" in response.headers["content-type"]


@pytest.mark.anyio
async def test_piano_roll_page_returns_200(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /{owner}/{slug}/view/{ref} returns 200 HTML."""
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/view/main")
    assert response.status_code == 200
    assert "text/html" in response.headers["content-type"]


@pytest.mark.anyio
async def test_arrange_page_no_auth_required(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Arrangement matrix page is accessible without a JWT (auth handled client-side)."""
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/view/HEAD")
    assert response.status_code == 200
    assert response.status_code != 401


@pytest.mark.anyio
async def test_arrange_page_contains_musehub(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Arrangement matrix page HTML shell contains 'MuseHub' branding."""
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/view/abc1234")
    assert response.status_code == 200
    assert "MuseHub" in response.text


@pytest.mark.anyio
async def test_arrange_page_contains_grid_js(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Insights page (aliases /view) renders the domain viewer container."""
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/view/HEAD")
    assert response.status_code == 200
    body = response.text
    assert "ins-page" in body


@pytest.mark.anyio
async def test_arrange_page_contains_density_logic(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Domain view page embeds the viewerType in page config JSON."""
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/view/HEAD")
    assert response.status_code == 200
    body = response.text
    assert "viewerType" in body


@pytest.mark.anyio
async def test_arrange_page_contains_token_form(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Insights page (aliases /view) renders successfully with MuseHub branding."""
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/view/HEAD")
    assert response.status_code == 200
    body = response.text
    assert "MuseHub" in body
    assert "ins-page" in body


@pytest.mark.anyio
async def test_arrange_page_unknown_repo_returns_404(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /{unknown}/{slug}/view/{ref} returns 404 for unknown repos."""
    response = await client.get("/unknown-user/no-such-repo/view/HEAD")
    assert response.status_code == 404


@pytest.mark.anyio
async def test_commit_detail_unknown_format_param_returns_html(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET commit detail page ignores ?format=json — SSR always returns HTML."""
    await _seed_commit_detail_fixtures(db_session)
    sha = "bbbb1111222233334444555566667777bbbbcccc"
    response = await client.get(
        f"/testuser/commit-detail-test/commits/{sha}?format=json"
    )
    assert response.status_code == 200
    assert "text/html" in response.headers["content-type"]
    # SSR commit page — commit message appears in body
    assert "feat(keys)" in response.text


@pytest.mark.anyio
async def test_commit_detail_wavesurfer_js_conditional_on_audio_url(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """WaveSurfer JS block is only present when audio_url is set (replaces musicalMeta JS checks)."""
    await _seed_commit_detail_fixtures(db_session)
    sha = "bbbb1111222233334444555566667777bbbbcccc"
    response = await client.get(f"/testuser/commit-detail-test/commits/{sha}")
    assert response.status_code == 200
    body = response.text
    # The child commit has no snapshot_id in _seed_commit_detail_fixtures → no WaveSurfer
    assert "commit-waveform" not in body
    # WaveSurfer script only loaded when audio is present — not here
    assert "wavesurfer.min.js" not in body


@pytest.mark.anyio
async def test_commit_detail_nav_has_parent_link(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Commit detail page navigation includes the parent commit link (SSR)."""
    await _seed_commit_detail_fixtures(db_session)
    sha = "bbbb1111222233334444555566667777bbbbcccc"
    response = await client.get(f"/testuser/commit-detail-test/commits/{sha}")
    assert response.status_code == 200
    body = response.text
    # SSR renders parent commit link when parent_ids is non-empty
    assert "Parent" in body
    # Parent SHA abbreviated to 8 chars in href
    assert "aaaa0000" in body


@pytest.mark.anyio
async def test_piano_roll_page_no_auth_required(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Piano roll UI page is accessible without a JWT token."""
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/view/main")
    assert response.status_code == 200


@pytest.mark.anyio
async def test_piano_roll_page_loads_piano_roll_js(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """View page embeds the viewerType in page config JSON."""
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/view/main")
    assert response.status_code == 200
    assert "viewerType" in response.text


@pytest.mark.anyio
async def test_piano_roll_page_contains_canvas(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Insights page (aliases /view) renders the domain viewer container server-side."""
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/view/main")
    assert response.status_code == 200
    body = response.text
    assert "ins-page" in body


@pytest.mark.anyio
async def test_piano_roll_page_has_token_form(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Insights page (aliases /view) renders the domain viewer container and page config."""
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats/view/main")
    assert response.status_code == 200
    assert "ins-page" in response.text
    assert "viewerType" in response.text


@pytest.mark.anyio
async def test_piano_roll_page_unknown_repo_404(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Piano roll page for an unknown repo returns 404."""
    response = await client.get("/nobody/no-repo/view/main")
    assert response.status_code == 404


@pytest.mark.anyio
async def test_arrange_tab_in_repo_nav(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Repo home page navigation includes an Insights link for the domain viewer."""
    await _make_repo(db_session)
    response = await client.get("/testuser/test-beats")
    assert response.status_code == 200
    assert "/insights/" in response.text


@pytest.mark.anyio
async def test_piano_roll_track_page_returns_200(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /view/{ref}/{path} (single track) returns 200."""
    await _make_repo(db_session)
    response = await client.get(
        "/testuser/test-beats/view/main/tracks/bass.mid"
    )
    assert response.status_code == 200


@pytest.mark.anyio
async def test_piano_roll_track_page_embeds_path(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Single-track piano roll page embeds the MIDI file path in the JS context."""
    await _make_repo(db_session)
    response = await client.get(
        "/testuser/test-beats/view/main/tracks/bass.mid"
    )
    assert response.status_code == 200
    assert "tracks/bass.mid" in response.text


@pytest.mark.anyio
async def test_piano_roll_js_served(client: AsyncClient) -> None:
    """GET /static/piano-roll.js returns 200 JavaScript."""
    response = await client.get("/static/piano-roll.js")
    assert response.status_code == 200
    assert "javascript" in response.headers.get("content-type", "")


@pytest.mark.anyio
async def test_piano_roll_js_contains_renderer(client: AsyncClient) -> None:
    """piano-roll.js exports the PianoRoll.render function."""
    response = await client.get("/static/piano-roll.js")
    assert response.status_code == 200
    body = response.text
    assert "PianoRoll" in body
    assert "render" in body



async def _seed_blob_fixtures(db_session: AsyncSession) -> str:
    """Seed a public repo with a branch and typed objects for blob viewer tests.

    Creates:
    - repo: testuser/blob-test (public)
    - branch: main
    - objects: tracks/bass.mid, tracks/keys.mp3, metadata.json, cover.webp

    Returns repo_id.
    """
    repo = MusehubRepo(
        name="blob-test",
        owner="testuser",
        slug="blob-test",
        visibility="public",
        owner_user_id="test-owner",
    )
    db_session.add(repo)
    await db_session.flush()

    commit = MusehubCommit(
        commit_id="blobdeadbeef12",
        repo_id=str(repo.repo_id),
        message="add blob fixtures",
        branch="main",
        author="testuser",
        timestamp=datetime.now(tz=UTC),
    )
    db_session.add(commit)

    branch = MusehubBranch(
        repo_id=str(repo.repo_id),
        name="main",
        head_commit_id="blobdeadbeef12",
    )
    db_session.add(branch)

    for path, size in [
        ("tracks/bass.mid", 2048),
        ("tracks/keys.mp3", 8192),
        ("metadata.json", 512),
        ("cover.webp", 4096),
    ]:
        obj = MusehubObject(
            object_id=f"sha256:blob_{path.replace('/', '_')}",
            repo_id=str(repo.repo_id),
            path=path,
            size_bytes=size,
            disk_path=f"/tmp/blob_{path.replace('/', '_')}",
        )
        db_session.add(obj)

    await db_session.commit()
    return str(repo.repo_id)



@pytest.mark.anyio
async def test_blob_404_unknown_path(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /api/v1/repos/{repo_id}/blob/{ref}/{path} returns 404 for unknown path."""
    repo_id = await _seed_blob_fixtures(db_session)
    response = await client.get(f"/api/v1/repos/{repo_id}/blob/main/does/not/exist.mid")
    assert response.status_code == 404


@pytest.mark.anyio
async def test_blob_image_shows_inline(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Blob page for .webp file includes image config in the page_json data block."""
    await _seed_blob_fixtures(db_session)
    response = await client.get("/testuser/blob-test/blob/main/cover.webp")
    assert response.status_code == 200
    body = response.text
    # blob.ts handles image rendering client-side; SSR provides config via page_json
    assert '"page": "blob"' in body
    assert "cover.webp" in body


@pytest.mark.anyio
async def test_blob_json_response(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /api/v1/repos/{repo_id}/blob/{ref}/{path} returns BlobMetaResponse JSON."""
    repo_id = await _seed_blob_fixtures(db_session)
    response = await client.get(
        f"/api/v1/repos/{repo_id}/blob/main/tracks/bass.mid"
    )
    assert response.status_code == 200
    data = response.json()
    assert data["path"] == "tracks/bass.mid"
    assert data["filename"] == "bass.mid"
    assert data["sizeBytes"] == 2048
    assert data["fileType"] == "midi"
    assert data["sha"].startswith("sha256:")
    assert "/raw/" in data["rawUrl"]
    # MIDI is binary — no content_text
    assert data["contentText"] is None
@pytest.mark.anyio
async def test_blob_json_syntax_highlighted(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Blob page for .json file includes syntax-highlighting config in page_json data block."""
    await _seed_blob_fixtures(db_session)
    response = await client.get("/testuser/blob-test/blob/main/metadata.json")
    assert response.status_code == 200
    body = response.text
    # blob.ts handles syntax highlighting client-side; SSR provides config via page_json
    assert '"page": "blob"' in body
    assert "metadata.json" in body


@pytest.mark.anyio
async def test_blob_midi_shows_piano_roll_link(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /{owner}/{repo}/blob/{ref}/{path} returns 200 HTML for a .mid file.

    The template's client-side JS must reference the piano roll URL pattern so that
    clicking the page in a browser navigates to the piano roll viewer.
    """
    await _seed_blob_fixtures(db_session)
    response = await client.get("/testuser/blob-test/blob/main/tracks/bass.mid")
    assert response.status_code == 200
    assert "text/html" in response.headers["content-type"]
    body = response.text
    # JS in the template constructs piano-roll URLs for MIDI files
    assert "piano-roll" in body or "Piano Roll" in body
    # Filename is embedded in the page context
    assert "bass.mid" in body



@pytest.mark.anyio
async def test_blob_raw_button(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Blob page JS constructs a Raw download link via the /raw/ endpoint."""
    await _seed_blob_fixtures(db_session)
    response = await client.get("/testuser/blob-test/blob/main/tracks/bass.mid")
    assert response.status_code == 200
    body = response.text
    # JS constructs raw URL — the string '/raw/' must appear in the template script
    assert "/raw/" in body










@pytest.mark.anyio
async def test_score_unknown_repo_404(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /{unknown}/{slug}/score/{ref} returns 404."""
    response = await client.get("/nobody/no-beats/score/main")
    assert response.status_code == 404


# ---------------------------------------------------------------------------
# Arrangement matrix page — # ---------------------------------------------------------------------------


# ---------------------------------------------------------------------------
# Piano roll page tests — # ---------------------------------------------------------------------------


@pytest.mark.anyio
async def test_ui_commit_page_artifact_auth_uses_blob_proxy(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Commit detail page (SSR, issue #583) returns 404 for non-existent commits.

    The pre-SSR blob-proxy artifact pattern no longer applies — artifacts are loaded
    via the API. Non-existent commit SHAs now return 404 rather than an empty JS shell.
    """
    await _make_repo(db_session)
    commit_id = "abc1234567890abcdef1234567890abcdef12345678"
    response = await client.get(f"/testuser/test-beats/commits/{commit_id}")
    assert response.status_code == 404


# ---------------------------------------------------------------------------
# Reaction bars — # ---------------------------------------------------------------------------


@pytest.mark.anyio
async def test_reaction_bar_js_in_musehub_js(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """musehub.js must define loadReactions and toggleReaction for all detail pages."""
    response = await client.get("/static/musehub.js")
    assert response.status_code == 200
    body = response.text
    assert "loadReactions" in body
    assert "toggleReaction" in body
    assert "REACTION_BAR_EMOJIS" in body


@pytest.mark.anyio
async def test_reaction_bar_emojis_in_musehub_js(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """musehub.js reaction bar must include all 8 required emojis."""
    response = await client.get("/static/musehub.js")
    assert response.status_code == 200
    body = response.text
    for emoji in ["🔥", "❤️", "👏", "✨", "🎵", "🎸", "🎹", "🥁"]:
        assert emoji in body, f"Emoji {emoji!r} missing from musehub.js"


@pytest.mark.anyio
async def test_reaction_bar_commit_page_has_load_call(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Commit detail page (SSR, issue #583) returns 404 for non-existent commits.

    Reactions are loaded via the API; the reaction bar is no longer a JS-only element
    in the SSR commit_detail.html template. Non-existent commits return 404.
    """
    await _make_repo(db_session)
    commit_id = "abc1234567890abcdef1234567890abcdef12345678"
    response = await client.get(f"/testuser/test-beats/commits/{commit_id}")
    assert response.status_code == 404


@pytest.mark.anyio
async def test_reaction_bar_pr_detail_has_load_call(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """PR detail page renders SSR pull request content."""
    from musehub.db.musehub_models import MusehubPullRequest
    repo_id = await _make_repo(db_session)
    pr = MusehubPullRequest(
        repo_id=repo_id,
        title="Test PR for reaction bar",
        body="",
        state="open",
        from_branch="feat/test",
        to_branch="main",
        author="testuser",
    )
    db_session.add(pr)
    await db_session.commit()
    await db_session.refresh(pr)
    pr_id = str(pr.pr_id)

    response = await client.get(f"/testuser/test-beats/pulls/{pr_id}")
    assert response.status_code == 200
    body = response.text
    assert "pd-layout" in body
    assert pr_id[:8] in body


@pytest.mark.anyio
async def test_reaction_bar_issue_detail_has_load_call(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Issue detail page renders SSR issue content."""
    from musehub.db.musehub_models import MusehubIssue
    repo_id = await _make_repo(db_session)
    issue = MusehubIssue(
        repo_id=repo_id,
        number=1,
        title="Test issue for reaction bar",
        body="",
        state="open",
        labels=[],
        author="testuser",
    )
    db_session.add(issue)
    await db_session.commit()

    response = await client.get("/testuser/test-beats/issues/1")
    assert response.status_code == 200
    body = response.text
    assert "id-layout" in body
    assert "Test issue for reaction bar" in body


@pytest.mark.anyio
async def test_reaction_bar_release_detail_has_load_call(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Release detail page renders SSR release content (includes loadReactions call)."""
    repo_id = await _make_repo(db_session)
    release = MusehubRelease(
        repo_id=repo_id,
        tag="v1.0",
        title="Test Release v1.0",
        body="Initial release notes.",
        author="testuser",
    )
    db_session.add(release)
    await db_session.commit()

    response = await client.get("/testuser/test-beats/releases/v1.0")
    assert response.status_code == 200
    body = response.text
    assert "v1.0" in body
    assert "Test Release v1.0" in body
    assert "rd-header" in body
    assert '"page": "release-detail"' in body


@pytest.mark.anyio
async def test_reaction_bar_session_detail_has_load_call(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Session detail page renders SSR session content."""
    repo_id = await _make_repo(db_session)
    session_id = await _make_session(db_session, repo_id)

    response = await client.get(f"/testuser/test-beats/sessions/{session_id}")
    assert response.status_code == 200
    body = response.text
    assert "Session" in body
    assert session_id[:8] in body


@pytest.mark.anyio
async def test_reaction_api_allows_new_emojis(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """POST /reactions with 👏 and 🎹 (new emojis) must be accepted (not 400)."""
    from musehub.db.musehub_models import MusehubRepo
    repo = MusehubRepo(
        name="reaction-test",
        owner="testuser",
        slug="reaction-test",
        visibility="public",
        owner_user_id="reaction-owner",
    )
    db_session.add(repo)
    await db_session.commit()
    await db_session.refresh(repo)
    repo_id = str(repo.repo_id)

    token_headers = {"Authorization": "Bearer test-token"}

    for emoji in ["👏", "🎹"]:
        response = await client.post(
            f"/api/v1/repos/{repo_id}/reactions",
            json={"target_type": "commit", "target_id": "abc123", "emoji": emoji},
            headers=token_headers,
        )
        assert response.status_code not in (400, 422), (
            f"Emoji {emoji!r} rejected by API: {response.status_code} {response.text}"
        )


@pytest.mark.anyio
async def test_reaction_api_allows_release_and_session_target_types(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """POST /reactions must accept 'release' and 'session' as target_type values.

    These target types were added to support reaction bars on
    release_detail and session_detail pages.
    """
    from musehub.db.musehub_models import MusehubRepo
    repo = MusehubRepo(
        name="target-type-test",
        owner="testuser",
        slug="target-type-test",
        visibility="public",
        owner_user_id="target-type-owner",
    )
    db_session.add(repo)
    await db_session.commit()
    await db_session.refresh(repo)
    repo_id = str(repo.repo_id)

    token_headers = {"Authorization": "Bearer test-token"}

    for target_type in ["release", "session"]:
        response = await client.post(
            f"/api/v1/repos/{repo_id}/reactions",
            json={"target_type": target_type, "target_id": "some-id", "emoji": "🔥"},
            headers=token_headers,
        )
        assert response.status_code not in (400, 422), (
            f"target_type {target_type!r} rejected: {response.status_code} {response.text}"
        )


@pytest.mark.anyio
async def test_reaction_bar_css_loaded_on_detail_pages(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Detail pages return 200 and load app.css (base stylesheet)."""
    from musehub.db.musehub_models import MusehubIssue, MusehubPullRequest
    repo_id = await _make_repo(db_session)

    pr = MusehubPullRequest(
        repo_id=repo_id,
        title="CSS test PR",
        body="",
        state="open",
        from_branch="feat/css",
        to_branch="main",
        author="testuser",
    )
    db_session.add(pr)
    issue = MusehubIssue(
        repo_id=repo_id,
        number=1,
        title="CSS test issue",
        body="",
        state="open",
        labels=[],
        author="testuser",
    )
    db_session.add(issue)
    release = MusehubRelease(
        repo_id=repo_id,
        tag="v1.0",
        title="CSS test release",
        body="",
        author="testuser",
    )
    db_session.add(release)
    await db_session.commit()
    await db_session.refresh(pr)
    pr_id = str(pr.pr_id)
    session_id = await _make_session(db_session, repo_id)

    pages = [
        f"/testuser/test-beats/pulls/{pr_id}",
        "/testuser/test-beats/issues/1",
        "/testuser/test-beats/releases/v1.0",
        f"/testuser/test-beats/sessions/{session_id}",
    ]
    for page in pages:
        response = await client.get(page)
        assert response.status_code == 200, f"Expected 200 for {page}, got {response.status_code}"
        assert "app.css" in response.text, f"app.css missing from {page}"


@pytest.mark.anyio
async def test_reaction_bar_components_css_has_styles(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """app.css must define .reaction-bar and .reaction-btn CSS classes."""
    response = await client.get("/static/app.css")
    assert response.status_code == 200
    body = response.text
    assert ".reaction-bar" in body
    assert ".reaction-btn" in body
    assert ".reaction-btn--active" in body
    assert ".reaction-count" in body


# ---------------------------------------------------------------------------
# Feed page tests — (rich event cards)
# ---------------------------------------------------------------------------


@pytest.mark.anyio
async def test_feed_page_returns_200(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /feed returns 200 HTML without requiring a JWT."""
    response = await client.get("/feed")
    assert response.status_code == 200
    assert "text/html" in response.headers["content-type"]
    assert "Activity Feed" in response.text


@pytest.mark.anyio
async def test_feed_page_no_raw_json_payload(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Feed page must not render raw JSON.stringify of notification payload.

    Regression guard: the old implementation called
    JSON.stringify(item.payload) directly into the DOM, exposing raw JSON
    to users. The new rich card templates must not do this.
    """
    response = await client.get("/feed")
    assert response.status_code == 200
    body = response.text
    assert "JSON.stringify(item.payload" not in body
    assert "JSON.stringify(item" not in body


@pytest.mark.anyio
async def test_feed_page_has_event_meta_for_all_types(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Feed page dispatches feed.ts which handles all 8 notification event types."""
    response = await client.get("/feed")
    assert response.status_code == 200
    body = response.text
    assert '"page": "feed"' in body


@pytest.mark.anyio
async def test_feed_page_has_data_notif_id_attribute(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Feed page renders via feed.ts; data-notif-id attached client-side."""
    response = await client.get("/feed")
    assert response.status_code == 200
    assert '"page": "feed"' in response.text


@pytest.mark.anyio
async def test_feed_page_has_unread_indicator(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Feed page dispatches feed.ts which highlights unread cards client-side."""
    response = await client.get("/feed")
    assert response.status_code == 200
    body = response.text
    assert '"page": "feed"' in body


@pytest.mark.anyio
async def test_feed_page_has_actor_avatar_logic(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Feed page dispatches feed.ts; actorHsl / actorAvatar helpers live in that module."""
    response = await client.get("/feed")
    assert response.status_code == 200
    assert '"page": "feed"' in response.text


@pytest.mark.anyio
async def test_feed_page_has_relative_timestamp(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Feed page dispatches feed.ts; fmtRelative called client-side by that module."""
    response = await client.get("/feed")
    assert response.status_code == 200
    assert '"page": "feed"' in response.text


# ---------------------------------------------------------------------------
# Mark-as-read UX tests — # ---------------------------------------------------------------------------


@pytest.mark.anyio
async def test_feed_page_has_mark_one_read_function(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Feed page dispatches feed.ts; markOneRead() lives in that module."""
    response = await client.get("/feed")
    assert response.status_code == 200
    assert '"page": "feed"' in response.text


@pytest.mark.anyio
async def test_feed_page_has_mark_all_read_function(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Feed page dispatches feed.ts; markAllRead() lives in that module."""
    response = await client.get("/feed")
    assert response.status_code == 200
    assert '"page": "feed"' in response.text


@pytest.mark.anyio
async def test_feed_page_has_decrement_nav_badge_function(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Feed page dispatches feed.ts; decrementNavBadge() lives in that module."""
    response = await client.get("/feed")
    assert response.status_code == 200
    assert '"page": "feed"' in response.text


@pytest.mark.anyio
async def test_feed_page_mark_read_btn_targets_notification_endpoint(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Feed page dispatches feed.ts; mark-read calls handled client-side by that module."""
    response = await client.get("/feed")
    assert response.status_code == 200
    assert '"page": "feed"' in response.text


@pytest.mark.anyio
async def test_feed_page_mark_all_btn_targets_read_all_endpoint(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Feed page dispatches feed.ts; read-all endpoint called client-side by that module."""
    response = await client.get("/feed")
    assert response.status_code == 200
    assert '"page": "feed"' in response.text


@pytest.mark.anyio
async def test_feed_page_mark_all_btn_present_in_template(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Feed page dispatches feed.ts; mark-all-read button rendered client-side."""
    response = await client.get("/feed")
    assert response.status_code == 200
    assert '"page": "feed"' in response.text


@pytest.mark.anyio
async def test_feed_page_mark_read_updates_nav_badge(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Feed page dispatches feed.ts; nav-notif-badge updated client-side by that module."""
    response = await client.get("/feed")
    assert response.status_code == 200
    assert '"page": "feed"' in response.text


# ---------------------------------------------------------------------------
# Per-dimension analysis detail pages
# ---------------------------------------------------------------------------




















# ---------------------------------------------------------------------------
# Issue #295 — Profile page: followers/following lists with user cards
# ---------------------------------------------------------------------------

# test_profile_page_has_followers_following_tabs
# test_profile_page_has_user_card_js
# test_profile_page_has_switch_tab_js
# test_followers_list_endpoint_returns_200
# test_followers_list_returns_user_cards_for_known_user
# test_following_list_returns_user_cards_for_known_user
# test_followers_list_unknown_user_404
# test_following_list_unknown_user_404
# test_followers_response_includes_following_count
# test_followers_list_empty_for_user_with_no_followers


async def _make_follow(
    db_session: AsyncSession,
    follower_id: str,
    followee_id: str,
) -> MusehubFollow:
    """Seed a follow relationship and return the ORM row."""
    import uuid
    row = MusehubFollow(
        follow_id=str(uuid.uuid4()),
        follower_id=follower_id,
        followee_id=followee_id,
    )
    db_session.add(row)
    await db_session.commit()
    return row


@pytest.mark.anyio
async def test_profile_page_has_followers_following_tabs(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Profile page renders Followers and Following tab buttons."""
    await _make_profile(db_session, username="tabuser")
    response = await client.get("/tabuser")
    assert response.status_code == 200
    body = response.text
    assert 'data-tab="followers"' in body
    assert 'data-tab="following"' in body




@pytest.mark.anyio
async def test_profile_page_has_switch_tab_js(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Profile page must include switchTab() to toggle between followers and following."""
    await _make_profile(db_session, username="switchtabuser")
    response = await client.get("/switchtabuser")
    assert response.status_code == 200
    # switchTab moved to app.js TypeScript module; check page dispatch and tab structure
    assert '"page": "user-profile"' in response.text
    assert "tab-btn" in response.text


@pytest.mark.anyio
async def test_followers_list_endpoint_returns_200(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /api/v1/users/{username}/followers-list returns 200 for known user."""
    await _make_profile(db_session, username="followerlistuser")
    response = await client.get("/api/v1/users/followerlistuser/followers-list")
    assert response.status_code == 200
    assert isinstance(response.json(), list)


@pytest.mark.anyio
async def test_followers_list_returns_user_cards_for_known_user(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """followers-list returns UserCard objects when followers exist."""
    import uuid

    target = MusehubProfile(
        user_id="target-user-fl-01",
        username="flctarget",
        bio="I am the target",
        avatar_url=None,
        pinned_repo_ids=[],
    )
    follower = MusehubProfile(
        user_id="follower-user-fl-01",
        username="flcfollower",
        bio="I am a follower",
        avatar_url=None,
        pinned_repo_ids=[],
    )
    db_session.add(target)
    db_session.add(follower)
    await db_session.flush()
    # Seed a follow row using user_ids (same convention as the seed script)
    await _make_follow(db_session, follower_id="follower-user-fl-01", followee_id="target-user-fl-01")

    response = await client.get("/api/v1/users/flctarget/followers-list")
    assert response.status_code == 200
    cards = response.json()
    assert len(cards) >= 1
    usernames = [c["username"] for c in cards]
    assert "flcfollower" in usernames


@pytest.mark.anyio
async def test_following_list_returns_user_cards_for_known_user(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """following-list returns UserCard objects for users that the target follows."""
    actor = MusehubProfile(
        user_id="actor-user-fl-02",
        username="flcactor",
        bio="I follow people",
        avatar_url=None,
        pinned_repo_ids=[],
    )
    followee = MusehubProfile(
        user_id="followee-user-fl-02",
        username="flcfollowee",
        bio="I am followed",
        avatar_url=None,
        pinned_repo_ids=[],
    )
    db_session.add(actor)
    db_session.add(followee)
    await db_session.flush()
    await _make_follow(db_session, follower_id="actor-user-fl-02", followee_id="followee-user-fl-02")

    response = await client.get("/api/v1/users/flcactor/following-list")
    assert response.status_code == 200
    cards = response.json()
    assert len(cards) >= 1
    usernames = [c["username"] for c in cards]
    assert "flcfollowee" in usernames


@pytest.mark.anyio
async def test_followers_list_unknown_user_404(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """followers-list returns 404 when the target username does not exist."""
    response = await client.get("/api/v1/users/nonexistent-ghost-user/followers-list")
    assert response.status_code == 404


@pytest.mark.anyio
async def test_following_list_unknown_user_404(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """following-list returns 404 when the target username does not exist."""
    response = await client.get("/api/v1/users/nonexistent-ghost-user/following-list")
    assert response.status_code == 404


@pytest.mark.anyio
async def test_followers_response_includes_following_count(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """GET /users/{username}/followers now includes following_count in response."""
    await _make_profile(db_session, username="followcountuser")
    response = await client.get("/api/v1/users/followcountuser/followers")
    assert response.status_code == 200
    data = response.json()
    assert "followerCount" in data or "follower_count" in data
    assert "followingCount" in data or "following_count" in data


@pytest.mark.anyio
async def test_followers_list_empty_for_user_with_no_followers(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """followers-list returns an empty list when no one follows the user."""
    await _make_profile(db_session, username="lonelyuser295")
    response = await client.get("/api/v1/users/lonelyuser295/followers-list")
    assert response.status_code == 200
    assert response.json() == []


# ---------------------------------------------------------------------------
# Issue #450 — Enhanced commit detail: inline audio player, muse_tags panel,
# reactions, comment thread, cross-references
# ---------------------------------------------------------------------------


@pytest.mark.anyio
async def test_commit_page_has_inline_audio_player_section(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Commit detail page (SSR, issue #583) renders WaveSurfer shell when snapshot_id is set.

    Post-SSR migration: the audio player shell (commit-waveform + WaveSurfer script)
    is rendered only when the commit has a snapshot_id. Non-existent commits → 404.
    """
    from datetime import datetime, timezone
    from musehub.db.musehub_models import MusehubCommit

    repo = MusehubRepo(
        name="audio-player-test",
        owner="audiouser",
        slug="audio-player-test",
        visibility="public",
        owner_user_id="audio-uid",
    )
    db_session.add(repo)
    await db_session.commit()
    await db_session.refresh(repo)

    snap_id = "sha256:deadbeefcafe"
    commit_id = "c0ffee0000111122223333444455556666c0ffee"
    commit = MusehubCommit(
        commit_id=commit_id,
        repo_id=str(repo.repo_id),
        branch="main",
        parent_ids=[],
        message="Add audio snapshot",
        author="audiouser",
        timestamp=datetime.now(tz=timezone.utc),
        snapshot_id=snap_id,
    )
    db_session.add(commit)
    await db_session.commit()

    response = await client.get(f"/audiouser/audio-player-test/commits/{commit_id}")
    assert response.status_code == 200
    body = response.text
    # SSR commit page renders for any repo type
    assert "audio-player-test" in body
    assert "Add audio snapshot" in body
    assert "audioUser" in body.lower() or "audiouser" in body.lower()


@pytest.mark.anyio
async def test_commit_page_inline_player_has_track_selector_js(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Commit detail page (SSR, issue #583) returns 404 for non-existent commits.

    Track selector JS was part of the pre-SSR commit.html. The new commit_detail.html
    renders a simplified WaveSurfer shell from the commit's snapshot_id.
    Non-existent commits return 404 rather than an empty JS shell.
    """
    repo = MusehubRepo(
        name="track-sel-test",
        owner="trackuser",
        slug="track-sel-test",
        visibility="public",
        owner_user_id="track-uid",
    )
    db_session.add(repo)
    await db_session.commit()
    await db_session.refresh(repo)

    commit_id = "aaaa1111bbbb2222cccc3333dddd4444eeee5555"
    response = await client.get(f"/trackuser/track-sel-test/commits/{commit_id}")
    assert response.status_code == 404


@pytest.mark.anyio
async def test_commit_page_has_muse_tags_panel(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Commit detail page (SSR, issue #583) returns 404 for non-existent commits.

    The muse-tags-panel was a JS-only construct in the pre-SSR commit.html.
    The new commit_detail.html renders metadata server-side; the muse-tags panel
    is not present. Non-existent commits return 404.
    """
    repo = MusehubRepo(
        name="tags-panel-test",
        owner="tagsuser",
        slug="tags-panel-test",
        visibility="public",
        owner_user_id="tags-uid",
    )
    db_session.add(repo)
    await db_session.commit()
    await db_session.refresh(repo)

    commit_id = "1234567890abcdef1234567890abcdef12345678"
    response = await client.get(f"/tagsuser/tags-panel-test/commits/{commit_id}")
    assert response.status_code == 404


@pytest.mark.anyio
async def test_commit_page_muse_tags_pill_colours_defined(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Commit detail page (SSR, issue #583) returns 404 for non-existent commits.

    Muse-pill CSS classes were part of the pre-SSR commit.html analysis panel.
    The new commit_detail.html does not include muse-pill classes.
    Non-existent commits return 404.
    """
    repo = MusehubRepo(
        name="pill-colour-test",
        owner="pilluser",
        slug="pill-colour-test",
        visibility="public",
        owner_user_id="pill-uid",
    )
    db_session.add(repo)
    await db_session.commit()
    await db_session.refresh(repo)

    commit_id = "abcd1234ef567890abcd1234ef567890abcd1234"
    response = await client.get(f"/pilluser/pill-colour-test/commits/{commit_id}")
    assert response.status_code == 404


@pytest.mark.anyio
async def test_commit_page_has_cross_references_section(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Commit detail page (SSR, issue #583) returns 404 for non-existent commits.

    The cross-references panel (xrefs-body, loadCrossReferences) was a JS-only
    construct in the pre-SSR commit.html. The new commit_detail.html does not
    include this panel. Non-existent commits return 404.
    """
    repo = MusehubRepo(
        name="xrefs-test",
        owner="xrefsuser",
        slug="xrefs-test",
        visibility="public",
        owner_user_id="xrefs-uid",
    )
    db_session.add(repo)
    await db_session.commit()
    await db_session.refresh(repo)

    commit_id = "face000011112222333344445555666677778888"
    response = await client.get(f"/xrefsuser/xrefs-test/commits/{commit_id}")
    assert response.status_code == 404


@pytest.mark.anyio
async def test_commit_page_context_passes_listen_and_embed_urls(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """commit_page() (SSR, issue #583) injects listenUrl and embedUrl into the JS page-data block.

    The SSR template still exposes these URLs server-side for the JS and for
    navigation links. Requires the commit to exist in the DB.
    """
    from datetime import datetime, timezone
    from musehub.db.musehub_models import MusehubCommit

    repo = MusehubRepo(
        name="url-context-test",
        owner="urluser",
        slug="url-context-test",
        visibility="public",
        owner_user_id="url-uid",
    )
    db_session.add(repo)
    await db_session.commit()
    await db_session.refresh(repo)

    commit_id = "dead0000beef1111dead0000beef1111dead0000"
    commit = MusehubCommit(
        commit_id=commit_id,
        repo_id=str(repo.repo_id),
        branch="main",
        parent_ids=[],
        message="URL context test commit",
        author="urluser",
        timestamp=datetime.now(tz=timezone.utc),
    )
    db_session.add(commit)
    await db_session.commit()

    response = await client.get(f"/urluser/url-context-test/commits/{commit_id}")
    assert response.status_code == 200
    body = response.text
    assert "audioUrl" in body
    assert "viewerType" in body
    # /view/ link only appears for piano_roll domain repos; diff link is always present
    assert f"/commits/{commit_id}/diff" in body


# ---------------------------------------------------------------------------
# Issue #442 — Repo landing page enrichment panels
# Explore page — filter sidebar + inline audio preview
# ---------------------------------------------------------------------------


@pytest.mark.anyio
async def test_repo_home_contributors_panel_js(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Repo home page links to the credits page (SSR — no client-side contributor panel JS)."""
    repo = MusehubRepo(
        name="contrib-panel-test",
        owner="contribowner",
        slug="contrib-panel-test",
        visibility="public",
        owner_user_id="contrib-uid",
    )
    db_session.add(repo)
    await db_session.commit()

    response = await client.get("/contribowner/contrib-panel-test")
    assert response.status_code == 200
    body = response.text
    assert "MuseHub" in body
    assert "contribowner" in body
    assert "contrib-panel-test" in body


@pytest.mark.anyio
async def test_repo_home_activity_heatmap_js(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Repo home page renders SSR repo metadata (no client-side heatmap JS)."""
    repo = MusehubRepo(
        name="heatmap-panel-test",
        owner="heatmapowner",
        slug="heatmap-panel-test",
        visibility="public",
        owner_user_id="heatmap-uid",
    )
    db_session.add(repo)
    await db_session.commit()

    response = await client.get("/heatmapowner/heatmap-panel-test")
    assert response.status_code == 200
    body = response.text
    assert "MuseHub" in body
    assert "heatmapowner" in body
    assert "heatmap-panel-test" in body


@pytest.mark.anyio
async def test_repo_home_instrument_bar_js(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Repo home page renders SSR repo metadata (no client-side instrument-bar JS)."""
    repo = MusehubRepo(
        name="instrbar-panel-test",
        owner="instrbarowner",
        slug="instrbar-panel-test",
        visibility="public",
        owner_user_id="instrbar-uid",
    )
    db_session.add(repo)
    await db_session.commit()

    response = await client.get("/instrbarowner/instrbar-panel-test")
    assert response.status_code == 200
    body = response.text
    assert "MuseHub" in body
    assert "instrbarowner" in body
    assert "instrbar-panel-test" in body


@pytest.mark.anyio
async def test_repo_home_clone_widget_renders(
    client: AsyncClient,
    db_session: AsyncSession,
) -> None:
    """Repo home page renders clone URLs server-side into read-only inputs."""
    repo = MusehubRepo(
        name="clone-widget-test",
        owner="cloneowner",
        slug="clone-widget-test",
        visibility="public",
        owner_user_id="clone-uid",
    )
    db_session.add(repo)
    await db_session.commit()

    response = await client.get("/cloneowner/clone-widget-test")
    assert response.status_code == 200
    body = response.text

    # Clone URLs injected server-side by repo_page()
    assert "musehub://cloneowner/clone-widget-test" in body
    assert "https://musehub.ai/cloneowner/clone-widget-test" in body
    # SSH is not supported — must not appear
    assert "git@" not in body
    # SSR clone widget DOM elements
    assert "clone-input" in body
async def test_explore_page_returns_200(
    client: AsyncClient,
) -> None:
    """GET /explore returns 200 without authentication."""
    response = await client.get("/explore")
    assert response.status_code == 200


@pytest.mark.anyio
async def test_explore_page_has_filter_sidebar(
    client: AsyncClient,
) -> None:
    """Explore page renders a filter sidebar with sort, license, and clear-filters sections."""
    response = await client.get("/explore")
    assert response.status_code == 200
    body = response.text
    assert "ex-sidebar" in body
    assert "Clear filters" in body
    assert "Sort by" in body
    assert "License" in body


@pytest.mark.anyio
async def test_explore_page_has_sort_options(
    client: AsyncClient,
) -> None:
    """Explore page sidebar includes all four sort radio options."""
    response = await client.get("/explore")
    assert response.status_code == 200
    body = response.text
    assert "Most starred" in body
    assert "Recently updated" in body
    assert "Most forked" in body
    assert "Trending" in body


@pytest.mark.anyio
async def test_explore_page_has_license_options(
    client: AsyncClient,
) -> None:
    """Explore page sidebar includes the expected license filter options."""
    response = await client.get("/explore")
    assert response.status_code == 200
    body = response.text
    assert "CC0" in body
    assert "CC BY" in body
    assert "CC BY-SA" in body
    assert "CC BY-NC" in body
    assert "All Rights Reserved" in body


@pytest.mark.anyio
async def test_explore_page_has_repo_grid(
    client: AsyncClient,
) -> None:
    """Explore page includes the repo grid and JS discover API loader."""
    response = await client.get("/explore")
    assert response.status_code == 200
    body = response.text
    assert "repo-grid" in body
    assert "filter-form" in body


@pytest.mark.anyio
async def test_explore_page_has_audio_preview_js(
    client: AsyncClient,
) -> None:
    """Explore page renders the filter sidebar and repo grid (SSR, no inline audio-preview JS)."""
    response = await client.get("/explore")
    assert response.status_code == 200
    body = response.text
    assert "filter-form" in body
    assert "ex-browse" in body
    assert "repo-grid" in body


@pytest.mark.anyio
async def test_explore_page_default_sort_stars(
    client: AsyncClient,
) -> None:
    """Explore page defaults to 'stars' sort when no sort param given."""
    response = await client.get("/explore")
    assert response.status_code == 200
    body = response.text
    # 'stars' radio should be pre-checked (default sort)
    assert 'value="stars"' in body
    assert 'checked' in body


@pytest.mark.anyio
async def test_explore_page_sort_param_honoured(
    client: AsyncClient,
) -> None:
    """Explore page honours the ?sort= query param for pre-selecting a sort option."""
    response = await client.get("/explore?sort=updated")
    assert response.status_code == 200
    body = response.text
    assert 'value="updated"' in body


@pytest.mark.anyio
async def test_explore_page_no_auth_required(
    client: AsyncClient,
) -> None:
    """Explore page is publicly accessible — no JWT required (zero-friction discovery)."""
    response = await client.get("/explore")
    assert response.status_code == 200
    assert response.status_code != 401
    assert response.status_code != 403


@pytest.mark.anyio
async def test_explore_page_chip_toggle_js(
    client: AsyncClient,
) -> None:
    """Explore page dispatches explore.ts module (toggleChip is now in explore.ts)."""
    response = await client.get("/explore")
    assert response.status_code == 200
    body = response.text
    assert '"page": "explore"' in body
    # filter-form is always present; data-filter chips appear when repos with tags exist
    assert "filter-form" in body


@pytest.mark.anyio
async def test_explore_page_get_params_preserved(
    client: AsyncClient,
) -> None:
    """Explore page accepts lang, license, topic, sort GET params without error."""
    response = await client.get(
        "/explore?lang=piano&license=CC0&topic=jazz&sort=stars"
    )
    assert response.status_code == 200