from __future__ import annotations

import json
import tempfile
import unittest
from pathlib import Path

from techviz.cli import main


ROOT = Path(__file__).resolve().parents[1]


class CliTests(unittest.TestCase):
    def test_prepare_prompt_lint_render(self) -> None:
        with tempfile.TemporaryDirectory() as tmp:
            root = Path(tmp)
            context = root / "context.json"
            prompt = root / "prompt.md"
            output = root / "out"
            self.assertEqual(
                main([
                    "prepare",
                    str(ROOT / "examples/docs/payment-flow.md"),
                    "--marker",
                    "payment-request",
                    "-o",
                    str(context),
                ]),
                0,
            )
            self.assertEqual(main(["prompt", str(context), "-o", str(prompt)]), 0)
            self.assertIn("untrusted evidence data", prompt.read_text(encoding="utf-8"))
            self.assertEqual(
                main([
                    "lint",
                    str(ROOT / "examples/work/payment/spec.json"),
                    "--context",
                    str(context),
                ]),
                0,
            )
            self.assertEqual(
                main([
                    "render",
                    str(ROOT / "examples/work/payment/spec.json"),
                    "--context",
                    str(context),
                    "--formats",
                    "svg,a11y",
                    "-o",
                    str(output),
                ]),
                0,
            )
            manifest = json.loads((output / "payment-request.manifest.json").read_text(encoding="utf-8"))
            self.assertEqual(manifest["spec_id"], "payment-request")

    def test_render_blocks_unapproved_assumptions(self) -> None:
        with tempfile.TemporaryDirectory() as tmp:
            root = Path(tmp)
            data = json.loads((ROOT / "examples/work/payment/spec.json").read_text(encoding="utf-8"))
            data["nodes"][0]["evidence"] = []
            data["nodes"][0]["assumption"] = True
            spec = root / "assumption.json"
            spec.write_text(json.dumps(data, ensure_ascii=False), encoding="utf-8")
            blocked_output = root / "blocked"
            self.assertEqual(
                main([
                    "render",
                    str(spec),
                    "--context",
                    str(ROOT / "examples/work/payment/context.json"),
                    "--formats",
                    "svg",
                    "-o",
                    str(blocked_output),
                ]),
                1,
            )
            self.assertFalse((blocked_output / "payment-request.svg").exists())

            approved_output = root / "approved"
            self.assertEqual(
                main([
                    "render",
                    str(spec),
                    "--context",
                    str(ROOT / "examples/work/payment/context.json"),
                    "--formats",
                    "svg",
                    "--allow-assumptions",
                    "-o",
                    str(approved_output),
                ]),
                0,
            )
            manifest = json.loads((approved_output / "payment-request.manifest.json").read_text(encoding="utf-8"))
            self.assertEqual(manifest["assumption_count"], 1)
            self.assertTrue(manifest["assumptions_allowed"])


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