from __future__ import annotations

import ast
import json
import unittest
from pathlib import Path


class MCPMetadataTests(unittest.TestCase):
    def test_every_dashboard_tool_has_public_name_and_description(self) -> None:
        tree = ast.parse(Path("renderer_app.py").read_text(encoding="utf-8-sig"))
        functions = {
            node.name: node
            for node in tree.body
            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))
        }
        formatter_module = ast.Module(body=[functions["_mcp_description"]], type_ignores=[])
        ast.fix_missing_locations(formatter_module)
        namespace = {"json": json, "Any": object}
        exec(compile(formatter_module, "renderer_app.py", "exec"), namespace)
        format_description = namespace["_mcp_description"]
        events = [
            node
            for node in ast.walk(tree)
            if isinstance(node, ast.Call)
            and isinstance(node.func, ast.Attribute)
            and node.func.attr == "click"
        ]

        self.assertEqual(len(events), 25)
        for event in events:
            keywords = {item.arg: item.value for item in event.keywords if item.arg}
            callback = keywords.get("fn")
            self.assertIsInstance(callback, ast.Name, "MCP callbacks must be named functions")
            callback_name = callback.id
            self.assertFalse(callback_name.startswith("_"), f"Private MCP callback: {callback_name}")
            self.assertIn(callback_name, functions)
            self.assertTrue(ast.get_docstring(functions[callback_name]), f"Missing docstring: {callback_name}")

            api_name = keywords.get("api_name")
            description = keywords.get("api_description")
            self.assertIsInstance(api_name, ast.Constant, f"Missing api_name: {callback_name}")
            self.assertTrue(api_name.value, f"Empty api_name: {callback_name}")
            self.assertIsInstance(description, ast.Call, f"Missing structured api_description: {callback_name}")
            self.assertIsInstance(description.func, ast.Name)
            self.assertEqual(description.func.id, "_mcp_description")
            self.assertEqual(len(description.args), 2)

            summary = ast.literal_eval(description.args[0])
            example = ast.literal_eval(description.args[1])
            self.assertTrue(summary, f"Empty description: {callback_name}")
            self.assertIsInstance(example, dict, f"Example must be an object: {callback_name}")

            rendered = format_description(summary, example)
            marker = "\n\nExample JSON:\n```json\n"
            self.assertIn(marker, rendered, f"Missing JSON code block: {callback_name}")
            self.assertTrue(rendered.endswith("\n```"), f"Unclosed JSON code block: {callback_name}")
            json_payload = rendered.split(marker, 1)[1][:-4]
            self.assertEqual(json.loads(json_payload), example)
            if example:
                self.assertIn('\n  "', json_payload, f"Example is not indented: {callback_name}")

            parameters = [argument.arg for argument in functions[callback_name].args.args]
            self.assertEqual(set(example), set(parameters), f"Example keys do not match: {callback_name}")


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