from pathlib import Path

import pytest
from fastapi.testclient import TestClient
from sqlmodel import SQLModel, create_engine


@pytest.fixture
def api_client(tmp_path, monkeypatch):
    db_path = tmp_path / "media_pipeline_test.db"
    monkeypatch.setenv("APPOPS_DB_PATH", str(db_path))
    monkeypatch.setenv("APP_OPS_VOICE_TOKEN", "test-voice-token")

    from backend.app.db import session
    from backend.app.db.init_db import init_db
    from backend.app.main import app

    engine = create_engine(f"sqlite:///{Path(db_path)}", connect_args={"check_same_thread": False})
    session.engine = engine
    SQLModel.metadata.drop_all(engine)
    SQLModel.metadata.create_all(engine)
    init_db()

    with TestClient(app) as client:
        yield client


def _healthy_payloads():
    return {
        "sonarr_health": {"success": True, "status": "connected"},
        "sonarr_wanted": {"success": True, "status": "connected", "total": 3, "items": [{"title": "The Boys"}]},
        "sonarr_queue": {"success": True, "status": "connected", "total": 1, "downloading": 1, "queued": 0, "failed": 0, "stalled": 0, "items": [{"title": "The Boys", "status": "downloading"}]},
        "prowlarr_health": {"success": True, "status": "connected"},
        "prowlarr_indexers": {"success": True, "status": "ok", "total": 4, "enabled": 4, "failing": 0, "items": []},
        "prowlarr_apps": {"success": True, "status": "ok", "total": 2, "items": [{"name": "Sonarr", "status": "healthy"}, {"name": "Radarr", "status": "healthy"}]},
        "prowlarr_sync": {"success": True, "status": "ok", "applicationsConfigured": 2, "indexersConfigured": 4, "indexersEnabled": 4, "indexersFailing": 0, "healthWarnings": 0, "healthErrors": 0},
        "deluge_health": {"success": True, "status": "connected"},
        "deluge_session": {"success": True, "status": "ok", "connected": True, "downloadRate": 1_200_000, "uploadRate": 200_000, "numTorrents": 2, "active": 1, "paused": 1, "stalled": 0, "errors": 0},
        "deluge_active": {"success": True, "status": "ok", "total": 1, "items": [{"id": "active-1", "name": "The Boys", "state": "Downloading", "progress": 55}]},
        "deluge_stalled": {"success": True, "status": "ok", "total": 0, "items": []},
        "deluge_paused": {"success": True, "status": "ok", "total": 1, "items": [{"id": "paused-1", "name": "Paused", "state": "Paused"}]},
        "deluge_speeds": {"success": True, "status": "ok", "downloadRate": 1_200_000, "uploadRate": 200_000, "active": 1, "paused": 1, "stalled": 0, "errors": 0},
        "plex_health": {"success": True, "status": "connected"},
        "plex_libraries": {"success": True, "status": "ok", "total": 2, "libraries": [{"id": "1", "title": "Series", "type": "show", "itemCount": 200}]},
        "plex_sessions": {"success": True, "status": "ok", "total": 1, "sessions": [{"id": "plex-1", "title": "The Boys", "user": "Jens", "videoDecision": "directplay"}]},
        "plex_recent": {"success": True, "status": "ok", "total": 1, "items": [{"title": "The Boys", "library": "Series", "type": "episode"}]},
        "plex_streams": {"success": True, "status": "ok", "total": 1, "directPlay": 1, "directStream": 0, "transcoding": 0, "bandwidth": 4000, "users": 1},
        "tautulli_health": {"success": True, "status": "connected"},
        "tautulli_activity": {"success": True, "status": "ok", "streamCount": 1, "sessions": [{"sessionKey": "t1", "title": "The Boys", "user": "Jens", "ipAddress": "192.168.10.x", "transcodeDecision": "directplay"}]},
        "tautulli_history": {"success": True, "status": "ok", "total": 1, "items": [{"rowId": "h1", "title": "The Boys", "user": "Jens", "duration": 3600}]},
        "tautulli_stats": {"success": True, "status": "ok", "totalPlays": 10, "totalDuration": 36000, "topUsers": [{"name": "Jens", "plays": 10, "duration": 36000}], "topLibraries": [], "topPlatforms": [], "playsByDay": []},
        "tautulli_streams": {"success": True, "status": "ok", "activeStreams": 1, "directPlay": 1, "directStream": 0, "transcoding": 0, "lanStreams": 1, "wanStreams": 0, "bandwidth": 4000},
        "tautulli_libraries": {"success": True, "status": "ok", "total": 1, "items": [{"sectionId": "1", "name": "Series", "type": "show", "count": 200}]},
        "widefrog_health": {"success": True, "status": "connected"},
        "widefrog_queue": {"success": True, "status": "ok", "total": 1, "active": 1, "queued": 0, "completed": 0, "failed": 0, "items": [{"id": "wf-1", "title": "Process media"}]},
        "widefrog_failed": {"success": True, "status": "ok", "failed": 0, "items": []},
        "widefrog_activity": {"success": True, "status": "ok", "recent": [{"message": "Processed media"}], "last_event": {"message": "Processed media"}},
        "widefrog_downloads": {"success": True, "status": "ok", "active": 1, "processing": 1, "items": [{"title": "Import"}]},
    }


def _patch_pipeline(monkeypatch, payloads=None):
    payloads = payloads or _healthy_payloads()

    monkeypatch.setattr("backend.app.connectors.sonarr.SonarrConnector.health", lambda self: payloads["sonarr_health"], raising=False)
    monkeypatch.setattr("backend.app.connectors.sonarr.SonarrConnector.wanted_missing", lambda self: payloads["sonarr_wanted"], raising=False)
    monkeypatch.setattr("backend.app.connectors.sonarr.SonarrConnector.queue_status", lambda self: payloads["sonarr_queue"], raising=False)
    monkeypatch.setattr("backend.app.connectors.prowlarr.ProwlarrConnector.health", lambda self: payloads["prowlarr_health"], raising=False)
    monkeypatch.setattr("backend.app.connectors.prowlarr.ProwlarrConnector.indexer_status", lambda self: payloads["prowlarr_indexers"], raising=False)
    monkeypatch.setattr("backend.app.connectors.prowlarr.ProwlarrConnector.application_status", lambda self: payloads["prowlarr_apps"], raising=False)
    monkeypatch.setattr("backend.app.connectors.prowlarr.ProwlarrConnector.sync_status", lambda self: payloads["prowlarr_sync"], raising=False)
    monkeypatch.setattr("backend.app.connectors.deluge.DelugeConnector.health", lambda self: payloads["deluge_health"], raising=False)
    monkeypatch.setattr("backend.app.connectors.deluge.DelugeConnector.session_status", lambda self: payloads["deluge_session"], raising=False)
    monkeypatch.setattr("backend.app.connectors.deluge.DelugeConnector.active_downloads", lambda self: payloads["deluge_active"], raising=False)
    monkeypatch.setattr("backend.app.connectors.deluge.DelugeConnector.stalled_downloads", lambda self: payloads["deluge_stalled"], raising=False)
    monkeypatch.setattr("backend.app.connectors.deluge.DelugeConnector.paused_downloads", lambda self: payloads["deluge_paused"], raising=False)
    monkeypatch.setattr("backend.app.connectors.deluge.DelugeConnector.speed_status", lambda self: payloads["deluge_speeds"], raising=False)
    monkeypatch.setattr("backend.app.connectors.plex.PlexConnector.health", lambda self: payloads["plex_health"], raising=False)
    monkeypatch.setattr("backend.app.connectors.plex.PlexConnector.library_status", lambda self: payloads["plex_libraries"], raising=False)
    monkeypatch.setattr("backend.app.connectors.plex.PlexConnector.active_sessions", lambda self: payloads["plex_sessions"], raising=False)
    monkeypatch.setattr("backend.app.connectors.plex.PlexConnector.recent_media", lambda self: payloads["plex_recent"], raising=False)
    monkeypatch.setattr("backend.app.connectors.plex.PlexConnector.stream_summary", lambda self: payloads["plex_streams"], raising=False)
    monkeypatch.setattr("backend.app.connectors.tautulli.TautulliConnector.health", lambda self: payloads["tautulli_health"], raising=False)
    monkeypatch.setattr("backend.app.connectors.tautulli.TautulliConnector.activity", lambda self: payloads["tautulli_activity"], raising=False)
    monkeypatch.setattr("backend.app.connectors.tautulli.TautulliConnector.history", lambda self: payloads["tautulli_history"], raising=False)
    monkeypatch.setattr("backend.app.connectors.tautulli.TautulliConnector.watch_stats", lambda self: payloads["tautulli_stats"], raising=False)
    monkeypatch.setattr("backend.app.connectors.tautulli.TautulliConnector.stream_summary", lambda self: payloads["tautulli_streams"], raising=False)
    monkeypatch.setattr("backend.app.connectors.tautulli.TautulliConnector.libraries", lambda self: payloads["tautulli_libraries"], raising=False)
    monkeypatch.setattr("backend.app.connectors.widefrog.WidefrogConnector.health", lambda self: payloads["widefrog_health"], raising=False)
    monkeypatch.setattr("backend.app.connectors.widefrog.WidefrogConnector.queue_status", lambda self: payloads["widefrog_queue"], raising=False)
    monkeypatch.setattr("backend.app.connectors.widefrog.WidefrogConnector.failed_jobs", lambda self: payloads["widefrog_failed"], raising=False)
    monkeypatch.setattr("backend.app.connectors.widefrog.WidefrogConnector.activity", lambda self: payloads["widefrog_activity"], raising=False)
    monkeypatch.setattr("backend.app.connectors.widefrog.WidefrogConnector.download_status", lambda self: payloads["widefrog_downloads"], raising=False)
    return payloads


def test_media_pipeline_summary_healthy(api_client, monkeypatch):
    _patch_pipeline(monkeypatch)

    payload = api_client.get("/api/media-pipeline/summary").json()

    assert payload["success"] is True
    assert payload["status"] == "healthy"
    assert payload["connectors"]["sonarr"]["status"] == "connected"
    assert payload["counts"]["wantedSeries"] == 3
    assert payload["counts"]["activeDownloads"] == 1
    assert payload["counts"]["plexLibraries"] == 2
    assert payload["counts"]["activeStreams"] == 1
    assert payload["counts"]["indexers"] == 4
    assert payload["risk"]["level"] == "low"


def test_media_pipeline_reuses_snapshot_for_burst_reads(api_client, monkeypatch):
    from backend.app.services import media_pipeline_service

    payloads = _patch_pipeline(monkeypatch)
    calls = {"sonarr_health": 0}

    def sonarr_health(_self):
        calls["sonarr_health"] += 1
        return payloads["sonarr_health"]

    monkeypatch.setattr("backend.app.connectors.sonarr.SonarrConnector.health", sonarr_health, raising=False)
    media_pipeline_service._SNAPSHOT_CACHE.clear()

    summary_payload = api_client.get("/api/media-pipeline/summary").json()
    issues_payload = api_client.get("/api/media-pipeline/issues").json()

    assert summary_payload["success"] is True
    assert issues_payload["success"] is True
    assert calls["sonarr_health"] == 1


def test_media_pipeline_summary_reuses_persistent_cache_after_snapshot_loss(api_client, monkeypatch):
    from backend.app.services import media_pipeline_service

    _patch_pipeline(monkeypatch)
    media_pipeline_service._SNAPSHOT_CACHE.clear()

    first = api_client.get("/api/media-pipeline/summary").json()
    media_pipeline_service._SNAPSHOT_CACHE.clear()

    def fail_build_snapshot():
        raise AssertionError("persistent media summary cache should avoid cold connector reads")

    monkeypatch.setattr(media_pipeline_service, "_build_snapshot", fail_build_snapshot)

    second = api_client.get("/api/media-pipeline/summary").json()

    assert second["status"] == first["status"]
    assert second["counts"] == first["counts"]
    assert second["connectors"] == first["connectors"]


def test_media_pipeline_snapshot_cache_prevents_concurrent_stampede(api_client, monkeypatch):
    from concurrent.futures import ThreadPoolExecutor
    from time import sleep

    from backend.app.services import media_pipeline_service

    payloads = _patch_pipeline(monkeypatch)
    calls = {"sonarr_health": 0}

    def sonarr_health(_self):
        calls["sonarr_health"] += 1
        sleep(0.05)
        return payloads["sonarr_health"]

    monkeypatch.setattr("backend.app.connectors.sonarr.SonarrConnector.health", sonarr_health, raising=False)
    media_pipeline_service._SNAPSHOT_CACHE.clear()

    with ThreadPoolExecutor(max_workers=4) as executor:
        results = list(executor.map(lambda _index: media_pipeline_service._snapshot_cached(), range(4)))

    assert all(result["sonarrHealth"]["success"] is True for result in results)
    assert calls["sonarr_health"] == 1


def test_media_pipeline_cold_snapshot_runs_connector_reads_in_parallel(api_client, monkeypatch):
    from threading import Barrier

    from backend.app.services import media_pipeline_service

    payloads = _patch_pipeline(monkeypatch)
    barrier = Barrier(3, timeout=1)

    def wait_and_return(key):
        def _inner(_self):
            barrier.wait()
            return payloads[key]

        return _inner

    monkeypatch.setattr("backend.app.connectors.sonarr.SonarrConnector.health", wait_and_return("sonarr_health"), raising=False)
    monkeypatch.setattr("backend.app.connectors.sonarr.SonarrConnector.wanted_missing", wait_and_return("sonarr_wanted"), raising=False)
    monkeypatch.setattr("backend.app.connectors.sonarr.SonarrConnector.queue_status", wait_and_return("sonarr_queue"), raising=False)
    media_pipeline_service._SNAPSHOT_CACHE.clear()

    payload = api_client.get("/api/media-pipeline/summary").json()

    assert payload["success"] is True
    assert payload["connectors"]["sonarr"]["status"] == "connected"
    assert payload["counts"]["wantedSeries"] == 3


def test_media_pipeline_summary_partial_when_connector_missing_config(api_client, monkeypatch):
    payloads = _healthy_payloads()
    payloads["prowlarr_health"] = {"success": False, "status": "missing_config", "message": "missing_config"}
    payloads["prowlarr_indexers"] = {"success": False, "status": "missing_config", "total": 0, "enabled": 0, "failing": 0, "items": []}
    payloads["prowlarr_sync"] = {"success": False, "status": "missing_config", "applicationsConfigured": 0, "indexersConfigured": 0, "indexersEnabled": 0, "indexersFailing": 0, "healthWarnings": 0, "healthErrors": 0}
    _patch_pipeline(monkeypatch, payloads)

    payload = api_client.get("/api/media-pipeline/summary").json()

    assert payload["success"] is True
    assert payload["status"] in {"partial", "missing_config"}
    assert payload["connectors"]["prowlarr"]["status"] == "missing_config"
    assert "prowlarr" in " ".join(payload["risk"]["reasons"]).lower()


def test_media_pipeline_flow_returns_nodes_and_edges(api_client, monkeypatch):
    _patch_pipeline(monkeypatch)

    payload = api_client.get("/api/media-pipeline/flow").json()

    node_ids = {node["id"] for node in payload["nodes"]}
    assert {"sonarr", "prowlarr", "deluge", "widefrog", "plex", "tautulli"}.issubset(node_ids)
    assert {"from": "sonarr", "to": "prowlarr", "status": "healthy", "label": "indexer sync"} in payload["edges"]
    assert not any(edge["from"] == "deluge" and edge["to"] == "widefrog" for edge in payload["edges"])
    assert {"from": "widefrog", "to": "plex", "status": "healthy", "label": "media processing"} in payload["edges"]
    action_ids = [action["actionId"] for node in payload["nodes"] for action in node.get("actions", [])]
    assert not any("delete" in action or "remove" in action for action in action_ids)


def test_media_pipeline_flow_has_no_healthy_edges_when_configuration_is_missing(api_client, monkeypatch):
    payloads = _healthy_payloads()
    for connector in ("sonarr", "prowlarr", "deluge", "widefrog", "plex", "tautulli"):
        payloads[f"{connector}_health"] = {"success": False, "status": "missing_config"}
    _patch_pipeline(monkeypatch, payloads)

    response = api_client.get("/api/media-pipeline/flow")

    assert response.status_code == 200
    payload = response.json()
    assert len(payload["edges"]) == 4
    assert all(edge["status"] == "unknown" for edge in payload["edges"])
    assert all(node["status"] == "missing_config" for node in payload["nodes"])


@pytest.mark.parametrize("connector", ["sonarr", "prowlarr", "deluge", "widefrog", "plex", "tautulli"])
@pytest.mark.parametrize("health_status,expected", [
    ("missing_config", "unknown"),
    ("unknown", "unknown"),
    ("unavailable", "unknown"),
    ("unsupported", "unknown"),
    ("unexpected_state", "unknown"),
    ("auth_failed", "broken"),
    ("unreachable", "broken"),
    ("error", "broken"),
])
def test_media_pipeline_flow_checks_each_endpoint_before_queue_warnings(api_client, monkeypatch, connector, health_status, expected):
    payloads = _healthy_payloads()
    payloads[f"{connector}_health"] = {"success": False, "status": health_status}
    # Nonzero counts must never turn unavailable or failed endpoints amber/green.
    payloads["prowlarr_indexers"]["failing"] = 2
    payloads["widefrog_failed"]["failed"] = 3
    _patch_pipeline(monkeypatch, payloads)

    response = api_client.get("/api/media-pipeline/flow")

    assert response.status_code == 200
    edges = response.json()["edges"]
    unrelated_statuses = {
        ("sonarr", "prowlarr"): "healthy",
        ("prowlarr", "deluge"): "warning",
        ("widefrog", "plex"): "warning",
        ("plex", "tautulli"): "healthy",
    }
    for edge in edges:
        if connector in (edge["from"], edge["to"]):
            assert edge["status"] == expected
        else:
            assert edge["status"] == unrelated_statuses[(edge["from"], edge["to"])]


def test_media_pipeline_flow_unknown_endpoint_precedes_failure_on_the_other_endpoint(api_client, monkeypatch):
    payloads = _healthy_payloads()
    payloads["prowlarr_health"] = {"success": False, "status": "unreachable"}
    payloads["deluge_health"] = {"success": False, "status": "missing_config"}
    _patch_pipeline(monkeypatch, payloads)

    payload = api_client.get("/api/media-pipeline/flow").json()
    edge_statuses = {(edge["from"], edge["to"]): edge["status"] for edge in payload["edges"]}

    assert edge_statuses[("sonarr", "prowlarr")] == "broken"
    assert edge_statuses[("prowlarr", "deluge")] == "unknown"


def test_media_pipeline_flow_applies_queue_warnings_only_with_connected_endpoints(api_client, monkeypatch):
    payloads = _healthy_payloads()
    payloads["prowlarr_indexers"]["failing"] = 2
    payloads["widefrog_failed"]["failed"] = 3
    _patch_pipeline(monkeypatch, payloads)

    payload = api_client.get("/api/media-pipeline/flow").json()

    assert {(edge["from"], edge["to"]): edge["status"] for edge in payload["edges"]} == {
        ("sonarr", "prowlarr"): "healthy",
        ("prowlarr", "deluge"): "warning",
        ("widefrog", "plex"): "warning",
        ("plex", "tautulli"): "healthy",
    }


def test_media_pipeline_issues_detect_cross_connector_problems(api_client, monkeypatch):
    payloads = _healthy_payloads()
    payloads["prowlarr_indexers"] = {"success": True, "status": "ok", "total": 3, "enabled": 2, "failing": 1, "items": [{"name": "Indexer", "status": "error"}]}
    payloads["deluge_stalled"] = {"success": True, "status": "ok", "total": 1, "items": [{"id": "stalled-1", "name": "The Boys", "state": "Error"}]}
    payloads["widefrog_failed"] = {"success": True, "status": "ok", "failed": 2, "items": [{"id": "wf-fail", "title": "Import failed"}]}
    payloads["tautulli_health"] = {"success": False, "status": "missing_config", "message": "missing_config"}
    _patch_pipeline(monkeypatch, payloads)

    payload = api_client.get("/api/media-pipeline/issues").json()
    titles = " ".join(issue["title"] for issue in payload["issues"]).lower()

    assert "indexer" in titles
    assert "stalled" in titles
    assert "widefrog" in titles
    assert "tautulli" in titles
    actions = [action for issue in payload["issues"] for action in issue["suggestedActions"]]
    assert actions
    assert all(action["policyDecision"] in {"allowed", "approval_required", "blocked"} for action in actions)
    assert all(action.get("link") for action in actions)
    assert not any(any(blocked in action["actionId"] for blocked in ["delete", "remove", "kill_session", "terminate"]) for action in actions)


def test_deluge_stalled_issue_includes_source_and_timestamp(api_client, monkeypatch):
    payloads = _healthy_payloads()
    payloads["deluge_stalled"] = {"success": True, "status": "ok", "total": 1, "items": [{"id": "stalled-1", "name": "The Boys", "state": "Downloading"}]}
    _patch_pipeline(monkeypatch, payloads)

    payload = api_client.get("/api/media-pipeline/issues").json()
    stalled = next(issue for issue in payload["issues"] if issue["id"] == "deluge-stalled")

    assert stalled["source"] == "deluge.stalled_downloads"
    assert stalled["observedAt"]
    assert any(str(item).startswith("source=deluge.stalled_downloads") for item in stalled["evidence"])
    assert any(str(item).startswith("observedAt=") for item in stalled["evidence"])


def test_media_pipeline_issues_handles_review_apps_without_connector_type(api_client, monkeypatch):
    from sqlmodel import Session

    from backend.app.db.models import App
    from backend.app.db.session import engine

    _patch_pipeline(monkeypatch)
    with Session(engine) as session:
        session.add(App(id="media-review-app", name="Media Review App", category="media", needs_review=True))
        session.commit()

    response = api_client.get("/api/media-pipeline/issues")

    assert response.status_code == 200
    payload = response.json()
    review_issue = next(issue for issue in payload["issues"] if issue["id"] == "app-needs-review-media-review-app")
    assert review_issue["affectedConnectors"] == ["media-review-app"]
    assert review_issue["suggestedActions"][0]["target"] == "media-review-app"
    assert review_issue["suggestedActions"][0]["link"] == "/apps/media-review-app"


def test_media_pipeline_downloads_combines_deluge_and_widefrog(api_client, monkeypatch):
    payloads = _healthy_payloads()
    payloads["deluge_stalled"] = {"success": True, "status": "ok", "total": 1, "items": [{"id": "stalled-1", "name": "The Boys", "state": "Error"}]}
    payloads["widefrog_failed"] = {"success": True, "status": "ok", "failed": 1, "items": [{"id": "wf-fail", "title": "Import failed"}]}
    _patch_pipeline(monkeypatch, payloads)

    payload = api_client.get("/api/media-pipeline/downloads").json()

    assert payload["active"]["total"] == 1
    assert payload["stalled"]["total"] == 1
    assert payload["failedWidefrogJobs"]["failed"] == 1
    action_ids = [action["actionId"] for action in payload["suggestedActions"]]
    assert "deluge.resume_torrent" in action_ids
    assert "widefrog.retry_failed" in action_ids
    assert {action["target"]: action["link"] for action in payload["suggestedActions"] if action["target"] in {"deluge", "widefrog"}} == {
        "deluge": "/apps/deluge",
        "widefrog": "/apps/widefrog",
    }
    assert not any("remove" in action or "delete" in action for action in action_ids)


def test_media_pipeline_library_combines_plex_tautulli_widefrog(api_client, monkeypatch):
    _patch_pipeline(monkeypatch)

    payload = api_client.get("/api/media-pipeline/library").json()

    assert payload["plexLibraries"]["total"] == 2
    assert payload["tautulliStats"]["totalPlays"] == 10
    assert payload["widefrogQueue"]["total"] == 1
    action_ids = [action["actionId"] for action in payload["suggestedActions"]]
    assert "plex.scan_library" in action_ids
    assert "plex.scan_all_libraries" in action_ids
    assert "widefrog.scan_library" in action_ids
    assert all(action.get("link") in {"/apps/plex", "/apps/widefrog"} for action in payload["suggestedActions"])
    assert not any("empty_trash" in action or "kill_session" in action for action in action_ids)


def test_media_pipeline_activity_marks_privacy_sensitive_data(api_client, monkeypatch):
    _patch_pipeline(monkeypatch)

    payload = api_client.get("/api/media-pipeline/activity").json()

    assert payload["privacy"]["sensitive"] is True
    assert "tautulli.history" in payload["privacy"]["actions"]
    assert payload["tautulliActivity"]["streamCount"] == 1
    assert payload["plexSessions"]["total"] == 1
    assert "192.168.10.x" in str(payload)


def test_media_pipeline_recommendations_are_generated_from_issues(api_client, monkeypatch):
    payloads = _healthy_payloads()
    payloads["prowlarr_indexers"] = {"success": True, "status": "ok", "total": 3, "enabled": 2, "failing": 1, "items": []}
    payloads["plex_streams"] = {"success": True, "status": "ok", "total": 3, "directPlay": 0, "directStream": 0, "transcoding": 3, "bandwidth": 12000, "users": 3}
    _patch_pipeline(monkeypatch, payloads)

    payload = api_client.get("/api/media-pipeline/recommendations").json()

    assert payload["success"] is True
    assert payload["recommendations"]
    assert all("confidence" in item for item in payload["recommendations"])
    assert any("transcode" in item["title"].lower() or "indexer" in item["title"].lower() for item in payload["recommendations"])


def test_media_pipeline_check_is_read_only_and_audited(api_client, monkeypatch):
    _patch_pipeline(monkeypatch)

    payload = api_client.post("/api/media-pipeline/check").json()

    assert payload["success"] is True
    assert payload["summary"]["status"] == "healthy"
    assert payload["auditId"].startswith("audit-")
    assert payload["jobId"].startswith("job-")


def test_media_pipeline_diagnose_returns_evidence_without_execution(api_client, monkeypatch):
    payloads = _healthy_payloads()
    payloads["sonarr_wanted"] = {"success": True, "status": "connected", "total": 1, "items": [{"title": "The Boys"}]}
    payloads["deluge_active"] = {"success": True, "status": "ok", "total": 0, "items": []}
    payloads["prowlarr_indexers"] = {"success": True, "status": "ok", "total": 3, "enabled": 2, "failing": 1, "items": []}
    _patch_pipeline(monkeypatch, payloads)

    payload = api_client.post("/api/media-pipeline/diagnose", json={"query": "waarom downloadt The Boys niet?", "scope": "downloads"}).json()

    assert payload["success"] is True
    assert payload["diagnosis"]["likelyCauses"]
    assert payload["diagnosis"]["evidence"]
    assert payload["diagnosis"]["executedActions"] == []
    assert not any("delete" in action["actionId"] or "remove" in action["actionId"] for action in payload["diagnosis"]["suggestedActions"])


def test_media_pipeline_diagnose_policy_is_read_only_allowed(api_client):
    payload = api_client.post(
        "/api/policies/evaluate",
        json={"action": "media_pipeline.diagnose", "target": "media-pipeline", "source": "manual"},
    ).json()

    assert payload["decision"] == "allowed"
    assert payload["risk"] == "low"