import unittest

from app.services.detect_service import _slice_remote_log_lines_fairly
from app.services.runtime_status_service import _align_queue_health_with_backlog, _build_detect_node_row


class RuntimeStatusServiceTests(unittest.TestCase):
    def test_build_detect_node_row_merges_queue_running_metrics(self) -> None:
        row = _build_detect_node_row(
            node_code="mainland-worker-01",
            cluster_node={
                "node_code": "mainland-worker-01",
                "region": "mainland",
                "role": "worker",
                "status": "busy",
                "is_effective_worker": True,
                "current_load": 61,
                "metadata": {
                    "job_items_total": 1000,
                    "job_items_claimed": 0,
                    "job_items_running": 61,
                },
            },
            job_node={
                "node_code": "mainland-worker-01",
                "items_total": 0,
                "items_pending": 0,
                "items_claimed": 0,
                "items_running": 0,
                "items_completed": 0,
                "items_failed": 0,
            },
            queue_node={
                "node_code": "mainland-worker-01",
                "items_total": 1000,
                "items_pending": 739,
                "items_claimed": 200,
                "items_running": 61,
                "items_completed": 191,
                "items_blacklisted": 0,
                "items_failed": 0,
                "processed_recent": 632,
                "processed_per_minute": 42.13,
            },
        )

        self.assertEqual(1000, row["items_total"])
        self.assertEqual(200, row["items_claimed"])
        self.assertEqual(61, row["items_running"])
        self.assertEqual("running", row["participation_state"])
        self.assertTrue(row["is_current_participant"])
        self.assertTrue(row["is_dispatch_active"])

    def test_build_detect_node_row_uses_active_threads_as_current_execution_signal(self) -> None:
        row = _build_detect_node_row(
            node_code="mainland-worker-01",
            cluster_node={
                "node_code": "mainland-worker-01",
                "region": "mainland",
                "role": "worker",
                "status": "busy",
                "is_effective_worker": True,
                "current_load": 61,
                "metadata": {
                    "active_threads": 61,
                    "max_threads": 400,
                },
            },
            job_node={},
            queue_node={
                "node_code": "mainland-worker-01",
                "processed_recent": 632,
                "processed_per_minute": 42.13,
            },
        )

        self.assertEqual(61, row["active_threads"])
        self.assertEqual(400, row["max_threads"])
        self.assertEqual("runtime_active", row["participation_state"])
        self.assertEqual("执行中", row["participation_label"])
        self.assertTrue(row["is_dispatch_active"])

    def test_slice_remote_log_lines_fairly_keeps_secondary_node_visible(self) -> None:
        lines = [f"[2026-04-19 17:30:{i:02d}] [mainland-controller-01] controller-{i}" for i in range(20)]
        lines.extend(
            [f"[2026-04-19 17:31:{i:02d}] [mainland-worker-01] worker-{i}" for i in range(2)]
        )

        sliced = _slice_remote_log_lines_fairly(lines, limit=6, min_per_node=2)

        self.assertEqual(6, len(sliced))
        self.assertTrue(any("[mainland-controller-01]" in line for line in sliced))
        self.assertTrue(any("[mainland-worker-01]" in line for line in sliced))

    def test_align_queue_health_with_backlog_prefers_larger_runtime_snapshot(self) -> None:
        aligned = _align_queue_health_with_backlog(
            {
                "has_active_job": True,
                "queue": {
                    "items_total": 120,
                    "pending": 100,
                    "claimed": 10,
                    "running": 5,
                    "completed": 5,
                    "blacklisted": 0,
                    "failed": 0,
                    "terminal": 5,
                },
            },
            {
                "pending_total": 1200,
                "claimed_total": 230,
                "running_total": 40,
                "completed_total": 300,
                "blacklisted_total": 12,
                "failed_total": 8,
            },
        )

        self.assertTrue(aligned["has_active_job"])
        self.assertEqual(1200, aligned["queue"]["pending"])
        self.assertEqual(230, aligned["queue"]["claimed"])
        self.assertEqual(40, aligned["queue"]["running"])
        self.assertEqual(300, aligned["queue"]["completed"])
        self.assertEqual(12, aligned["queue"]["blacklisted"])
        self.assertEqual(8, aligned["queue"]["failed"])
        self.assertEqual(1790, aligned["queue"]["items_total"])


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