"""Tests for eco.manual_control.box_server: the background service that
holds a console's connection to the physical control box.

Uses the Flask test client (no HTTP socket) against a real BoxListener on
loopback, exactly like tests/test_manual_control_box.py's own link tests -
the box side is real, only the socket the test client talks to is faked by
Flask.
"""

import threading
import time

import pytest

flask = pytest.importorskip("flask")

from eco.manual_control.box_server import BoxServerState, create_box_app
from eco.manual_control.demo import build_fake_beamline
from eco.manual_control.remote.box_link import BoxListener
from eco.manual_control.remote.client import RemoteControlClient
from eco.utilities.config import Namespace

TOKEN = "box-server-test-token"


def _listener(port, token=TOKEN):
    return BoxListener(port=port, token=token, bind="127.0.0.1")


def _next_request(listener, timeout=5.0):
    deadline = time.time() + timeout
    while time.time() < deadline:
        request = listener.pending()
        if request is not None:
            return request
        time.sleep(0.02)
    return None


def _wait(predicate, timeout=5.0):
    deadline = time.time() + timeout
    while time.time() < deadline:
        if predicate():
            return True
        time.sleep(0.02)
    return False


def _fresh_namespace():
    from eco.elements.adjustable import DummyAdjustable

    ns = Namespace(name="bernina_test")
    ns.append_obj(DummyAdjustable, name="theta", module_name=None)
    return ns


def test_health_before_any_connection_reports_idle():
    ns = _fresh_namespace()
    state = BoxServerState(ns, "127.0.0.1", 8760, TOKEN, None)
    app = create_box_app(ns, state)
    resp = app.test_client().get("/health")
    body = resp.get_json()
    assert resp.status_code == 200
    assert body["state"] == "idle"
    assert body["connected"] is False
    assert body["namespace"] == "bernina_test"
    assert body["box"] == "127.0.0.1:8760"


def test_health_reflects_a_real_accepted_connection():
    listener = _listener(8759)
    ns = _fresh_namespace()
    state = BoxServerState(ns, "127.0.0.1", 8759, TOKEN, None)
    app = create_box_app(ns, state)
    client = app.test_client()
    try:
        resp = client.get("/health")
        assert resp.get_json()["state"] == "idle"

        state.connect()  # what main() does at startup
        assert _wait(lambda: state._session() is not None)
        assert _wait(lambda: state._session().state == "waiting for the operator")
        assert client.get("/health").get_json()["state"] == "waiting for the operator"

        request = _next_request(listener)
        assert request is not None
        box_client = RemoteControlClient(request.accept()).start()
        assert _wait(lambda: bool(box_client.entries))
        assert _wait(lambda: state.connected)

        body = client.get("/health").get_json()
        assert body["state"] == "connected"
        assert body["connected"] is True
    finally:
        ns.stop_eco_control_box()
        listener.close()


def test_admin_disconnect_releases_the_box_and_it_is_reported():
    """The safety button: /admin/disconnect must actually drop the link, and
    the box side must notice (fall back to waiting), not just the console."""
    listener = _listener(8758)
    ns = _fresh_namespace()
    state = BoxServerState(ns, "127.0.0.1", 8758, TOKEN, None)
    app = create_box_app(ns, state)
    client = app.test_client()
    try:
        state.connect()
        request = _next_request(listener)
        box_client = RemoteControlClient(request.accept()).start()
        assert _wait(lambda: bool(box_client.entries))
        assert _wait(lambda: state.connected)

        resp = client.post("/admin/disconnect")
        body = resp.get_json()
        assert resp.status_code == 200
        assert body["connected"] is False
        assert "disconnect" in body["message"]

        # the box side must see this too, not just the console bookkeeping
        assert _wait(lambda: not box_client.connected), \
            "the box was not told the session disconnected"

        # health afterwards still reflects "not connected", not a crash
        assert client.get("/health").get_json()["connected"] is False
    finally:
        ns.stop_eco_control_box()
        listener.close()


def test_admin_reconnect_offers_a_new_session_that_the_box_can_accept():
    listener = _listener(8757)
    ns = _fresh_namespace()
    state = BoxServerState(ns, "127.0.0.1", 8757, TOKEN, None)
    app = create_box_app(ns, state)
    client = app.test_client()
    try:
        # nothing connected yet - /admin/reconnect must offer a session
        resp = client.post("/admin/reconnect")
        assert resp.get_json()["state"] in ("dialling", "waiting for the operator")

        request = _next_request(listener)
        assert request is not None, "/admin/reconnect did not call the box"
        box_client = RemoteControlClient(request.accept()).start()
        assert _wait(lambda: bool(box_client.entries))
        assert _wait(lambda: state.connected)
    finally:
        ns.stop_eco_control_box()
        listener.close()


def test_admin_reconnect_is_idempotent_while_already_connecting():
    """Calling reconnect twice in a row must not open two competing sessions
    - Namespace.start_eco_control_box() is already idempotent; this checks
    box_server does not bypass that."""
    listener = _listener(8756)
    ns = _fresh_namespace()
    state = BoxServerState(ns, "127.0.0.1", 8756, TOKEN, None)
    app = create_box_app(ns, state)
    client = app.test_client()
    try:
        client.post("/admin/reconnect")
        first_session = ns._control_box_server
        client.post("/admin/reconnect")
        assert ns._control_box_server is first_session
    finally:
        ns.stop_eco_control_box()
        listener.close()


def test_admin_restart_disconnects_then_execs(monkeypatch):
    """Mirrors test_status_server.py's restart test: the listening socket
    must be closed before os.execv (werkzeug marks it inheritable), and -
    unlike the plain status server - the box must be told to disconnect
    first, so a restarted process does not leave the box thinking it is
    still connected to a session that is about to vanish."""
    import types

    from eco.manual_control import box_server as box_server_mod

    listener = _listener(8755)
    ns = _fresh_namespace()
    state = BoxServerState(ns, "127.0.0.1", 8755, TOKEN, None)
    holder = {}
    app = create_box_app(ns, state, wsgi_server_holder=holder)
    client = app.test_client()
    try:
        state.connect()
        request = _next_request(listener)
        box_client = RemoteControlClient(request.accept()).start()
        assert _wait(lambda: bool(box_client.entries))
        assert _wait(lambda: state.connected)

        closed = []
        execd = []
        holder["server"] = types.SimpleNamespace(server_close=lambda: closed.append(True))
        monkeypatch.setattr(box_server_mod.os, "execv", lambda exe, argv: execd.append(argv))
        monkeypatch.setattr(box_server_mod.time, "sleep", lambda s: None)

        resp = client.post("/admin/restart", json={"delay": 0})
        assert resp.status_code == 202

        assert _wait(lambda: bool(execd), timeout=5)
        assert closed == [True]
        assert _wait(lambda: not box_client.connected), \
            "restart must disconnect the box before re-exec'ing"
    finally:
        ns.stop_eco_control_box()
        listener.close()


def test_health_survives_no_control_box_attribute_yet():
    """A namespace that has never called start/stop_eco_control_box (the
    attribute genuinely does not exist) must not crash /health."""
    ns = _fresh_namespace()
    assert not hasattr(ns, "_control_box_server")
    state = BoxServerState(ns, "127.0.0.1", 8754, TOKEN, None)
    app = create_box_app(ns, state)
    body = app.test_client().get("/health").get_json()
    assert body["state"] == "idle"
    assert body["connected"] is False


def test_restart_argv_reconstructs_module_invocation(monkeypatch):
    """Same reasoning/test shape as status_server's equivalent: running the
    __main__.py file directly breaks relative imports, so a re-exec must use
    `-m eco.manual_control.box_server`, not sys.argv[0] verbatim."""
    import sys
    import types

    from eco.manual_control import box_server as box_server_mod

    fake_main = types.ModuleType("__main__")
    fake_main.__spec__ = types.SimpleNamespace(name="eco.manual_control.box_server",
                                                parent="eco.manual_control.box_server")
    monkeypatch.setitem(sys.modules, "__main__", fake_main)
    monkeypatch.setattr(sys, "argv", ["box_server.py", "-s", "bernina"])
    argv = box_server_mod._restart_argv()
    assert argv[:3] == [sys.executable, "-m", "eco.manual_control.box_server"]
    assert argv[3:] == ["-s", "bernina"]