import base64
from io import BytesIO
from pathlib import Path

from fastapi.testclient import TestClient
from PIL import Image

from app.config.store import ConfigStore
from app.demo_library import DEMO_ANIMATION_ID, DEMO_ANIMATION_NAME
from app.main import create_app, static_content_version
from app.network.manager import MockNetworkManager
from app.power.voltage import VoltageMonitor


def solid_scene(color=(12, 34, 56)):
    return {
        "version": 1,
        "width": 64,
        "height": 64,
        "pixelRgb": base64.b64encode(bytes(color) * (64 * 64)).decode("ascii"),
        "elements": [],
    }


def test_status_config_and_display_api(tmp_path):
    client = TestClient(create_app(project_root=tmp_path, driver_kind="mock"))

    status = client.get("/api/status")
    assert status.status_code == 200
    assert status.json()["screen"]["driver"] == "mock"
    assert status.json()["screen"]["driver_options"]["rows"] == 64
    assert status.json()["screen"]["driver_options"]["scan_rows"] == 32
    assert status.json()["screen"]["driver_options"]["row_address_bits"] == 5
    assert status.json()["screen"]["driver_options"]["pwm_bits"] == 7
    assert status.json()["screen"]["hardware_mapping"] == "walnutpi-pi-bank-pwm-oe-v2"
    assert status.json()["screen"]["driver_options"]["limit_refresh_rate_hz"] == 100
    assert status.json()["screen"]["driver_status"]["actual_refresh_rate_hz"] is None
    assert status.json()["screen"]["driver_status"]["panel_scan_rate_hz"] is None
    assert status.json()["screen"]["driver_status"]["completed_scans"] is None
    assert status.json()["screen"]["driver_status"]["scans_per_frame"] is None
    assert status.json()["power"]["screen_input_voltage"]["status"] == "starting"
    assert status.json()["state"]["animation_playback"] == {
        "active": False,
        "session_id": None,
        "animation_id": None,
        "animation_revision": None,
        "frame_id": None,
        "frame_index": None,
        "frame_count": None,
        "position_ms": None,
        "total_duration_ms": None,
        "paused": None,
        "speed": None,
        "supported_speeds": [0.5, 1.0, 1.5, 2.0],
    }
    assert status.json()["power"]["low_voltage_protection"] == {
        "enabled": False,
        "mode": "disabled",
        "brightness_limit_percent": None,
        "reading_stale": False,
        "revision": 0,
        "sampling_interval_seconds": 5.0,
        "enforcement_error_code": None,
    }
    assert status.json()["resources"] == {
        "status": "starting",
        "sampled_at": None,
        "cpu": {
            "application_percent": None,
            "total_percent": None,
            "logical_cpu_count": None,
            "application_core_equivalent": None,
            "cores_percent": [],
        },
        "memory": {
            "application_bytes": None,
            "application_percent": None,
            "total_percent": None,
        },
        "error_code": None,
    }
    assert status.json()["ui"]["preview_refresh_interval_ms"] == 1000
    assert status.json()["system"]["performance_mode"] == {
        "requested": False,
        "available": False,
        "effective": False,
        "current_governors": {},
        "restore_governors": {},
        "last_error": "当前内核未提供 CPU 调频策略；请检查候选内核是否回退",
    }
    assert status.json()["state"]["display_test"] == {
        "active": False,
        "color": None,
        "brightness": None,
    }

    config = client.put(
        "/api/config",
        json={
            "orientation": 180,
            "brightness": 30,
            "preview_refresh_interval_ms": 99,
            "matrix_refresh_rate_limit_hz": 80,
            "custom_test_color": "#a1b2c3",
            "workspace_order": ["templates", "device", "settings", "canvas", "text", "animations"],
            "animation_preview_max_concurrent": 50,
        },
    )
    assert config.status_code == 200
    assert config.json()["orientation"] == 180
    assert config.json()["preview_refresh_interval_ms"] == 99
    assert config.json()["matrix_refresh_rate_limit_hz"] == 80
    assert config.json()["custom_test_color"] == "#A1B2C3"
    assert config.json()["workspace_order"] == [
        "templates", "device", "settings", "canvas", "text", "animations",
    ]
    assert client.get("/api/config").json()["preview_refresh_interval_ms"] == 99
    assert client.get("/api/config").json()["low_voltage_protection_enabled"] is False
    assert client.get("/api/status").json()["ui"]["preview_refresh_interval_ms"] == 99
    assert client.get("/api/status").json()["screen"]["driver_options"][
        "limit_refresh_rate_hz"
    ] == 80
    assert "schema_version" not in config.json()
    assert config.json()["performance_mode_enabled"] is False
    assert config.json()["animation_preview_max_concurrent"] == 50

    homepage = client.get("/")
    assert 'id="topbar-cpu"' in homepage.text
    assert 'id="topbar-memory"' in homepage.text
    assert 'id="topbar-low-voltage-warning"' in homepage.text
    assert 'id="low-voltage-protection-enabled"' in homepage.text
    assert 'id="brightness-protection-status"' in homepage.text
    assert 'id="resource-details-dialog"' in homepage.text
    assert 'id="matrix-refresh-rate-grid"' in homepage.text
    assert homepage.text.count("data-matrix-refresh-rate=") == 7
    assert 'aria-controls="resource-details-dialog"' in homepage.text
    assert "资源占用详情" in homepage.text
    assert (
        homepage.text.index('id="topbar-cpu"')
        < homepage.text.index('id="topbar-memory"')
        < homepage.text.index('id="topbar-low-voltage-warning"')
        < homepage.text.index('id="topbar-voltage"')
    )

    for value in (0, 60001):
        assert client.put(
            "/api/config",
            json={"preview_refresh_interval_ms": value},
        ).status_code == 400
    for value in (True, 1.5, "100"):
        assert client.put(
            "/api/config",
            json={"preview_refresh_interval_ms": value},
        ).status_code == 422

    for value in (1, 2, 50):
        response = client.put(
            "/api/config",
            json={"animation_preview_max_concurrent": value},
        )
        assert response.status_code == 200
        assert response.json()["animation_preview_max_concurrent"] == value
    for value in (0, 51):
        assert client.put(
            "/api/config",
            json={"animation_preview_max_concurrent": value},
        ).status_code == 400
    for value in (None, True, 2.0, "2", [], {}):
        assert client.put(
            "/api/config",
            json={"animation_preview_max_concurrent": value},
        ).status_code == 422

    for value in (None, 0, 1, "true", [], {}):
        assert client.put(
            "/api/config",
            json={"low_voltage_protection_enabled": value},
        ).status_code == 422
    assert client.get("/api/config").json()["low_voltage_protection_enabled"] is False

    for value in (15, 20, 30, 45, 60, 80, 100):
        response = client.put(
            "/api/config",
            json={"matrix_refresh_rate_limit_hz": value},
        )
        assert response.status_code == 200
        assert response.json()["matrix_refresh_rate_limit_hz"] == value
        assert client.get("/api/status").json()["screen"]["driver_options"][
            "limit_refresh_rate_hz"
        ] == value
    for value in (0, 14, 16, 101):
        assert client.put(
            "/api/config",
            json={"matrix_refresh_rate_limit_hz": value},
        ).status_code == 400
    for value in (True, 60.0, "60", [], {}):
        assert client.put(
            "/api/config",
            json={"matrix_refresh_rate_limit_hz": value},
        ).status_code == 422

    for value in (None, True, 123, "red", "#12345"):
        response = client.put("/api/config", json={"custom_test_color": value})
        assert response.status_code in {400, 422}

    saved_workspace_order = client.get("/api/config").json()["workspace_order"]
    for value in (None, [], ["device", "device"], ["bad id"], [1, "device"], "device"):
        response = client.put("/api/config", json={"workspace_order": value})
        assert response.status_code in {400, 422}
        assert client.get("/api/config").json()["workspace_order"] == saved_workspace_order

    legacy_config = client.put("/api/config", json={"default_font": "default", "default_text_size": 14})
    assert legacy_config.status_code == 200
    assert legacy_config.json()["default_text_size"] == 14

    fill = client.post("/api/display/fill", json={"color": "#00FF00"})
    assert fill.status_code == 200
    assert fill.json() == {"ok": True, "mode": "fill"}

    text = client.post("/api/display/text", json={"text": "OK", "size": 12, "x": 4, "y": 24})
    assert text.status_code == 200
    assert text.json()["mode"] == "text"

    diagnostic = client.post("/api/display/diagnostic", json={"mode": "corners_lines"})
    assert diagnostic.status_code == 200
    assert diagnostic.json() == {"ok": True, "mode": "diagnostic:corners_lines"}


def test_display_test_api_is_temporary_persistent_across_reads_and_restorable(tmp_path):
    app = create_app(project_root=tmp_path, driver_kind="mock")
    client = TestClient(app)
    assert client.put("/api/config", json={"brightness": 31}).status_code == 200
    assert client.post("/api/display/fill", json={"color": "#010203"}).status_code == 200

    started = client.post("/api/display/test/fill", json={"color": "#FF0000"})
    assert started.status_code == 200
    assert started.json()["display_test"] == {
        "active": True,
        "color": "#FF0000",
        "brightness": 50,
    }
    assert started.json()["effective_brightness"] == 50
    assert client.get("/api/config").json()["brightness"] == 31
    assert client.get("/api/status").json()["state"]["display_test"]["active"] is True

    changed = client.put("/api/display/test/brightness", json={"brightness": 72})
    assert changed.status_code == 200
    assert changed.json()["display_test"]["brightness"] == 72
    switched = client.post("/api/display/test/fill", json={"color": "#0000FF"})
    assert switched.json()["display_test"]["brightness"] == 72

    exited = client.delete("/api/display/test")
    assert exited.status_code == 200
    assert exited.json()["display_test"]["active"] is False
    assert client.delete("/api/display/test").status_code == 200
    final = client.get("/api/status").json()["state"]
    assert final["mode"] == "fill"
    assert final["brightness"] == 31
    assert final["effective_brightness"] == 31
    restored = Image.open(BytesIO(client.get("/api/display/current-frame").content))
    assert restored.getpixel((0, 0)) == (1, 2, 3)

    assert client.put("/api/display/test/brightness", json={"brightness": 50}).status_code == 409
    assert client.put("/api/display/test/brightness", json={"brightness": True}).status_code == 422
    assert client.post("/api/display/test/fill", json={"color": "bad"}).status_code == 400


def test_device_storage_api_and_successful_persistent_write_invalidate_cache(tmp_path):
    class FakeStorageMonitor:
        def __init__(self):
            self.invalidations = 0

        def get_status(self):
            return {
                "sampled_at": "2026-07-29T00:00:00Z",
                "device_total_bytes": 1000,
                "device_free_bytes": 700,
                "software_bytes": 200,
                "templates_bytes": 50,
            }

        def invalidate(self):
            self.invalidations += 1

    fake = FakeStorageMonitor()
    app = create_app(
        project_root=tmp_path,
        driver_kind="mock",
        storage_monitor_factory=lambda _program, _data: fake,
    )
    client = TestClient(app)

    response = client.get("/api/device-storage")
    assert response.status_code == 200
    assert response.json()["software_bytes"] == 200
    assert response.headers["cache-control"] == "no-store"
    assert fake.invalidations == 0

    assert client.put("/api/config", json={"custom_test_color": "#112233"}).status_code == 200
    assert fake.invalidations == 1
    assert client.post("/api/display/test/fill", json={"color": "#112233"}).status_code == 200
    assert client.put("/api/display/test/brightness", json={"brightness": 45}).status_code == 200
    assert fake.invalidations == 1


def test_current_display_frame_api_is_logical_and_side_effect_free(tmp_path):
    app = create_app(project_root=tmp_path, driver_kind="mock")
    client = TestClient(app)
    frame = bytearray([0, 0, 0] * (64 * 64))
    frame[(7 * 64 + 2) * 3:(7 * 64 + 2) * 3 + 3] = bytes((12, 34, 56))
    app.state.display_service.show_rgb_bytes(bytes(frame), mode="composition")
    app.state.display_service.set_orientation(270)
    before = client.get("/api/status").json()["state"]

    response = client.get("/api/display/current-frame")
    image = Image.open(BytesIO(response.content))

    assert response.status_code == 200
    assert response.headers["content-type"] == "image/png"
    assert response.headers["cache-control"] == "no-store"
    assert image.mode == "RGB"
    assert image.size == (64, 64)
    assert image.getpixel((2, 7)) == (12, 34, 56)
    assert client.get("/api/status").json()["state"] == before


def test_animation_playback_api_controls_frame_and_rejects_invalid_or_stale_sessions(tmp_path):
    app = create_app(project_root=tmp_path, driver_kind="mock")
    with TestClient(app) as client:
        animation = client.post("/api/animations", json={"name": "播放控制"}).json()
        first = client.post(
            f"/api/animations/{animation['id']}/frames",
            headers={"If-Match": f'"{animation["revision"]}"'},
            json={"scene": solid_scene((255, 0, 0)), "duration_ms": 200},
        ).json()
        second = client.post(
            f"/api/animations/{animation['id']}/frames",
            headers={"If-Match": f'"{first["revision"]}"'},
            json={"scene": solid_scene((0, 255, 0)), "duration_ms": 300},
        ).json()
        played = client.post(
            f"/api/animations/{animation['id']}/play",
            headers={"If-Match": f'"{second["revision"]}"'},
        )
        assert played.status_code == 200
        playback = client.get("/api/status").json()["state"]["animation_playback"]
        session_id = playback["session_id"]
        assert playback["frame_count"] == 2
        assert playback["total_duration_ms"] == 500

        controlled = client.patch(
            "/api/display/animation-playback",
            json={
                "session_id": session_id,
                "position_ms": 250,
                "paused": True,
                "speed": 1.5,
            },
        )
        assert controlled.status_code == 200
        assert controlled.json()["state_revision"] >= 1
        result = controlled.json()["animation_playback"]
        assert result["position_ms"] == 250
        assert result["frame_index"] == 2
        assert result["paused"] is True
        assert result["speed"] == 1.5
        frame = Image.open(BytesIO(client.get("/api/display/current-frame").content))
        assert frame.getpixel((0, 0)) == (0, 255, 0)

        invalid_payloads = [
            {"session_id": session_id},
            {"session_id": session_id, "position_ms": 500},
            {"session_id": session_id, "position_ms": True},
            {"session_id": session_id, "paused": 1},
            {"session_id": session_id, "speed": 1.25},
            {"session_id": session_id, "speed": "2"},
            {"session_id": session_id, "paused": None},
            {"session_id": session_id, "paused": True, "unknown": 1},
        ]
        for payload in invalid_payloads:
            assert client.patch("/api/display/animation-playback", json=payload).status_code == 422

        replayed = client.post(
            f"/api/animations/{animation['id']}/play",
            headers={"If-Match": f'"{second["revision"]}"'},
        )
        assert replayed.status_code == 200
        reset = client.get("/api/status").json()["state"]["animation_playback"]
        assert reset["session_id"] != session_id
        assert reset["position_ms"] < 100
        assert reset["paused"] is False
        assert reset["speed"] == 1.0
        stale = client.patch(
            "/api/display/animation-playback",
            json={"session_id": session_id, "paused": True},
        )
        assert stale.status_code == 409


def test_create_app_explicit_project_root_ignores_storage_environment(
    tmp_path,
    monkeypatch,
):
    environment_data = tmp_path / "environment-data"
    environment_runtime = tmp_path / "environment-runtime"
    monkeypatch.setenv("MATRIX_DATA_DIR", str(environment_data))
    monkeypatch.setenv("STATE_DIRECTORY", str(tmp_path / "state-data"))
    monkeypatch.setenv("MATRIX_RUNTIME_DIR", str(environment_runtime))
    monkeypatch.setenv("RUNTIME_DIRECTORY", str(tmp_path / "systemd-runtime"))
    explicit = tmp_path / "explicit"

    app = create_app(project_root=explicit, driver_kind="mock")

    assert app.state.config_store.data_dir == explicit / "data"
    assert app.state.config_store.runtime_dir == explicit / "data" / "runtime"
    assert not environment_data.exists()
    assert not environment_runtime.exists()


def test_consecutive_brightness_updates_keep_config_status_and_driver_in_sync(tmp_path):
    app = create_app(project_root=tmp_path, driver_kind="mock")
    client = TestClient(app)

    for value in (20, 55, 37):
        response = client.put("/api/config", json={"brightness": value})
        assert response.status_code == 200
        assert response.json()["brightness"] == value

    status = client.get("/api/status")
    assert status.status_code == 200
    assert status.json()["state"]["brightness"] == 37
    assert status.json()["screen"]["driver_options"]["brightness"] == 37
    assert app.state.config_store.config["brightness"] == 37


def test_voltage_status_calibration_and_reset_do_not_change_display_state(tmp_path):
    class Device:
        def __enter__(self):
            return self

        def __exit__(self, exc_type, exc, traceback):
            return None

        def configure(self):
            return None

        def read_fresh(self):
            return 13115, 0x0C

    app = create_app(
        project_root=tmp_path,
        driver_kind="mock",
        voltage_monitor_factory=lambda store: VoltageMonitor(store, device_factory=Device),
    )
    client = TestClient(app)
    app.state.voltage_monitor.sample_now()
    state_before = client.get("/api/status").json()["state"]

    invalid = client.post(
        "/api/power/voltage/calibration/preview",
        json={"reference_volts": 4.0},
    )
    assert invalid.status_code == 400

    preview = client.post(
        "/api/power/voltage/calibration/preview",
        json={"reference_volts": 5.0},
    )
    assert preview.status_code == 200
    proposal = preview.json()
    assert proposal["uncalibrated_volts"] > 4.9
    assert client.get("/api/config").json()["voltage_calibrated_at"] is None

    confirmed = client.post(
        "/api/power/voltage/calibration/confirm",
        json={"proposal_id": proposal["proposal_id"]},
    )
    assert confirmed.status_code == 200
    assert confirmed.json()["screen_input_voltage"]["calibrated"] is True
    assert confirmed.json()["config"]["voltage_calibrated_at"].endswith("Z")
    assert client.post(
        "/api/power/voltage/calibration/confirm",
        json={"proposal_id": proposal["proposal_id"]},
    ).status_code == 409

    reset = client.post("/api/power/voltage/calibration/reset", json={})
    assert reset.status_code == 200
    assert reset.json()["config"]["voltage_calibration_factor"] == 1.0
    assert reset.json()["config"]["voltage_calibrated_at"] is None
    assert client.get("/api/status").json()["state"] == state_before


def test_low_voltage_protection_api_overlays_without_changing_user_state(tmp_path):
    class MutableDevice:
        raw = 11777  # Approximately 4.49V with the Unit ADC divider.

        def __enter__(self):
            return self

        def __exit__(self, exc_type, exc, traceback):
            return None

        def configure(self):
            return None

        def read_fresh(self):
            return self.raw, 0x0C

    device = MutableDevice()
    app = create_app(
        project_root=tmp_path,
        driver_kind="mock",
        voltage_monitor_factory=lambda store: VoltageMonitor(
            store,
            device_factory=lambda: device,
        ),
    )
    client = TestClient(app)

    enabled = client.put(
        "/api/config",
        json={"low_voltage_protection_enabled": True},
    )
    assert enabled.status_code == 200
    assert enabled.json()["low_voltage_protection_enabled"] is True

    critical = client.get("/api/status").json()
    assert critical["power"]["low_voltage_protection"]["mode"] == "critical"
    assert critical["power"]["low_voltage_protection"]["brightness_limit_percent"] == 35
    assert critical["power"]["low_voltage_protection"]["sampling_interval_seconds"] == 0.5
    assert critical["state"]["mode"] == "low_voltage_indicator"
    assert critical["state"]["brightness"] == 40
    assert critical["state"]["effective_brightness"] == 35
    assert critical["state"]["revision"] == 0

    indicator = Image.open(BytesIO(client.get("/api/display/current-frame").content))
    assert {color for _count, color in indicator.getcolors(maxcolors=4096)} == {
        (0, 0, 0),
        (255, 0, 0),
    }

    assert client.post("/api/display/fill", json={"color": "#00FF00"}).status_code == 200
    assert client.put(
        "/api/config",
        json={"orientation": 90, "brightness": 77},
    ).status_code == 200
    while_critical = client.get("/api/status").json()
    assert while_critical["state"]["mode"] == "low_voltage_indicator"
    assert while_critical["state"]["brightness"] == 77
    assert while_critical["state"]["effective_brightness"] == 35
    assert app.state.config_store.config["last_mode"] == "fill"
    user_revision = while_critical["state"]["revision"]
    protection_revision = while_critical["power"]["low_voltage_protection"]["revision"]

    device.raw = 12853  # Approximately 4.90V.
    app.state.voltage_monitor.sample_now()
    first_recovery = client.get("/api/status").json()
    assert first_recovery["power"]["low_voltage_protection"]["mode"] == "critical"
    app.state.voltage_monitor.sample_now()

    recovered = client.get("/api/status").json()
    assert recovered["power"]["low_voltage_protection"]["mode"] == "inactive"
    assert recovered["power"]["low_voltage_protection"]["revision"] > protection_revision
    assert recovered["state"]["revision"] == user_revision
    assert recovered["state"]["mode"] == "fill"
    assert recovered["state"]["brightness"] == 77
    assert recovered["state"]["effective_brightness"] == 77
    restored = Image.open(BytesIO(client.get("/api/display/current-frame").content))
    assert {color for _count, color in restored.getcolors(maxcolors=4096)} == {
        (0, 255, 0),
    }


def test_startup_sample_applies_critical_overlay_before_smile(tmp_path):
    class CriticalDevice:
        def __enter__(self):
            return self

        def __exit__(self, exc_type, exc, traceback):
            return None

        def configure(self):
            return None

        def read_fresh(self):
            return 11777, 0x0C

    ConfigStore(project_root=tmp_path).update({
        "low_voltage_protection_enabled": True,
        "last_mode": "fill",
    })
    app = create_app(
        project_root=tmp_path,
        driver_kind="mock",
        startup_boot_id="low-voltage-startup",
        voltage_monitor_factory=lambda store: VoltageMonitor(
            store,
            device_factory=CriticalDevice,
        ),
    )

    with TestClient(app) as client:
        status = client.get("/api/status").json()
        assert status["power"]["low_voltage_protection"]["mode"] == "critical"
        assert status["state"]["mode"] == "low_voltage_indicator"
        assert status["state"]["effective_brightness"] == 35
        assert status["state"]["startup_indicator_active"] is False
        assert status["state"]["animation_active"] is True
        assert status["state"]["current_content"] == {
            "category": "system",
            "id": None,
            "name": "低电压提示",
        }
        assert app.state.config_store.config["last_mode"] == "fill"


def test_bad_color_returns_400(tmp_path):
    client = TestClient(create_app(project_root=tmp_path, driver_kind="mock"))

    response = client.post("/api/display/fill", json={"color": "green"})

    assert response.status_code == 400


def test_shared_color_palette_api(tmp_path):
    app = create_app(project_root=tmp_path, driver_kind="mock")
    app.state.config_store.update({"color_palette": []})
    client = TestClient(app)

    added = client.post("/api/colors/palette", json={"color": "#aabbcc"})
    assert added.status_code == 200
    assert added.json() == {"colors": ["#AABBCC"], "limit": 24}

    duplicate = client.post("/api/colors/palette", json={"color": "#AABBCC"})
    assert duplicate.status_code == 200
    assert duplicate.json()["colors"] == ["#AABBCC"]

    invalid = client.post("/api/colors/palette", json={"color": "blue"})
    assert invalid.status_code == 400

    deleted = client.delete("/api/colors/palette/AABBCC")
    assert deleted.status_code == 200
    assert deleted.json()["colors"] == []
    assert client.delete("/api/colors/palette/AABBCC").status_code == 200


def test_shared_color_palette_limit(tmp_path):
    app = create_app(project_root=tmp_path, driver_kind="mock")
    app.state.config_store.update({"color_palette": []})
    client = TestClient(app)

    for index in range(24):
        response = client.post("/api/colors/palette", json={"color": f"#{index:06X}"})
        assert response.status_code == 200

    overflow = client.post("/api/colors/palette", json={"color": "#FFFFFF"})
    assert overflow.status_code == 409


def test_canvas_websocket(tmp_path):
    app = create_app(project_root=tmp_path, driver_kind="mock")
    client = TestClient(app)
    legacy_frame = bytes([0, 0, 0]) * (64 * 64)
    composition_frame = bytes([18, 52, 86]) * (64 * 64)

    with client.websocket_connect("/ws/canvas") as websocket:
        websocket.send_json({
            "type": "frame_rgb",
            "width": 64,
            "height": 64,
            "encoding": "base64_rgb888",
            "data": base64.b64encode(legacy_frame).decode("ascii"),
        })
        assert websocket.receive_json() == {"type": "ack", "mode": "canvas", "applied": True}
        assert app.state.config_store.config["last_mode"] == "canvas"

        websocket.send_json({
            "type": "frame_rgb",
            "source": "composition",
            "width": 64,
            "height": 64,
            "encoding": "base64_rgb888",
            "data": base64.b64encode(composition_frame).decode("ascii"),
        })
        assert websocket.receive_json() == {"type": "ack", "mode": "composition", "applied": True}
        assert app.state.config_store.config["last_mode"] == "composition"
        frame_path = tmp_path / "data" / "runtime" / "last_frame.png"
        frame_before_error = frame_path.read_bytes()

        websocket.send_json({
            "type": "frame_rgb",
            "source": "canvas",
            "width": 64,
            "height": 64,
            "encoding": "base64_rgb888",
            "data": base64.b64encode(legacy_frame).decode("ascii"),
        })
        error = websocket.receive_json()
        assert error["type"] == "error"
        assert "source" in error["message"]
        assert app.state.config_store.config["last_mode"] == "composition"
        assert frame_path.read_bytes() == frame_before_error

        websocket.send_json({"type": "frame_rgb", "width": 1, "height": 1, "encoding": "base64_rgb888", "data": ""})
        assert websocket.receive_json()["type"] == "error"


def test_preview_endpoints_return_png_without_display_side_effects(tmp_path):
    client = TestClient(create_app(project_root=tmp_path, driver_kind="mock"))
    fill = client.post("/api/display/fill", json={"color": "#123456"})
    assert fill.status_code == 200
    frame_path = tmp_path / "data" / "runtime" / "last_frame.png"
    frame_before = frame_path.read_bytes()
    status_before = client.get("/api/status").json()["state"]

    text_preview = client.post("/api/preview/text", json={
        "text": "UP",
        "size": 12,
        "x": 4,
        "y": 24,
        "color": "#FFFFFF",
        "background": "#000000",
    })
    assert text_preview.status_code == 200
    assert text_preview.headers["content-type"] == "image/png"
    text_image = Image.open(BytesIO(text_preview.content))
    assert text_image.size == (64, 64)
    assert text_image.mode == "RGB"

    text_layer_preview = client.post("/api/preview/text-layer", json={
        "text": "TOP",
        "size": 12,
        "x": 4,
        "y": 24,
        "color": "#FF8000",
    })
    assert text_layer_preview.status_code == 200
    assert text_layer_preview.headers["content-type"] == "image/png"
    text_layer_image = Image.open(BytesIO(text_layer_preview.content))
    assert text_layer_image.size == (64, 64)
    assert text_layer_image.mode == "RGBA"
    assert text_layer_image.getpixel((63, 63)) == (0, 0, 0, 0)
    assert text_layer_image.getchannel("A").getbbox() is not None

    diagnostic_preview = client.post("/api/preview/diagnostic", json={"mode": "corners_lines"})
    assert diagnostic_preview.status_code == 200
    diagnostic_image = Image.open(BytesIO(diagnostic_preview.content))
    assert diagnostic_image.size == (64, 64)
    assert diagnostic_image.getpixel((0, 0)) == (255, 0, 0)

    assert client.get("/api/status").json()["state"] == status_before
    assert frame_path.read_bytes() == frame_before


def test_multilingual_text_preview_uses_covered_fonts_and_rejects_emoji(tmp_path):
    client = TestClient(create_app(project_root=tmp_path, driver_kind="mock"))
    samples = ("你好", "日本", "한글", "Привет", "Ελλάδα", "مرحبا", "שלום", "สวัสดี")

    for sample in samples:
        response = client.post("/api/preview/text-layer", json={
            "text": sample,
            "font": "default",
            "size": 18,
            "x": 0,
            "y": 16,
            "color": "#FFFFFF",
        })
        assert response.status_code == 200, (sample, response.text)
        image = Image.open(BytesIO(response.content))
        assert image.mode == "RGBA"
        assert image.getchannel("A").getbbox() is not None

    unsupported = client.post("/api/preview/text-layer", json={
        "text": "😀",
        "font": "default",
        "size": 18,
        "x": 0,
        "y": 16,
        "color": "#FFFFFF",
    })
    assert unsupported.status_code == 400
    assert "U+1F600" in unsupported.json()["detail"]


def test_composition_can_be_reapplied_after_diagnostic_override(tmp_path):
    app = create_app(project_root=tmp_path, driver_kind="mock")
    client = TestClient(app)
    composition_frame = bytearray([0, 0, 0] * (64 * 64))
    composition_frame[0:3] = bytes((12, 34, 56))
    composition_frame[-3:] = bytes((78, 90, 123))
    encoded_frame = base64.b64encode(composition_frame).decode("ascii")

    with client.websocket_connect("/ws/canvas") as websocket:
        websocket.send_json({
            "type": "frame_rgb",
            "source": "composition",
            "width": 64,
            "height": 64,
            "encoding": "base64_rgb888",
            "data": encoded_frame,
        })
        assert websocket.receive_json()["mode"] == "composition"

    diagnostic = client.post("/api/display/diagnostic", json={"mode": "corners_lines"})
    assert diagnostic.status_code == 200
    assert app.state.config_store.config["last_mode"] == "diagnostic:corners_lines"
    diagnostic_image = Image.open(tmp_path / "data" / "runtime" / "last_frame.png")
    assert diagnostic_image.getpixel((0, 0)) == (255, 0, 0)

    with client.websocket_connect("/ws/canvas") as websocket:
        websocket.send_json({
            "type": "frame_rgb",
            "source": "composition",
            "width": 64,
            "height": 64,
            "encoding": "base64_rgb888",
            "data": encoded_frame,
        })
        assert websocket.receive_json() == {
            "type": "ack",
            "mode": "composition",
            "applied": True,
        }

    restored = Image.open(tmp_path / "data" / "runtime" / "last_frame.png")
    assert restored.tobytes() == bytes(composition_frame)
    assert app.state.config_store.config["last_mode"] == "composition"


def test_mobile_workspace_assets_are_served(tmp_path):
    app = create_app(project_root=tmp_path, driver_kind="mock")
    client = TestClient(app)

    index = client.get("/")
    assert index.status_code == 200
    assert index.headers["cache-control"] == "no-store"
    assert f'<meta name="app-version" content="{app.state.app_version}">' in index.text
    assert f'/static/{app.state.app_version}/style.css' in index.text
    assert f'/static/{app.state.app_version}/app.js' in index.text
    assert 'id="workspace-drawer"' in index.text
    assert 'id="workspace-order-toggle"' in index.text
    assert "自定义项目位置" in index.text
    assert 'id="workspace-settings"' in index.text
    assert 'id="topbar-voltage"' in index.text
    assert 'id="start-voltage-calibration"' in index.text
    assert 'id="voltage-calibration-dialog"' in index.text
    assert 'id="board-stage"' in index.text
    assert 'id="scene-canvas"' in index.text
    assert 'id="pixel-grid"' in index.text
    assert 'id="pixel-edit-toggle"' in index.text
    assert 'id="pixel-edit-status"' in index.text
    assert 'id="text-element-list"' in index.text
    assert 'id="create-text"' in index.text
    assert 'id="workspace-templates"' in index.text
    assert 'id="workspace-animations"' in index.text
    assert 'id="animation-frames"' in index.text
    assert 'id="animation-edit-notice"' in index.text
    assert 'id="animation-preview-image"' in index.text
    assert 'id="animation-board-preview"' in index.text
    assert 'id="animation-dirty-message"' in index.text
    assert 'id="library-copy-dialog"' in index.text
    assert 'id="template-grid"' in index.text
    assert 'id="save-template"' in index.text
    assert 'id="template-dialog-note"' in index.text
    assert 'id="animation-apply-all"' not in index.text
    assert 'id="template-confirm-dialog"' in index.text
    assert 'id="config-font"' not in index.text
    assert 'id="text-font"' in index.text
    assert 'role="combobox"' in index.text
    assert 'id="import-font"' in index.text
    assert 'accept=".ttf,.otf,.ttc,.otc"' in index.text
    assert "选择设备已有字体，或导入 TTF、OTF、TTC、OTC 文件" in index.text
    assert 'id="text-background"' not in index.text
    assert 'type="color"' not in index.text
    assert index.text.count("data-color-picker") == 4
    settings = index.text[index.text.index('id="workspace-settings"'):]
    assert settings.index("<h3>屏幕亮度</h3>") < settings.index("<h3>屏幕方向</h3>") < settings.index("<h3>供电电压</h3>") < settings.index("<h3>预览刷新间隔</h3>")
    assert 'id="preview-refresh-interval"' in settings
    assert "刷新间隔过短，会增加核桃派负载，可能影响系统运行。" in settings
    assert "角度仅作为4个方向的标识符，和现实方向无关，设置到实际方向正确之后自动储存在系统内。" in settings
    assert "设备的输入电压应该为5V，稍微低一点是正常的。但如果严重偏低请充电。" in settings
    assert '<h3>性能模式</h3>' in settings
    assert "如果使用出现卡顿，可以打开此选项，但会降低续航。" in settings
    assert settings.index('<h3>性能模式</h3>') < settings.index("<h3>模板界面同时播放的动图数量</h3>")
    assert 'id="animation-preview-max-concurrent"' in settings
    assert 'min="1"' in settings[settings.index('id="animation-preview-max-concurrent"'):]
    assert 'max="50"' in settings[settings.index('id="animation-preview-max-concurrent"'):]
    assert "不建议开启太多，否则会出现严重的性能问题。" in settings
    assert '<h3>frp配置</h3>' in settings
    assert "此功能通常是远程排查使用，请保证你知道你在做什么。" in settings
    assert settings.index('<h3>frp配置</h3>') > settings.index('id="animation-preview-max-concurrent"')
    assert "方向和亮度立即应用并保存；电压传感器按设备独立校准。" not in settings
    assert "更换 ADC 模块、测量线或测量点后，请恢复标称值并重新校准。" not in settings
    assert "方向和亮度会自动保存" not in settings
    legacy = client.get("/static/core.js")
    assert legacy.status_code == 200
    assert legacy.headers["cache-control"] == "no-store"
    assert client.get("/static/scene-model.js").status_code == 200
    scene_board = client.get("/static/scene-board.js")
    assert scene_board.status_code == 200
    assert 'new Set(["device", "settings", "templates"])' in scene_board.text
    assert client.get("/static/template-edit-model.js").status_code == 200
    assert (
        'renderUiCopy("copy.dynamic.board.monitor_mode", boardMode, '
        '"预览当前显示屏幕画面", {}, { defaultHidden: true })'
        in scene_board.text
    )
    assert 'renderUiValue(boardMode, "")' in scene_board.text
    assert "当前设备逻辑画面 · 只读监视" not in scene_board.text
    assert client.get("/static/color-math.js").status_code == 200
    canvas_tools = client.get("/static/canvas-tools-model.js")
    assert canvas_tools.status_code == 200
    assert 'presets: Object.freeze([1, 2, 3, 4])' in canvas_tools.text
    assert client.get("/static/color-picker.js").status_code == 200
    assert client.get("/static/views/templates.js").status_code == 200
    assert client.get("/static/views/animations.js").status_code == 200
    assert client.get("/static/animation-ui-model.js").status_code == 200
    assert client.get("/static/sortable-card.js").status_code == 200
    interaction_feedback = client.get("/static/interaction-feedback.js")
    assert interaction_feedback.status_code == 200
    assert 'setAttribute("aria-disabled", "true")' in interaction_feedback.text
    assert 'setAttribute("aria-busy", "true")' in interaction_feedback.text
    device_view = client.get("/static/views/device.js")
    assert device_view.status_code == 200
    assert "/api/preview/diagnostic" not in device_view.text
    assert "showTestFill" not in device_view.text
    assert 'limiting: "电压过低，屏幕亮度限制"' in device_view.text
    assert 'critical: "电压过低，屏幕已经禁用，请充电"' in device_view.text
    settings_view = client.get("/static/views/settings.js")
    assert settings_view.status_code == 200
    assert "JSON.stringify({ low_voltage_protection_enabled: requested })" in settings_view.text
    assert "showLowVoltageProtectionSwitch(previous)" in settings_view.text
    assert "低电压亮度保护保存失败" in settings_view.text
    assert "JSON.stringify({ performance_mode_enabled: requested })" in settings_view.text
    assert "性能模式切换失败" in settings_view.text
    assert "JSON.stringify({ animation_preview_max_concurrent: requested })" in settings_view.text
    assert "同时播放数量保存失败" in settings_view.text
    protection_sync = settings_view.text.index(
        "lowVoltageProtectionStatus = detail.power?.low_voltage_protection || null;"
    )
    pending_early_return = settings_view.text.index(
        "if (orientationPending || applyingBrightness || desiredBrightness !== null) return;"
    )
    assert protection_sync < pending_early_return
    assert "保护开关已从其他页面同步为开启" in settings_view.text
    assert "当前允许的最高亮度：${limitText}%" in settings_view.text
    versioned_app = client.get(f"/static/{app.state.app_version}/app.js")
    assert versioned_app.status_code == 200
    assert versioned_app.headers["cache-control"] == "public, max-age=31536000, immutable"
    assert 'from "./core.js"' in versioned_app.text
    assert client.get(f"/static/{app.state.app_version}/views/device.js").status_code == 200
    assert client.get(f"/static/{app.state.app_version}/canvas-tools-model.js").status_code == 200
    assert client.get(f"/static/{app.state.app_version}/interaction-feedback.js").status_code == 200

    status = client.get("/api/status")
    assert status.headers["cache-control"] == "no-store"
    assert status.json()["service"]["app_version"] == app.state.app_version
    assert status.json()["service"]["instance_id"] == app.state.instance_id
    assert status.json()["state"]["revision"] == 0


def test_app_lifecycle_starts_default_animation_and_screen_write_replaces_it(tmp_path):
    app = create_app(project_root=tmp_path, driver_kind="mock", startup_boot_id="boot-api")

    with TestClient(app) as client:
        status = client.get("/api/status").json()
        config = client.get("/api/config").json()
        assert status["state"]["mode"] == "animation"
        assert status["state"]["startup_indicator_active"] is False
        assert status["state"]["animation_active"] is True
        assert status["state"]["current_content"] == {
            "category": "animation",
            "id": DEMO_ANIMATION_ID,
            "name": DEMO_ANIMATION_NAME,
        }
        assert status["state"]["brightness"] == config["brightness"]
        assert status["state"]["effective_brightness"] == config["brightness"]

        preview = client.post("/api/preview/diagnostic", json={"mode": "corners_lines"})
        assert preview.status_code == 200
        assert client.get("/api/status").json()["state"]["animation_active"] is True

        invalid = client.post("/api/display/fill", json={"color": "not-a-color"})
        assert invalid.status_code == 400
        assert client.get("/api/status").json()["state"]["animation_active"] is True

        applied = client.post("/api/display/clear")
        assert applied.status_code == 200
        final_status = client.get("/api/status").json()
        assert final_status["state"]["startup_indicator_active"] is False
        assert final_status["state"]["animation_active"] is False
        assert final_status["state"]["effective_brightness"] == config["brightness"]
        assert final_status["state"]["mode"] == "clear"
        assert final_status["state"]["current_content"]["name"] == "未保存内容"


def test_maintenance_black_startup_skips_default_content_and_boot_overlay(tmp_path):
    app = create_app(
        project_root=tmp_path,
        driver_kind="mock",
        startup_boot_id="maintenance-black",
        maintenance_black=True,
    )

    with TestClient(app) as client:
        status = client.get("/api/status").json()
        frame = Image.open(BytesIO(client.get("/api/display/current-frame").content))

        assert app.state.maintenance_black is True
        assert status["state"]["mode"] == "clear"
        assert status["state"]["animation_active"] is False
        assert status["state"]["wifi_indicator_active"] is False
        assert frame.convert("RGB").getbbox() is None


def test_default_content_api_applies_persists_and_validates_template_source(tmp_path):
    app = create_app(project_root=tmp_path, driver_kind="mock", startup_boot_id="default-api")
    with TestClient(app) as client:
        initial = client.get("/api/display/default-content")
        assert initial.status_code == 200
        assert initial.json()["id"] == DEMO_ANIMATION_ID
        assert initial.json()["is_demo"] is True

        empty = client.post("/api/animations", json={"name": "空动图"}).json()
        rejected = client.put(
            "/api/display/default-content",
            json={"type": "animation", "id": empty["id"]},
        )
        assert rejected.status_code == 409
        assert client.get("/api/display/default-content").json()["id"] == DEMO_ANIMATION_ID

        created = client.post(
            "/api/templates",
            json={"name": "默认静态图", "scene": solid_scene((120, 30, 10))},
        ).json()
        selected = client.put(
            "/api/display/default-content",
            json={"type": "template", "id": created["id"]},
        )
        assert selected.status_code == 200
        assert selected.json()["name"] == "默认静态图"
        state = client.get("/api/status").json()["state"]
        assert state["mode"] == "template"
        assert state["current_content"] == {
            "category": "template",
            "id": created["id"],
            "name": "默认静态图",
        }

        frame = bytes((120, 30, 10)) * (64 * 64)
        with client.websocket_connect("/ws/canvas") as websocket:
            websocket.send_json({
                "type": "frame_rgb",
                "source": "composition",
                "width": 64,
                "height": 64,
                "encoding": "base64_rgb888",
                "data": base64.b64encode(frame).decode("ascii"),
                "content_source": {
                    "type": "template",
                    "id": created["id"],
                    "revision": created["revision"],
                },
            })
            assert websocket.receive_json()["applied"] is True
        assert client.get("/api/status").json()["state"]["current_content"]["name"] == "默认静态图"

        updated = client.put(
            f"/api/templates/{created['id']}",
            headers={"If-Match": f'"{created["revision"]}"'},
            json={"scene": solid_scene((1, 2, 3))},
        ).json()
        assert updated["revision"] != created["revision"]
        with client.websocket_connect("/ws/canvas") as websocket:
            websocket.send_json({
                "type": "frame_rgb",
                "source": "composition",
                "width": 64,
                "height": 64,
                "encoding": "base64_rgb888",
                "data": base64.b64encode(frame).decode("ascii"),
                "content_source": {
                    "type": "template",
                    "id": created["id"],
                    "revision": created["revision"],
                },
            })
            assert websocket.receive_json()["applied"] is True
        assert client.get("/api/status").json()["state"]["current_content"] == {
            "category": "unsaved",
            "id": None,
            "name": "未保存内容",
        }
        with client.websocket_connect("/ws/canvas") as websocket:
            websocket.send_json({
                "type": "frame_rgb",
                "source": "composition",
                "width": 64,
                "height": 64,
                "encoding": "base64_rgb888",
                "data": base64.b64encode(frame).decode("ascii"),
                "content_source": {
                    "type": "template",
                    "id": "not-a-uuid",
                    "revision": created["revision"],
                },
            })
            assert websocket.receive_json()["type"] == "error"

    restarted = create_app(project_root=tmp_path, driver_kind="mock", startup_boot_id="default-api-restart")
    with TestClient(restarted) as client:
        assert client.get("/api/display/default-content").json()["id"] == created["id"]
        assert client.get("/api/status").json()["state"]["current_content"]["name"] == "默认静态图"


def test_static_content_version_changes_with_paths_and_content(tmp_path):
    static_dir = tmp_path / "static"
    static_dir.mkdir()
    (static_dir / "app.js").write_text("one", encoding="utf-8")
    first = static_content_version(static_dir)
    assert first == static_content_version(static_dir)

    (static_dir / "app.js").write_text("two", encoding="utf-8")
    second = static_content_version(static_dir)
    assert second != first

    (static_dir / "nested").mkdir()
    (static_dir / "nested" / "app.js").write_text("two", encoding="utf-8")
    assert static_content_version(static_dir) != second


def test_systemd_preserves_runtime_marker_across_service_stop_and_restart():
    unit = (Path(__file__).resolve().parents[1] / "systemd" / "matrix-screen-controller.service").read_text(encoding="utf-8")
    assert "RuntimeDirectoryPreserve=yes" in unit
    assert "scripts/dedicated_host.py check --service" in unit
    assert "After=NetworkManager.service" in unit
    assert "Wants=NetworkManager.service" in unit
    assert "network-online.target" not in unit


def test_wifi_settings_api_reveals_password_only_on_dedicated_get(tmp_path):
    connection_uuid = "12345678-1234-5678-1234-567812345678"
    backend = MockNetworkManager(
        saved={
            "connection_uuid": connection_uuid,
            "ssid": "phone-hotspot",
            "password": "secret123",
            "password_configured": True,
            "ipv4_mode": "dhcp",
            "address": None,
            "prefix": None,
            "gateway": None,
            "dns_servers": [],
        },
        active={
            "connected": True,
            "connection_uuid": connection_uuid,
            "ssid": "phone-hotspot",
            "ipv4_address": "192.168.9.93",
            "control_url": "http://192.168.9.93:8080/",
        },
    )
    app = create_app(
        project_root=tmp_path,
        driver_kind="mock",
        startup_boot_id="wifi-api",
        network_backend=backend,
    )
    with TestClient(app) as client:
        initial = client.get("/api/network/wifi")
        assert initial.status_code == 200
        assert initial.json()["saved"]["password_configured"] is True
        assert initial.json()["saved"]["password"] == "secret123"
        assert initial.json()["active"]["control_url"] == "http://192.168.9.93:8080/"
        status_network = client.get("/api/status").json()["network"]
        assert "password" not in status_network["saved"]
        startup_activation_count = len(backend.activations)

        payload = {
            "ssid": "phone-hotspot",
            "password": None,
            "ipv4_mode": "manual",
            "address": "192.168.9.94",
            "gateway": "192.168.9.1",
            "prefix": None,
            "dns_servers": [],
            "prompt_delay_seconds": 45,
            "activation": "next_boot",
        }
        deferred = client.put("/api/network/wifi", json=payload)
        assert deferred.status_code == 200
        assert deferred.json()["activation"] == "next_boot"
        assert len(backend.activations) == startup_activation_count

        payload["activation"] = "immediate"
        immediate = client.put("/api/network/wifi", json=payload)
        assert immediate.status_code == 202
        assert immediate.json()["activation"] == "immediate"
        assert len(backend.activations) == startup_activation_count + 1
        assert backend.activations[-1] == connection_uuid
        assert "secret123" not in immediate.text


def test_wifi_prompt_delay_api_is_independent_from_network_manager(tmp_path):
    connection_uuid = "12345678-1234-5678-1234-567812345678"
    backend = MockNetworkManager(
        saved={
            "connection_uuid": connection_uuid,
            "ssid": "phone-hotspot",
            "password": "secret123",
            "password_configured": True,
            "ipv4_mode": "dhcp",
            "address": None,
            "prefix": None,
            "gateway": None,
            "dns_servers": [],
        },
        active={
            "connected": True,
            "connection_uuid": connection_uuid,
            "ssid": "phone-hotspot",
            "ipv4_address": "192.168.9.93",
            "control_url": "http://192.168.9.93:8080/",
        },
    )
    app = create_app(
        project_root=tmp_path,
        driver_kind="mock",
        startup_boot_id="wifi-delay-api",
        network_backend=backend,
    )
    with TestClient(app) as client:
        before = client.get("/api/network/wifi").json()
        saved_before = dict(backend.saved)
        activations_before = list(backend.activations)

        response = client.put(
            "/api/network/wifi/prompt-delay",
            json={"prompt_delay_seconds": 45},
        )

        assert response.status_code == 200
        assert response.json()["prompt_delay_seconds"] == 45
        after = client.get("/api/network/wifi").json()
        assert after["prompt_delay_seconds"] == 45
        assert after["prompt"]["deadline_monotonic"] == before["prompt"]["deadline_monotonic"]
        assert backend.saved == saved_before
        assert backend.activations == activations_before
        assert client.put(
            "/api/network/wifi/prompt-delay",
            json={"prompt_delay_seconds": 0},
        ).status_code == 400
        assert client.put(
            "/api/network/wifi/prompt-delay",
            json={"prompt_delay_seconds": True},
        ).status_code == 422


def test_homepage_dismisses_wifi_prompt_for_current_boot(tmp_path):
    app = create_app(project_root=tmp_path, driver_kind="mock", startup_boot_id="wifi-home")
    with TestClient(app) as client:
        before = client.get("/api/network/wifi").json()
        assert before["prompt"]["dismissed_for_boot"] is False
        assert client.get("/api/status").json()["state"]["current_content"]["id"] == DEMO_ANIMATION_ID
        app.state.display_service.show_wifi_indicator(
            connected=True,
            message="SSID: test  IP: http://192.168.1.20:8080/",
        )
        assert client.get("/api/status").json()["state"]["current_content"] == {
            "category": "system",
            "id": None,
            "name": "WiFi 提示",
        }
        assert client.get("/").status_code == 200
        after = client.get("/api/network/wifi").json()
        assert after["prompt"]["dismissed_for_boot"] is True
        restored = client.get("/api/status").json()["state"]
        assert restored["current_content"]["id"] == DEMO_ANIMATION_ID
        assert restored["animation_active"] is True


def test_device_view_hides_hardware_diagnostics_and_uses_temporary_test_api():
    source = (
        Path(__file__).resolve().parents[1]
        / "app"
        / "static"
        / "views"
        / "device.js"
    ).read_text(encoding="utf-8")

    assert "disable_hardware_pulsing" not in source
    assert "/api/display/diagnostic" not in source
    assert "/api/display/test/fill" in source
    assert "/api/display/test/brightness" in source
    assert "/api/device-storage" in source


def test_settings_view_exposes_transactional_refresh_rate_buttons():
    static_root = Path(__file__).resolve().parents[1] / "app" / "static"
    source = (static_root / "views" / "settings.js").read_text(encoding="utf-8")
    html = (static_root / "index.html").read_text(encoding="utf-8")

    assert html.count("data-matrix-refresh-rate=") == 7
    assert "设置屏幕的最高扫描频率，不建议低于80Hz。更低的频率可以大大降低功耗，但会导致屏幕闪烁。" in html
    assert "matrix_refresh_rate_limit_hz" in source
    assert "扫描刷新率应用失败" in source