"""Unit tests for DockerMiddleware with mocked Docker client."""

from unittest.mock import MagicMock, patch

import pytest

from gnuradio_mcp.middlewares.docker import (
    CONTAINER_FLOWGRAPH_DIR,
    DEFAULT_XMLRPC_PORT,
    DockerMiddleware,
)
from gnuradio_mcp.models import ContainerModel, ScreenshotModel


@pytest.fixture
def mock_docker_client():
    return MagicMock()


@pytest.fixture
def docker_mw(mock_docker_client):
    return DockerMiddleware(mock_docker_client)


class TestDockerMiddlewareCreate:
    def test_create_returns_none_when_docker_unavailable(self):
        with patch(
            "gnuradio_mcp.middlewares.docker.docker",
            create=True,
        ) as mock_mod:
            mock_mod.from_env.side_effect = Exception("No Docker")
            # We need to patch the import inside create()
            with patch.dict("sys.modules", {"docker": mock_mod}):
                result = DockerMiddleware.create()
                assert result is None

    def test_create_returns_middleware_when_docker_available(self):
        mock_mod = MagicMock()
        mock_client = MagicMock()
        mock_mod.from_env.return_value = mock_client
        with patch.dict("sys.modules", {"docker": mock_mod}):
            result = DockerMiddleware.create()
            assert result is not None
            mock_client.ping.assert_called_once()


class TestLaunch:
    def test_launch_creates_container(self, docker_mw, mock_docker_client, tmp_path):
        fg_file = tmp_path / "test.grc"
        fg_file.write_text("<flowgraph/>")

        mock_container = MagicMock()
        mock_container.id = "abc123def456"
        mock_docker_client.containers.run.return_value = mock_container

        result = docker_mw.launch(
            flowgraph_path=str(fg_file),
            name="test-fg",
            xmlrpc_port=8080,
        )

        assert isinstance(result, ContainerModel)
        assert result.name == "test-fg"
        assert result.container_id == "abc123def456"
        assert result.status == "running"
        assert result.xmlrpc_port == 8080

        mock_docker_client.containers.run.assert_called_once()
        call_kwargs = mock_docker_client.containers.run.call_args
        assert call_kwargs.kwargs["name"] == "test-fg"
        assert call_kwargs.kwargs["detach"] is True

    def test_launch_raises_on_missing_file(self, docker_mw):
        with pytest.raises(FileNotFoundError):
            docker_mw.launch(
                flowgraph_path="/nonexistent/file.grc",
                name="test",
            )

    def test_launch_with_vnc(self, docker_mw, mock_docker_client, tmp_path):
        fg_file = tmp_path / "test.grc"
        fg_file.write_text("<flowgraph/>")

        mock_container = MagicMock()
        mock_container.id = "abc123def456"
        mock_docker_client.containers.run.return_value = mock_container

        result = docker_mw.launch(
            flowgraph_path=str(fg_file),
            name="test-vnc",
            enable_vnc=True,
        )
        assert result.vnc_port == 5900

        # Verify VNC label is set
        call_kwargs = mock_docker_client.containers.run.call_args
        assert call_kwargs.kwargs["labels"]["gr-mcp.vnc-enabled"] == "1"

    def test_launch_without_vnc_sets_label(self, docker_mw, mock_docker_client, tmp_path):
        fg_file = tmp_path / "test.grc"
        fg_file.write_text("<flowgraph/>")

        mock_container = MagicMock()
        mock_container.id = "abc123def456"
        mock_docker_client.containers.run.return_value = mock_container

        result = docker_mw.launch(
            flowgraph_path=str(fg_file),
            name="test-no-vnc",
            enable_vnc=False,
        )
        assert result.vnc_port is None

        # Verify VNC label is explicitly set to "0"
        call_kwargs = mock_docker_client.containers.run.call_args
        assert call_kwargs.kwargs["labels"]["gr-mcp.vnc-enabled"] == "0"

    def test_launch_with_devices(self, docker_mw, mock_docker_client, tmp_path):
        fg_file = tmp_path / "test.grc"
        fg_file.write_text("<flowgraph/>")

        mock_container = MagicMock()
        mock_container.id = "abc123def456"
        mock_docker_client.containers.run.return_value = mock_container

        result = docker_mw.launch(
            flowgraph_path=str(fg_file),
            name="test-sdr",
            device_paths=["/dev/bus/usb/001/002"],
        )
        assert result.device_paths == ["/dev/bus/usb/001/002"]

        call_kwargs = mock_docker_client.containers.run.call_args
        assert "/dev/bus/usb/001/002:/dev/bus/usb/001/002:rwm" in call_kwargs.kwargs["devices"]


class TestListContainers:
    def test_list_containers(self, docker_mw, mock_docker_client):
        mock_c = MagicMock()
        mock_c.name = "gr-test"
        mock_c.id = "abc123def456"
        mock_c.status = "running"
        mock_c.labels = {
            "gr-mcp.flowgraph": "/path/to/test.grc",
            "gr-mcp.xmlrpc-port": "8080",
            "gr-mcp.vnc-enabled": "0",
        }
        mock_docker_client.containers.list.return_value = [mock_c]

        result = docker_mw.list_containers()
        assert len(result) == 1
        assert result[0].name == "gr-test"
        assert result[0].flowgraph_path == "/path/to/test.grc"
        assert result[0].vnc_port is None  # VNC not enabled

    def test_list_containers_with_vnc(self, docker_mw, mock_docker_client):
        mock_c = MagicMock()
        mock_c.name = "gr-test-vnc"
        mock_c.id = "abc123def456"
        mock_c.status = "running"
        mock_c.labels = {
            "gr-mcp.flowgraph": "/path/to/test.grc",
            "gr-mcp.xmlrpc-port": "8080",
            "gr-mcp.vnc-enabled": "1",
        }
        mock_docker_client.containers.list.return_value = [mock_c]

        result = docker_mw.list_containers()
        assert len(result) == 1
        assert result[0].vnc_port == 5900  # VNC enabled

    def test_list_containers_empty(self, docker_mw, mock_docker_client):
        mock_docker_client.containers.list.return_value = []
        result = docker_mw.list_containers()
        assert result == []


class TestStopRemove:
    def test_stop(self, docker_mw, mock_docker_client):
        mock_container = MagicMock()
        mock_docker_client.containers.get.return_value = mock_container
        assert docker_mw.stop("test") is True
        mock_container.stop.assert_called_once_with(timeout=10)

    def test_remove(self, docker_mw, mock_docker_client):
        mock_container = MagicMock()
        mock_docker_client.containers.get.return_value = mock_container
        assert docker_mw.remove("test") is True
        mock_container.remove.assert_called_once_with(force=False)

    def test_remove_force(self, docker_mw, mock_docker_client):
        mock_container = MagicMock()
        mock_docker_client.containers.get.return_value = mock_container
        assert docker_mw.remove("test", force=True) is True
        mock_container.remove.assert_called_once_with(force=True)


class TestLogs:
    def test_get_logs(self, docker_mw, mock_docker_client):
        mock_container = MagicMock()
        mock_container.logs.return_value = b"flowgraph started\n"
        mock_docker_client.containers.get.return_value = mock_container

        result = docker_mw.get_logs("test", tail=50)
        assert "flowgraph started" in result
        mock_container.logs.assert_called_once_with(tail=50)


class TestScreenshot:
    def test_capture_screenshot(self, docker_mw, mock_docker_client):
        mock_container = MagicMock()
        # Simulate PNG bytes
        mock_container.exec_run.return_value = (0, b"\x89PNG\r\n\x1a\n")
        mock_docker_client.containers.get.return_value = mock_container

        result = docker_mw.capture_screenshot("test")
        assert isinstance(result, ScreenshotModel)
        assert result.container_name == "test"
        assert result.format == "png"
        assert len(result.image_base64) > 0

    def test_capture_screenshot_failure(self, docker_mw, mock_docker_client):
        mock_container = MagicMock()
        mock_container.exec_run.return_value = (1, b"error: no display")
        mock_docker_client.containers.get.return_value = mock_container

        with pytest.raises(RuntimeError, match="Screenshot failed"):
            docker_mw.capture_screenshot("test")


class TestGetXmlRpcPort:
    def test_get_port_from_label(self, docker_mw, mock_docker_client):
        mock_container = MagicMock()
        mock_container.labels = {"gr-mcp.xmlrpc-port": "9090"}
        mock_docker_client.containers.get.return_value = mock_container

        assert docker_mw.get_xmlrpc_port("test") == 9090

    def test_get_default_port(self, docker_mw, mock_docker_client):
        mock_container = MagicMock()
        mock_container.labels = {}
        mock_docker_client.containers.get.return_value = mock_container

        assert docker_mw.get_xmlrpc_port("test") == DEFAULT_XMLRPC_PORT