tools.py

import queue
import threading
import traceback
import uuid
from typing import Any, List, Optional

import bpy
import mathutils
from smolagents import FinalAnswerTool, PythonInterpreterTool, Tool


class ToolManager:
    """Singleton manager for Blender tools that handles task queueing and execution on the main thread."""

    _instance = None
    _lock = threading.Lock()

    def __new__(cls):
        with cls._lock:
            if cls._instance is None:
                cls._instance = super(ToolManager, cls).__new__(cls)
                cls._instance._initialize()
        return cls._instance

    def _initialize(self):
        prefs = bpy.context.preferences.addons[__package__].preferences

        self._task_queue = queue.Queue()
        self._result_dict = {}
        self._condition = threading.Condition()
        self._tools = [
            PythonInterpreterTool(),
            FinalAnswerTool(),
            GetSceneInfoTool(),
            GetObjectInfoTool(),
            CreateObjectTool(),
            ModifyObjectTool(),
            DeleteObjectTool(),
            SetMaterialTool(),
        ]

        if LlamaMeshModelManager.instance().is_loaded:
            self._tools += [
                LlamaMeshGenerateTool(),
                LlamaMeshDescribeTool(),
            ]

        if prefs.enable_hyper3d:
            self._tools += [Hyper3dGenerateObjectTool()]

    @property
    def tools(self):
        return self._tools

    def add_task(self, task):
        with self._condition:
            self._task_queue.put(task)
            self._condition.notify()

    def get_result(self, task_id):
        with self._condition:
            while task_id not in self._result_dict:
                self._condition.wait()
            return self._result_dict.pop(task_id)

    def process_tasks(self, context):
        try:
            while True:
                task = self._task_queue.get_nowait()
                func = task["func"]
                params = task.get("params") or {}

                if callable(func):
                    result = func(context, **params)
                    with self._condition:
                        self._result_dict[task["id"]] = result
                        self._condition.notify_all()
                else:
                    raise ValueError(f"Task function {func} is not callable")
        except queue.Empty:
            pass

    @classmethod
    def instance(cls):
        return cls()

    @classmethod
    def reset(cls):
        cls._instance = None


class BlenderTool(Tool):
    """
    Base class for all Blender tools.

    Provides utility method to run functions on the main blender thread.
    """

    def run_main_thread_func(self, func: callable, params: dict = None) -> str:
        task_id = str(uuid.uuid4())
        task = {
            "id": task_id,
            "func": func,
            "params": params,
        }
        tool_manager = ToolManager.instance()
        tool_manager.add_task(task)
        result = tool_manager.get_result(task_id)
        if result["status"] == "error":
            return f"Error in {func.__name__}: {result['data']}"
        return result["data"]


def get_aabb(obj):
    """Returns the world-space axis-aligned bounding box (AABB) of an object."""
    if obj.type != "MESH":
        raise TypeError("Object must be a mesh")

    # Get the bounding box corners in local space
    local_bbox_corners = [mathutils.Vector(corner) for corner in obj.bound_box]

    # Convert to world coordinates
    world_bbox_corners = [obj.matrix_world @ corner for corner in local_bbox_corners]

    # Compute axis-aligned min/max coordinates
    min_corner = mathutils.Vector(map(min, zip(*world_bbox_corners)))
    max_corner = mathutils.Vector(map(max, zip(*world_bbox_corners)))

    return [
        [*min_corner],
        [*max_corner],
    ]


def get_scene_info(context: Any):
    try:
        print("Getting scene info...")
        scene_info = {
            "name": context.scene.name,
            "object_count": len(context.scene.objects),
            "objects": [],
            "materials_count": len(bpy.data.materials),
        }

        for i, obj in enumerate(context.scene.objects):
            if i >= 10:
                break

            obj_info = {
                "name": obj.name,
                "type": obj.type,
                "location": [obj.location.x, obj.location.y, obj.location.z],
            }
            scene_info["objects"].append(obj_info)

        print(f"Scene info collected: {len(scene_info['objects'])} objects")
        return {"status": "success", "data": scene_info}
    except Exception as e:
        print(f"Error in get_scene_info: {str(e)}")
        traceback.print_exc()
        return {"status": "error", "data": str(e)}


class GetSceneInfoTool(BlenderTool):
    name = "get_scene_info"
    description = """
    This is a tool that gets detailed information about the current Blender scene.

    It returns the scene name, object count, a list of objects with their names, types, and locations, and the number of materials in the scene.

    Details are only provided for the first 10 objects, but the total object count is provided.

    The output is a dictionary with the following structure:
    {
        "name": "Scene",
        "object_count": 3,
        "objects": [
            {
                "name": "Cube",
                "type": "MESH",
                "location": [1.00, 2.00, 3.00]
            },
            {
                "name": "Sphere",
                "type": "MESH",
                "location": [0.00, 0.00, 0.00]
            },
            {
                "name": "Camera",
                "type": "CAMERA",
                "location": [0.00, 0.00, 0.00]
            }
        ],
        "materials_count": 2
    }
    """
    inputs = {}
    output_type = "object"

    def forward(self):
        return self.run_main_thread_func(get_scene_info)


def get_object_info(context: Any, name: str):
    try:
        obj = bpy.data.objects.get(name)
        if not obj:
            raise ValueError(f"Object with name {name} not found")

        obj_info = {
            "name": obj.name,
            "type": obj.type,
            "location": [obj.location.x, obj.location.y, obj.location.z],
            "rotation": [
                obj.rotation_euler.x,
                obj.rotation_euler.y,
                obj.rotation_euler.z,
            ],
            "scale": [obj.scale.x, obj.scale.y, obj.scale.z],
            "visible": obj.visible_get(),
            "materials": [],
        }

        if obj.type == "MESH":
            bounding_box = get_aabb(obj)
            obj_info["world_bounding_box"] = bounding_box

        for slot in obj.material_slots:
            if slot.material:
                obj_info["materials"].append(slot.material.name)

        if obj.type == "MESH" and obj.data:
            mesh = obj.data
            obj_info["mesh"] = {
                "vertices": len(mesh.vertices),
                "edges": len(mesh.edges),
                "polygons": len(mesh.polygons),
            }

        return {"status": "success", "data": obj_info}
    except Exception as e:
        print(f"Error in get_object_info: {str(e)}")
        traceback.print_exc()
        return {"status": "error", "data": str(e)}


class GetObjectInfoTool(BlenderTool):
    name = "get_object_info"
    description = """
    This is a tool that gets detailed information about a specific object in the Blender scene.

    It returns the object name, type, location, rotation, scale, visibility, materials, and world bounding box (if applicable).

    The output is a dictionary with the following structure:
    {
        "name": "Cube",
        "type": "MESH",
        "location": [1.00, 2.00, 3.00],
        "rotation": [0.00, 0.00, 0.00],
        "scale": [1.00, 1.00, 1.00],
        "visible": True,
        "materials": ["Material1"],
        "world_bounding_box": [1.00, 2.00, 3.00, 1.00, 1.00, 1.00]
    }
    """
    inputs = {
        "name": {
            "type": "string",
            "description": "Name of the object to get information about",
        }
    }
    output_type = "object"

    def forward(self, name: str):
        return self.run_main_thread_func(get_object_info, {"name": name})


def create_object(
    context: Any,
    type: str,
    name: Optional[str] = None,
    location: List[float] = None,
    rotation: List[float] = None,
    scale: List[float] = None,
    align: Optional[str] = None,
    major_segments: Optional[int] = None,
    minor_segments: Optional[int] = None,
    mode: Optional[str] = None,
    major_radius: Optional[float] = None,
    minor_radius: Optional[float] = None,
    abso_major_rad: Optional[float] = None,
    abso_minor_rad: Optional[float] = None,
    generate_uvs: Optional[bool] = None,
):
    try:
        view_area_3d = next(
            (area for area in context.screen.areas if area.type == "VIEW_3D"), None
        )
        if view_area_3d is None:
            raise RuntimeError("View 3D area not found")

        override = context.copy()
        override["area"] = view_area_3d

        with context.temp_override(**override):
            # Deselect all objects first
            bpy.ops.object.select_all(action="DESELECT")

            location = location or [0, 0, 0]
            rotation = rotation or [0, 0, 0]
            scale = scale or [1, 1, 1]

            # Create the object based on type
            if type == "CUBE":
                bpy.ops.mesh.primitive_cube_add(
                    location=location, rotation=rotation, scale=scale
                )
            elif type == "SPHERE":
                bpy.ops.mesh.primitive_uv_sphere_add(
                    location=location, rotation=rotation, scale=scale
                )
            elif type == "CYLINDER":
                bpy.ops.mesh.primitive_cylinder_add(
                    location=location, rotation=rotation, scale=scale
                )
            elif type == "PLANE":
                bpy.ops.mesh.primitive_plane_add(
                    location=location, rotation=rotation, scale=scale
                )
            elif type == "CONE":
                bpy.ops.mesh.primitive_cone_add(
                    location=location, rotation=rotation, scale=scale
                )
            elif type == "TORUS":
                bpy.ops.mesh.primitive_torus_add(
                    align=align,
                    location=location,
                    rotation=rotation,
                    major_segments=major_segments,
                    minor_segments=minor_segments,
                    mode=mode,
                    major_radius=major_radius,
                    minor_radius=minor_radius,
                    abso_major_rad=abso_major_rad,
                    abso_minor_rad=abso_minor_rad,
                    generate_uvs=generate_uvs,
                )
            elif type == "EMPTY":
                bpy.ops.object.empty_add(
                    location=location, rotation=rotation, scale=scale
                )
            elif type == "CAMERA":
                bpy.ops.object.camera_add(location=location, rotation=rotation)
            elif type == "LIGHT":
                bpy.ops.object.light_add(
                    type="POINT",
                    location=location,
                    rotation=rotation,
                    scale=scale,
                )
            else:
                raise ValueError(f"Unsupported object type: {type}")

            # Force update the view layer
            bpy.context.view_layer.update()

            # Get the active object (which should be our newly created object)
            obj = bpy.context.view_layer.objects.active

            # If we don't have an active object, something went wrong
            if obj is None:
                raise RuntimeError("Failed to create object - no active object")

            # Make sure it's selected
            obj.select_set(True)

            # Rename if name is provided
            if name:
                obj.name = name
                if obj.data:
                    obj.data.name = name

            # Patch for PLANE: scale don't work with bpy.ops.mesh.primitive_plane_add()
            if type in {"PLANE"}:
                obj.scale = scale

            # Return the object info
            result = {
                "name": obj.name,
                "type": obj.type,
                "location": [obj.location.x, obj.location.y, obj.location.z],
                "rotation": [
                    obj.rotation_euler.x,
                    obj.rotation_euler.y,
                    obj.rotation_euler.z,
                ],
                "scale": [obj.scale.x, obj.scale.y, obj.scale.z],
            }

            if obj.type == "MESH":
                bounding_box = get_aabb(obj)
                result["world_bounding_box"] = bounding_box

            return {"status": "success", "data": result}
    except Exception as e:
        print(f"Error in create_object: {str(e)}")
        traceback.print_exc()
        return {"status": "error", "data": str(e)}


class CreateObjectTool(BlenderTool):
    name = "create_object"
    description = """
    This is a tool that creates a new object in the Blender scene.

    It returns the created object name, type, location, rotation, scale, and world bounding box (if applicable).

    The output is a dictionary with the following structure:
    {
        "name": "Cube",
        "type": "MESH",
        "location": [1.00, 2.00, 3.00],
        "rotation": [0.00, 0.00, 0.00],
        "scale": [1.00, 1.00, 1.00],
        "world_bounding_box": [1.00, 2.00, 3.00, 1.00, 1.00, 1.00]
    }
    """
    inputs = {
        "type": {
            "type": "string",
            "description": "Object type (CUBE, SPHERE, CYLINDER, PLANE, CONE, TORUS, EMPTY, CAMERA, LIGHT)",
        },
        "name": {
            "type": "string",
            "description": "Optional name for the object",
            "nullable": True,
        },
        "location": {
            "type": "array",
            "description": "Optional [x, y, z] location coordinates",
            "nullable": True,
        },
        "rotation": {
            "type": "array",
            "description": "Optional [x, y, z] rotation in radians",
            "nullable": True,
        },
        "scale": {
            "type": "array",
            "description": "Optional [x, y, z] scale factors (not used for TORUS)",
            "nullable": True,
        },
        "align": {
            "type": "string",
            "description": "How to align the torus ('WORLD', 'VIEW', or 'CURSOR')",
            "nullable": True,
        },
        "major_segments": {
            "type": "integer",
            "description": "Number of segments for the main ring",
            "nullable": True,
        },
        "minor_segments": {
            "type": "integer",
            "description": "Number of segments for the cross-section",
            "nullable": True,
        },
        "mode": {
            "type": "string",
            "description": "Dimension mode ('MAJOR_MINOR' or 'EXT_INT')",
            "nullable": True,
        },
        "major_radius": {
            "type": "number",
            "description": "Radius from the origin to the center of the cross sections",
            "nullable": True,
        },
        "minor_radius": {
            "type": "number",
            "description": "Radius of the torus' cross section",
            "nullable": True,
        },
        "abso_major_rad": {
            "type": "number",
            "description": "Total exterior radius of the torus",
            "nullable": True,
        },
        "abso_minor_rad": {
            "type": "number",
            "description": "Total interior radius of the torus",
            "nullable": True,
        },
        "generate_uvs": {
            "type": "boolean",
            "description": "Whether to generate a default UV map",
            "nullable": True,
        },
    }
    output_type = "object"

    def forward(
        self,
        type: str,
        name: Optional[str] = None,
        location: Optional[List[float]] = None,
        rotation: Optional[List[float]] = None,
        scale: Optional[List[float]] = None,
        align: Optional[str] = "WORLD",
        major_segments: Optional[int] = 48,
        minor_segments: Optional[int] = 12,
        mode: Optional[str] = "MAJOR_MINOR",
        major_radius: Optional[float] = 1.0,
        minor_radius: Optional[float] = 0.25,
        abso_major_rad: Optional[float] = 1.25,
        abso_minor_rad: Optional[float] = 1.25,
        generate_uvs: Optional[bool] = True,
    ):
        location = location or [0, 0, 0]
        rotation = rotation or [0, 0, 0]
        scale = scale or [1, 1, 1]

        params = {
            "type": type,
            "location": location,
            "rotation": rotation,
            "scale": scale,
        }

        if name:
            params["name"] = name

        if type == "TORUS":
            params.update(
                {
                    "align": align,
                    "major_segments": major_segments,
                    "minor_segments": minor_segments,
                    "mode": mode,
                    "major_radius": major_radius,
                    "minor_radius": minor_radius,
                    "abso_major_rad": abso_major_rad,
                    "abso_minor_rad": abso_minor_rad,
                    "generate_uvs": generate_uvs,
                }
            )

        return self.run_main_thread_func(create_object, params)


def modify_object(
    context: Any,
    name: str,
    location: Optional[List[float]] = None,
    rotation: Optional[List[float]] = None,
    scale: Optional[List[float]] = None,
    visible: Optional[bool] = None,
):
    try:
        view_area_3d = next(
            (area for area in context.screen.areas if area.type == "VIEW_3D"), None
        )
        if view_area_3d is None:
            raise RuntimeError("View 3D area not found")

        override = context.copy()
        override["area"] = view_area_3d

        with context.temp_override(**override):
            obj = bpy.data.objects.get(name)
            if not obj:
                raise ValueError(f"Object with name {name} not found")

            if location is not None:
                obj.location = location
            if rotation is not None:
                obj.rotation_euler = rotation
            if scale is not None:
                obj.scale = scale
            if visible is not None:
                obj.visible_set(visible)

            result = {
                "name": obj.name,
                "type": obj.type,
                "location": [obj.location.x, obj.location.y, obj.location.z],
                "rotation": [
                    obj.rotation_euler.x,
                    obj.rotation_euler.y,
                    obj.rotation_euler.z,
                ],
                "scale": [obj.scale.x, obj.scale.y, obj.scale.z],
                "visible": obj.visible_get(),
            }

            if obj.type == "MESH":
                bounding_box = get_aabb(obj)
                result["world_bounding_box"] = bounding_box

            return {"status": "success", "data": result}
    except Exception as e:
        print(f"Error in modify_object: {str(e)}")
        traceback.print_exc()
        return {"status": "error", "data": str(e)}


class ModifyObjectTool(BlenderTool):
    name = "modify_object"
    description = """
    This is a tool that modifies an existing object in the Blender scene.

    It can modify the object's location, rotation, scale, and visibility.
    
    It returns the modified object name, type, location, rotation, scale, and visibility.
    
    The output is a dictionary with the following structure:
    {
        "name": "Cube",
        "type": "MESH",
        "location": [1.00, 2.00, 3.00],
        "rotation": [0.00, 0.00, 0.00],
        "scale": [1.00, 1.00, 1.00],
        "visible": True
    }
    """
    inputs = {
        "name": {
            "type": "string",
            "description": "Name of the object to modify",
        },
        "location": {
            "type": "array",
            "description": "Optional [x, y, z] location coordinates",
            "nullable": True,
        },
        "rotation": {
            "type": "array",
            "description": "Optional [x, y, z] rotation in radians",
            "nullable": True,
        },
        "scale": {
            "type": "array",
            "description": "Optional [x, y, z] scale factors",
            "nullable": True,
        },
        "visible": {
            "type": "boolean",
            "description": "Optional visibility of the object",
            "nullable": True,
        },
    }
    output_type = "object"

    def forward(
        self,
        name: str,
        location: Optional[List[float]] = None,
        rotation: Optional[List[float]] = None,
        scale: Optional[List[float]] = None,
        visible: Optional[bool] = None,
    ):
        params = {
            "name": name,
            "location": location,
            "rotation": rotation,
            "scale": scale,
            "visible": visible,
        }
        return self.run_main_thread_func(modify_object, params)


def delete_object(context: Any, name: str) -> dict:
    try:
        view_area_3d = next(
            (area for area in context.screen.areas if area.type == "VIEW_3D"), None
        )
        if view_area_3d is None:
            raise RuntimeError("View 3D area not found")

        override = context.copy()
        override["area"] = view_area_3d

        with context.temp_override(**override):
            obj = bpy.data.objects.get(name)
            if not obj:
                raise ValueError(f"Object with name {name} not found")

            bpy.data.objects.remove(obj, do_unlink=True)
            return {"status": "success", "data": name}
    except Exception as e:
        print(f"Error in delete_object: {str(e)}")
        traceback.print_exc()
        return {"status": "error", "data": str(e)}


class DeleteObjectTool(BlenderTool):
    name = "delete_object"
    description = """
    This is a tool that deletes an existing object from the Blender scene.

    It returns the deleted object name.
    """
    inputs = {
        "name": {
            "type": "string",
            "description": "Name of the object to delete",
        }
    }
    output_type = "string"

    def forward(self, name: str):
        return self.run_main_thread_func(delete_object, {"name": name})


def set_material(
    context: Any,
    object_name: str,
    material_name: Optional[str] = None,
    create_if_missing: Optional[bool] = True,
    color: Optional[List[float]] = None,
):
    try:
        obj = bpy.data.objects.get(object_name)
        if not obj:
            raise ValueError(f"Object with name {object_name} not found")

        if not hasattr(obj, "data") or not hasattr(obj.data, "materials"):
            raise ValueError(f"Object {object_name} cannot accept materials")

        # Create or get material
        if material_name:
            mat = bpy.data.materials.get(material_name)
            if not mat and create_if_missing:
                mat = bpy.data.materials.new(name=material_name)
                print(f"Created new material: {material_name}")
        else:
            mat_name = f"{object_name}_material"
            mat = bpy.data.materials.get(mat_name)
            if not mat:
                mat = bpy.data.materials.new(name=mat_name)
            material_name = mat_name
            print(f"Using material: {material_name}")

        # Set up material nodes if needed
        if mat:
            if not mat.use_nodes:
                mat.use_nodes = True

            # Get or create Principled BSDF
            principled = mat.node_tree.nodes.get("Principled BSDF")
            if not principled:
                principled = mat.node_tree.nodes.new("ShaderNodeBsdfPrincipled")
                output = mat.node_tree.nodes.new("Material Output")
                if not output:
                    output = mat.node_tree.nodes.new("Material Output")
                if not principled.outputs[0].links:
                    mat.node_tree.links.new(principled.outputs[0], output.inputs[0])

            # Set color if provided
            if color and len(color) >= 3:
                principled.inputs["Base Color"].default_value = (
                    color[0],
                    color[1],
                    color[2],
                    1.0 if len(color) < 4 else color[3],
                )
                print(f"Set material color to {color}")

        if mat:
            if not obj.data.materials:
                obj.data.materials.append(mat)
            else:
                obj.data.materials[0] = mat

            print(f"Assigned material {mat.name} to {object_name}")

            result = {
                "object": object_name,
                "material": mat.name,
                "color": color if color else None,
            }

            return {"status": "success", "data": result}
    except Exception as e:
        print(f"Error in set_material: {str(e)}")
        traceback.print_exc()
        return {"status": "error", "data": str(e)}


class SetMaterialTool(BlenderTool):
    name = "set_material"
    description = """
    Set or create a material on an object.

    Returns the object name, material name, and color.

    The output is a dictionary with the following structure:
    {
        "object": "Cube",
        "material": "Material1",
        "color": [1.00, 0.00, 0.00, 1.00]
    }
    """
    inputs = {
        "object_name": {
            "type": "string",
            "description": "Name of the object to set the material on",
        },
        "material_name": {
            "type": "string",
            "description": "Optional name of the material to use or create",
            "nullable": True,
        },
        "create_if_missing": {
            "type": "boolean",
            "description": "Whether to create a new material if it doesn't exist",
            "nullable": True,
        },
        "color": {
            "type": "array",
            "description": "Optional [r, g, b, a] color values (0-1)",
            "nullable": True,
        },
    }
    output_type = "object"

    def forward(
        self,
        object_name: str,
        material_name: Optional[str] = None,
        create_if_missing: Optional[bool] = True,
        color: Optional[List[float]] = None,
    ):
        params = {
            "object_name": object_name,
            "material_name": material_name,
            "create_if_missing": create_if_missing,
            "color": color,
        }
        return self.run_main_thread_func(set_material, params)


class LlamaMeshModelManager:
    _instance = None
    _lock = threading.Lock()
    _model = None

    def __new__(cls):
        if cls._instance is None:
            with cls._lock:
                if cls._instance is None:
                    cls._instance = super(LlamaMeshModelManager, cls).__new__(cls)

        return cls._instance

    @property
    def is_loaded(self):
        return self._model is not None

    def load_model(self):
        if self._model is not None:
            return

        from llama_cpp import Llama

        repo_id = "bartowski/LLaMA-Mesh-GGUF"
        filename = "LLaMA-Mesh-Q4_K_M.gguf"

        self._model = Llama.from_pretrained(
            repo_id=repo_id, filename=filename, n_gpu_layers=-1, n_ctx=8192
        )

    def unload_model(self):
        if self._model is None:
            return

        import gc

        del self._model
        gc.collect()

        self._model = None

    def get_model(self):
        if not self.is_loaded:
            raise RuntimeError(
                "LLaMA-Mesh is not loaded. You are not able to use this tool."
            )
        return self._model

    @classmethod
    def instance(cls):
        return cls()


def llama_mesh_generate(context: Any, object_name: str, mesh_data: str):
    try:
        import bmesh

        view_area_3d = next(
            (area for area in context.screen.areas if area.type == "VIEW_3D"), None
        )
        if view_area_3d is None:
            raise RuntimeError("View 3D area not found")

        override = context.copy()
        override["area"] = view_area_3d

        with context.temp_override(**override):
            mesh_data_obj = bpy.data.meshes.new(object_name)
            mesh_obj = bpy.data.objects.new(object_name, mesh_data_obj)
            context.collection.objects.link(mesh_obj)
            bm = bmesh.new()

            def add_vertex(x, y, z):
                try:
                    bm.verts.new((x, y, z))
                    bm.verts.ensure_lookup_table()
                    return True
                except ValueError as e:
                    print(f"Error adding vertex: ({x}, {y}, {z}): {e}")
                    return False

            def add_face(a, b, c):
                try:
                    bm.faces.new((bm.verts[a - 1], bm.verts[b - 1], bm.verts[c - 1]))
                    bm.faces.ensure_lookup_table()
                    return True
                except IndexError as e:
                    print(f"IndexError adding face: ({a}, {b}, {c}): {e}")
                    return False
                except ValueError as e:
                    print(f"ValueError adding face: ({a}, {b}, {c}): {e}")
                    return False

            def process_line(line):
                print(line)
                line = line.strip()

                if line.startswith("v "):
                    parts = line.split()
                    if len(parts) == 4:
                        try:
                            x, y, z = map(int, parts[1:])
                            scale = 1 / 64.0
                            add_vertex(
                                x * scale - 0.5, z * scale - 0.5, y * scale - 0.5
                            )
                        except ValueError:
                            pass
                elif line.startswith("f "):
                    parts = line.split()
                    if len(parts) > 1:
                        try:
                            a, b, c = map(int, parts[1:])
                            add_face(a, b, c)
                        except ValueError:
                            pass

            for line in mesh_data.splitlines():
                process_line(line)

            bm.to_mesh(mesh_data_obj)
            mesh_data_obj.update()
            context.view_layer.update()
            bm.free()

            return {"status": "success", "data": object_name}
    except Exception as e:
        print(f"Error in generate_mesh: {str(e)}")
        traceback.print_exc()
        return {"status": "error", "data": str(e)}


class LlamaMeshGenerateTool(BlenderTool):
    name = "llama_mesh_generate"
    description = """
    Use LLaMA-Mesh to generate a 3D mesh from a description.

    This tool is capable of generating low-resolution meshes with a small number of vertices.

    Returns the name of the generated object.
    """
    inputs = {
        "object_name": {
            "type": "string",
            "description": "Name for the generated object",
        },
        "object_description": {
            "type": "string",
            "description": "A short description of the mesh to generate",
        },
        "temperature": {
            "type": "number",
            "description": "Temperature for the model from 0 to 1, where 0 is deterministic and 1 is random",
            "nullable": True,
        },
    }
    output_type = "string"

    def forward(
        self,
        object_name: str,
        object_description: str,
        temperature: Optional[float] = 0.5,
    ):
        model_manager = LlamaMeshModelManager.instance()
        model = model_manager.get_model()

        messages = [
            {
                "role": "system",
                "content": "You are a helpful assistant that can generate 3D meshes from descriptions.",
            },
            {
                "role": "user",
                "content": f"Generate an obj file for the following description: {object_description}",
            },
        ]

        response = model.create_chat_completion(
            messages=messages, stream=True, temperature=temperature
        )

        mesh_data = ""
        for chunk in response:
            try:
                content = chunk["choices"][0]["delta"].get("content", "")
                if content:
                    mesh_data += content
            except Exception as e:
                print(f"Error in process_chunk: {str(e)}")
                pass

        params = {
            "object_name": object_name,
            "mesh_data": mesh_data,
        }
        return self.run_main_thread_func(llama_mesh_generate, params)


def get_mesh_obj_data(context: Any, name: str):
    try:
        obj = bpy.data.objects.get(name)
        if not obj:
            raise ValueError(f"Object with name {name} not found")

        if not obj.type == "MESH":
            raise ValueError(f"Object with name {name} is not a mesh")

        bounding_box = get_aabb(obj)
        mesh = obj.data

        bpy.context.view_layer.objects.active = obj
        bpy.ops.object.mode_set(mode="EDIT")
        bpy.ops.mesh.quads_convert_to_tris(quad_method="BEAUTY", ngon_method="BEAUTY")
        bpy.ops.object.mode_set(mode="OBJECT")

        min_coords = bounding_box[0]
        max_coords = bounding_box[1]

        ranges = [max_coords[i] - min_coords[i] for i in range(3)]
        max_range = max(ranges)

        vertices_with_indices = []
        for i, vertex in enumerate(mesh.vertices):
            world_vertex = obj.matrix_world @ vertex.co
            quantized_vertex = [
                int((world_vertex[0] - min_coords[0]) / max_range * 63),
                int((world_vertex[2] - min_coords[2]) / max_range * 63),
                int((world_vertex[1] - min_coords[1]) / max_range * 63),
            ]
            vertices_with_indices.append((quantized_vertex, i))

        vertices_with_indices.sort(key=lambda x: (x[0][0], x[0][1], x[0][2]))

        old_to_new_indices = {
            old_idx: new_idx
            for new_idx, (_, old_idx) in enumerate(vertices_with_indices)
        }

        obj_lines = []

        for vertex in vertices_with_indices:
            v = vertex[0]
            obj_lines.append(f"v {v[0]} {v[1]} {v[2]}")

        faces = []

        for face in mesh.polygons:
            old_indices = list(face.vertices)
            new_indices = [old_to_new_indices[old_idx] for old_idx in old_indices]
            min_pos = new_indices.index(min(new_indices))
            new_indices = new_indices[min_pos:] + new_indices[:min_pos]
            faces.append(new_indices)

        faces.sort(key=lambda x: (x[0], x[1], x[2]))

        for face in faces:
            obj_lines.append(f"f {face[0] + 1} {face[1] + 1} {face[2] + 1}")

        obj_data = "\n".join(obj_lines)

        return {"status": "success", "data": obj_data}
    except Exception as e:
        print(f"Error in llama_mesh_describe: {str(e)}")
        traceback.print_exc()
        return {"status": "error", "data": str(e)}


class LlamaMeshDescribeTool(BlenderTool):
    name = "llama_mesh_describe"
    description = """
    Use LLaMA-Mesh to describe a 3D object given its mesh data.

    Only accepts objects with fewer than 800 vertices. Use `get_object_info` to check the number of vertices.

    Returns a string describing what the object is.
    """
    inputs = {
        "name": {
            "type": "string",
            "description": "Name of the object to describe",
        },
    }
    output_type = "string"

    def forward(self, name: str):
        try:
            model_manager = LlamaMeshModelManager.instance()
            model = model_manager.get_model()

            obj_data = self.run_main_thread_func(get_mesh_obj_data, {"name": name})

            messages = [
                {
                    "role": "system",
                    "content": """You are a knowledgeable, efficient, and direct AI assistant that can read 3D obj file data.
                    Provide concise answers, focusing only on key information needed.
                    """,
                },
                {
                    "role": "user",
                    "content": f"What is this object?\n{obj_data}",
                },
            ]

            response = model.create_chat_completion(
                messages=messages, stream=False, temperature=0.5
            )

            response = response["choices"][0]["message"]["content"]

            return response
        except Exception as e:
            return f"Error in llama_mesh_describe: {str(e)}"


def hyper3d_get_api_key(context: Any):
    try:
        prefs = bpy.context.preferences.addons[__package__].preferences
        return {"status": "success", "data": prefs.hyper3d_api_key}
    except Exception as e:
        return {"status": "error", "data": str(e)}


def hyper3d_run_api(api_key: str, object_description: str):
    import os
    import tempfile
    import time

    import requests

    files = [
        ("mesh_mode", (None, "Raw")),
        ("prompt", (None, object_description)),
    ]

    response = requests.post(
        "https://hyperhuman.deemos.com/api/v2/rodin",
        headers={"Authorization": f"Bearer {api_key}"},
        files=files,
    )

    data = response.json()

    succeed = data.get("submit_time", False)
    if not succeed:
        raise RuntimeError("Failed to create generate job")

    task_uuid = data["uuid"]
    subscription_key = data["jobs"]["subscription_key"]

    start_time = time.time()
    max_wait_time = 300  # 5 minutes

    print(f"Generation started. Task UUID: {task_uuid}")
    print(f"Waiting up to {max_wait_time} seconds for generation to complete...")

    while True:
        if time.time() - start_time > max_wait_time:
            raise RuntimeError(f"Generation timed out after {max_wait_time} seconds")

        response = requests.post(
            "https://hyperhuman.deemos.com/api/v2/status",
            headers={"Authorization": f"Bearer {api_key}"},
            json={"subscription_key": subscription_key},
        )

        data = response.json()
        status_list = [i["status"] for i in data["jobs"]]
        if all(status == "Done" for status in status_list):
            break

        time.sleep(2)

    print("Generation completed. Downloading result...")

    response = requests.post(
        "https://hyperhuman.deemos.com/api/v2/download",
        headers={"Authorization": f"Bearer {api_key}"},
        json={"task_uuid": task_uuid},
    )

    data = response.json()
    temp_file = None

    for i in data["list"]:
        if i["name"].endswith(".glb"):
            temp_file = tempfile.NamedTemporaryFile(
                delete=False,
                prefix=task_uuid,
                suffix=".glb",
            )

            try:
                response = requests.get(i["url"], stream=True)
                response.raise_for_status()

                for chunk in response.iter_content(chunk_size=8192):
                    temp_file.write(chunk)

                temp_file.close()
            except Exception as e:
                temp_file.close()
                os.unlink(temp_file.name)
                raise e

    return temp_file.name


def hyper3d_generate_object(context: Any, filepath: str, mesh_name: str):
    try:
        existing_objects = set(bpy.data.objects)
        bpy.ops.import_scene.gltf(filepath=filepath)
        bpy.context.view_layer.update()

        imported_objects = list(set(bpy.data.objects) - existing_objects)

        if not imported_objects:
            raise RuntimeError("Error: No objects were imported.")

        mesh_obj = None

        if len(imported_objects) == 1 and imported_objects[0].type == "MESH":
            mesh_obj = imported_objects[0]
            print("Single mesh imported, no cleanup needed.")
        else:
            parent_obj = imported_objects[0]
            if parent_obj.type == "EMPTY" and len(parent_obj.children) == 1:
                potential_mesh = parent_obj.children[0]
                if potential_mesh.type == "MESH":
                    print("GLB structure confirmed: Empty node with one mesh child.")
                    potential_mesh.parent = None

                    bpy.data.objects.remove(parent_obj)
                    print("Removed empty node, keeping only the mesh.")
                    mesh_obj = potential_mesh
                else:
                    raise RuntimeError("Error: Child is not a mesh object.")
            else:
                raise RuntimeError(
                    "Error: Expected an empty node with one mesh child or a single mesh object."
                )

        try:
            if mesh_obj and mesh_obj.name is not None and mesh_name:
                mesh_obj.name = mesh_name
                if mesh_obj.data.name is not None:
                    mesh_obj.data.name = mesh_name
                print(f"Mesh renamed to: {mesh_name}")
        except Exception:
            print("Having issue with renaming, give up renaming.")
        result = {
            "name": mesh_obj.name,
            "type": mesh_obj.type,
            "location": [mesh_obj.location.x, mesh_obj.location.y, mesh_obj.location.z],
            "rotation": [
                mesh_obj.rotation_euler.x,
                mesh_obj.rotation_euler.y,
                mesh_obj.rotation_euler.z,
            ],
            "scale": [mesh_obj.scale.x, mesh_obj.scale.y, mesh_obj.scale.z],
        }

        if mesh_obj.type == "MESH":
            bounding_box = get_aabb(mesh_obj)
            result["world_bounding_box"] = bounding_box

        return {"status": "success", "data": result}
    except Exception as e:
        print(f"Error in hyper3d_generate: {str(e)}")
        traceback.print_exc()
        return {"status": "error", "data": str(e)}


class Hyper3dGenerateObjectTool(BlenderTool):
    name = "hyper3d_generate_object"
    description = """
    Generate a 3D asset using Hyper3D by giving a description of the desired asset, then import the result into Blender.
    The 3D asset has built-in materials.    
    The generated model has a normalized size, so re-scaling after generation may be useful.

    Hyper3D is good at generating 3D models for a single item.
    Don't try to:
    1. Generate the whole scene at once.
    2. Generate terrain.
    3. Generate parts of the item separately and put them together.
    """
    inputs = {
        "object_description": {
            "type": "string",
            "description": "A short description of the object to generate",
        },
        "mesh_name": {
            "type": "string",
            "description": "Name of the mesh to generate",
        },
    }
    output_type = "object"

    def forward(self, object_description: str, mesh_name: str):
        try:
            api_key = self.run_main_thread_func(hyper3d_get_api_key)
            filepath = hyper3d_run_api(api_key, object_description)
            return self.run_main_thread_func(
                hyper3d_generate_object,
                {"filepath": filepath, "mesh_name": mesh_name},
            )
        except Exception as e:
            return f"Error in hyper3d_generate_object: {str(e)}"