from __future__ import annotations

import ast
import unittest
from pathlib import Path


APP_PATH = Path(__file__).resolve().parents[1] / "app.py"


def _load_tree() -> ast.Module:
    return ast.parse(APP_PATH.read_text(encoding="utf-8"))


def _get_function(tree: ast.Module, name: str) -> ast.FunctionDef:
    for node in tree.body:
        if isinstance(node, ast.FunctionDef) and node.name == name:
            return node
    raise AssertionError(f"Function {name!r} not found in app.py")


def _called_names(function_node: ast.FunctionDef) -> set[str]:
    names: set[str] = set()
    for node in ast.walk(function_node):
        if isinstance(node, ast.Call):
            if isinstance(node.func, ast.Name):
                names.add(node.func.id)
            elif isinstance(node.func, ast.Attribute):
                names.add(node.func.attr)
    return names


class AppArchitectureTests(unittest.TestCase):
    def test_default_page_load_no_longer_preprocesses_default_image(self) -> None:
        source = APP_PATH.read_text(encoding="utf-8")

        self.assertNotIn("demo.load(preprocess_default_image", source)

    def test_preview_hdri_stays_off_heavy_model_loader_path(self) -> None:
        preview_hdri = _get_function(_load_tree(), "preview_hdri")
        called = _called_names(preview_hdri)

        self.assertNotIn("ensure_near_pipeline", called)
        self.assertNotIn("set_tone_mapper", called)
        self.assertIn("ToneMapper", called)

    def test_generate_mesh_only_uses_geometry_loader(self) -> None:
        generate_mesh = _get_function(_load_tree(), "generate_mesh")
        called = _called_names(generate_mesh)

        self.assertIn("ensure_geometry_on_cuda", called)
        self.assertNotIn("ensure_near_on_cuda", called)

    def test_render_preview_calls_pipeline_render_view(self) -> None:
        render_preview = _get_function(_load_tree(), "render_preview")
        called = _called_names(render_preview)

        self.assertIn("render_view", called)

    def test_generate_slat_uses_near_cuda_loader(self) -> None:
        generate_slat = _get_function(_load_tree(), "generate_slat")
        called = _called_names(generate_slat)

        self.assertIn("ensure_near_on_cuda", called)

    def test_cpu_preload_is_blocking_before_launch_not_background_thread(self) -> None:
        source = APP_PATH.read_text(encoding="utf-8")
        near_launch = _get_function(_load_tree(), "_near_launch")
        called = _called_names(near_launch)

        self.assertIn("run_model_cpu_preload_blocking", called)
        self.assertNotIn("start_model_cpu_preload_thread", source)


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