import unittest
import subprocess
from unittest.mock import MagicMock, patch

from modules import app_status


class AppStatusTest(unittest.TestCase):
    def test_parses_systemctl_show_output(self):
        status = app_status.parse_systemctl_show(
            "\n".join(
                [
                    "LoadState=loaded",
                    "ActiveState=active",
                    "SubState=running",
                    "UnitFileState=enabled",
                    "Result=success",
                    "NRestarts=3",
                ]
            )
        )

        self.assertEqual(status["load_state"], "loaded")
        self.assertEqual(status["active_state"], "active")
        self.assertEqual(status["sub_state"], "running")
        self.assertEqual(status["unit_file_state"], "enabled")
        self.assertEqual(status["result"], "success")
        self.assertEqual(status["restarts"], 3)

    @patch("modules.app_status._systemd_unit_status", return_value={"ok": True})
    @patch("modules.app_status._obd_status", return_value={"status_label": "Connected"})
    @patch(
        "modules.app_status._cellular_hat_status",
        return_value={"module_responding": True},
    )
    @patch(
        "modules.app_status._server_status",
        return_value={"configured": True, "reachable": True},
    )
    @patch(
        "modules.app_status.app_upload.get_status",
        return_value={"pending_tracking_rows": 0},
    )
    @patch(
        "modules.app_status.app_network.get_status",
        return_value={"mode": "wifi", "internet_reachable": True},
    )
    @patch("modules.app_status.app_gps.get_status", return_value={"thread_alive": True})
    @patch("modules.app_status.app_health.collect_health", return_value={"status": "ok"})
    def test_collect_status_aggregates_subsystems(
        self,
        _collect_health,
        _gps_status,
        _network_status,
        _upload_status,
        _server_status,
        _cellular_status,
        _obd_status,
        _systemd_status,
    ):
        status = app_status.collect_status()

        self.assertEqual(status["health"]["status"], "ok")
        self.assertTrue(status["gps"]["thread_alive"])
        self.assertTrue(status["uplink"]["ok"])
        self.assertEqual(status["uplink"]["mode"], "wifi")
        self.assertTrue(status["server"]["reachable"])
        self.assertTrue(status["cellular_hat"]["module_responding"])
        self.assertEqual(status["obd"]["status_label"], "Connected")
        self.assertEqual(len(status["services"]), len(app_status.SERVICE_UNITS))

    @patch(
        "modules.app_status.app_network.get_status",
        side_effect=app_status.app_network.NetworkConfigurationError("nmcli failed"),
    )
    @patch("modules.app_status._systemd_unit_status", return_value={"ok": True})
    @patch("modules.app_status._obd_status", return_value={"status_label": "Connected"})
    @patch(
        "modules.app_status._cellular_hat_status",
        return_value={"module_responding": True},
    )
    @patch(
        "modules.app_status._server_status",
        return_value={"configured": False, "reachable": False},
    )
    @patch(
        "modules.app_status.app_upload.get_status",
        return_value={"pending_tracking_rows": 0},
    )
    @patch("modules.app_status.app_gps.get_status", return_value={"thread_alive": True})
    @patch("modules.app_status.app_health.collect_health", return_value={"status": "ok"})
    def test_collect_status_surfaces_uplink_errors(
        self,
        _collect_health,
        _gps_status,
        _upload_status,
        _server_status,
        _cellular_status,
        _obd_status,
        _systemd_status,
        _network_status,
    ):
        status = app_status.collect_status()

        self.assertFalse(status["uplink"]["ok"])
        self.assertIn("nmcli failed", status["uplink"]["error"])

    @patch("modules.app_status.Thread")
    @patch("modules.app_status.subprocess.run")
    def test_request_app_restart_schedules_background_restart(self, run, thread):
        run.return_value = MagicMock(returncode=0, stdout="", stderr="")
        thread_instance = MagicMock()
        thread.return_value = thread_instance

        result = app_status.request_app_restart()

        self.assertEqual(result["status"], "restart_scheduled")
        run.assert_called_once_with(
            ["sudo", "-n", "-l", "/usr/bin/systemctl", "restart", "--no-block", "yaris-obd.service"],
            capture_output=True,
            text=True,
            timeout=5,
            check=True,
        )
        thread.assert_called_once_with(
            target=app_status._delayed_restart,
            args=(1,),
            daemon=True,
        )
        thread_instance.start.assert_called_once_with()

    @patch("modules.app_status.subprocess.run", side_effect=subprocess.CalledProcessError(1, "sudo"))
    def test_request_app_restart_requires_installed_permission(self, _run):
        with self.assertRaises(RuntimeError):
            app_status.request_app_restart()


if __name__ == "__main__":
    unittest.main()