import importlib.util
import pathlib
import sys
import tempfile
import unittest


REPO_ROOT = pathlib.Path(__file__).resolve().parents[1]
SCRIPT_PATH = REPO_ROOT / "tools" / "render_config.py"


def load_module():
    spec = importlib.util.spec_from_file_location("render_config", SCRIPT_PATH)
    module = importlib.util.module_from_spec(spec)
    sys.modules[spec.name] = module
    spec.loader.exec_module(module)
    return module


class RenderConfigTest(unittest.TestCase):
    def test_renders_profile_and_overlay(self):
        module = load_module()
        template = {
            "name": "pipeline",
            "template": {
                "executor": {"batch_size": 2},
                "nodes": [
                    {"id": "in", "type": "input_rtsp", "url": "${rtsp_url}"},
                    {"id": "face_recog", "type": "ai_face_recog", "debug": {"enabled": False}},
                ],
                "edges": [["in", "face_recog"]],
            },
        }
        profile = {
            "queue": {"size": 8},
            "instances": [
                {
                    "name": "cam1",
                    "params": {"rtsp_url": "rtsp://example/cam1"},
                }
            ],
        }
        overlay = {
            "instance_overrides": {
                "*": {
                    "override": {
                        "nodes": {
                            "face_recog": {"debug": {"enabled": True, "log_matches": True}}
                        }
                    }
                }
            }
        }

        root = {
            "templates": {module.template_name(template, pathlib.Path("x.json")): module.template_body(template)},
            "instances": module.profile_instances(profile, "pipeline"),
            "queue": profile["queue"],
        }
        rendered = module.apply_overlay(root, overlay)

        self.assertEqual(rendered["queue"]["size"], 8)
        self.assertEqual(rendered["instances"][0]["template"], "pipeline")
        self.assertEqual(rendered["instances"][0]["params"]["rtsp_url"], "rtsp://example/cam1")
        node_override = rendered["instances"][0]["override"]["nodes"]["face_recog"]
        self.assertTrue(node_override["debug"]["enabled"])
        self.assertTrue(node_override["debug"]["log_matches"])

    def test_render_applies_multiple_overlays_in_order(self):
        module = load_module()
        with tempfile.TemporaryDirectory() as tmp_dir:
            tmp = pathlib.Path(tmp_dir)
            template_path = tmp / "template.json"
            profile_path = tmp / "profile.json"
            overlay1_path = tmp / "overlay1.json"
            overlay2_path = tmp / "overlay2.json"

            template_path.write_text(
                """
                {
                  "name": "pipeline",
                  "template": {
                    "nodes": [{"id": "alarm", "type": "alarm"}],
                    "edges": []
                  }
                }
                """,
                encoding="utf-8",
            )
            profile_path.write_text(
                """
                {
                  "instances": [{"name": "cam1", "params": {}}]
                }
                """,
                encoding="utf-8",
            )
            overlay1_path.write_text(
                """
                {
                  "instance_overrides": {
                    "*": {
                      "override": {
                        "nodes": {
                          "alarm": {
                            "face_debug": {"log_unknown_candidates": true},
                            "rules": [{"name": "shoe", "cooldown_ms": 1000}]
                          }
                        }
                      }
                    }
                  }
                }
                """,
                encoding="utf-8",
            )
            overlay2_path.write_text(
                """
                {
                  "instance_overrides": {
                    "*": {
                      "override": {
                        "nodes": {
                          "alarm": {
                            "face_debug": {"unknown_candidate_interval_ms": 0},
                            "rules": [{"name": "shoe", "cooldown_ms": 15000}]
                          }
                        }
                      }
                    }
                  }
                }
                """,
                encoding="utf-8",
            )

            rendered = module.render(template_path, profile_path, [overlay1_path, overlay2_path])
            alarm = rendered["instances"][0]["override"]["nodes"]["alarm"]
            self.assertTrue(alarm["face_debug"]["log_unknown_candidates"])
            self.assertEqual(alarm["face_debug"]["unknown_candidate_interval_ms"], 0)
            self.assertEqual(alarm["rules"][0]["cooldown_ms"], 15000)

    def test_render_adds_trace_metadata_when_requested(self):
        module = load_module()
        with tempfile.TemporaryDirectory() as tmp_dir:
            tmp = pathlib.Path(tmp_dir)
            template_path = tmp / "template.json"
            profile_path = tmp / "profile.json"

            template_path.write_text(
                """
                {
                  "name": "pipeline",
                  "template": {
                    "nodes": [{"id": "in", "type": "input_rtsp"}],
                    "edges": []
                  }
                }
                """,
                encoding="utf-8",
            )
            profile_path.write_text(
                """
                {
                  "name": "cam1",
                  "params": {"rtsp_url": "rtsp://example/cam1"}
                }
                """,
                encoding="utf-8",
            )

            rendered = module.render(
                template_path,
                profile_path,
                [],
                metadata={
                    "config_id": "local_3588_face_debug",
                    "config_version": "20260419.001",
                    "rendered_at": "2026-04-19T00:00:00Z",
                    "rendered_by": "test",
                },
            )

            self.assertEqual(rendered["metadata"]["config_id"], "local_3588_face_debug")
            self.assertEqual(rendered["metadata"]["config_version"], "20260419.001")
            self.assertEqual(rendered["metadata"]["template"], "pipeline")
            self.assertEqual(rendered["metadata"]["profile"], "cam1")
            self.assertEqual(rendered["metadata"]["overlays"], [])
            self.assertEqual(rendered["metadata"]["rendered_by"], "test")


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