import importlib
import os
import queue
import re

import bpy
import bpy_types
import mathutils

# import time # for debugging performance

# then import dependencies for our addon
if "Font" in locals():
    importlib.reload(Font)
else:
    from .common import Font

if "utils" in locals():
    importlib.reload(utils)
else:
    from .common import utils

execution_queue = queue.Queue()
lock_depsgraph_update_n_times = -1


# This function can safely be called in another thread.
# The function will be executed when the timer runs the next time.
def run_in_main_thread(function):
    execution_queue.put(function)


def execute_queued_functions():
    while not execution_queue.empty():
        function = execution_queue.get()
        function()
    return 1.0


def apply_all_transforms(obj):
    mb = obj.matrix_basis
    if hasattr(obj.data, "transform"):
        obj.data.transform(mb)
    for c in obj.children:
        c.matrix_local = mb @ c.matrix_local
    obj.matrix_basis.identity()


# broken
# def get_parent_collection_names(collection, parent_names):
#     for parent_collection in bpy.data.collections:
#         if collection.name in parent_collection.children.keys():
#             parent_names.append(parent_collection.name)
#             get_parent_collection_names(parent_collection, parent_names)
#             return


def get_key(key):
    return f"{utils.prefix()}_{key}"


# Ensure it's a curve object
# TODO: no raising, please
def get_curve_length(curve_obj, resolution=-1):
    total_length = 0

    curve = curve_obj.data

    # Loop through all splines in the curve
    for spline in curve.splines:
        total_length = total_length + spline.calc_length(resolution=resolution)

    return total_length


def get_curve_line_lengths(curve_obj, resolution=-1):
    lengths = []
    for spline in curve_obj.data.splines:
        lengths.append(spline.calc_length(resolution=resolution))
    return lengths


def get_next_line_advance(
    curve_obj, current_advance, previous_glyph_advance, resolution=-1
):
    curve_line_lengths = get_curve_line_lengths(curve_obj, resolution)
    total_length = 0
    for cll in curve_line_lengths:
        total_length += cll
        if current_advance - previous_glyph_advance < total_length:
            return total_length
    return current_advance


def calc_point_on_bezier(bezier_point_1, bezier_point_2, t):
    p1 = bezier_point_1.co
    h1 = bezier_point_1.handle_right
    p2 = bezier_point_2.co
    h2 = bezier_point_2.handle_left
    if p1 == h1 and p2 == h2:
        return p1 + t * (p2 - p1)
    return (
        ((1 - t) ** 3) * p1
        + (3 * t * (1 - t) ** 2) * h1
        + (3 * (t**2) * (1 - t)) * h2
        + (t**3) * p2
    )


# same in slightly more lines
# result is equal, performance minimally better perhaps?
# def calc_point_on_bezier(bezier_point_1, bezier_point_2, ratio):
# startPoint = bezier_point_1.co
# controlPoint1 = bezier_point_1.handle_right
# controlPoint2 = bezier_point_2.handle_left
# endPoint = bezier_point_2.co

# remainder = 1 - ratio
# ratioSquared = ratio * ratio
# remainderSquared = remainder * remainder
# startPointMultiplier = remainderSquared * remainder
# controlPoint1Multiplier = remainderSquared * ratio * 3
# controlPoint2Multiplier = ratioSquared * remainder * 3
# endPointMultiplier = ratioSquared * ratio

# return startPoint * startPointMultiplier + controlPoint1 * controlPoint1Multiplier + controlPoint2 * controlPoint2Multiplier + endPoint * endPointMultiplier


def calc_tangent_on_bezier(bezier_point_1, bezier_point_2, t):
    p1 = bezier_point_1.co
    h1 = bezier_point_1.handle_right
    p2 = bezier_point_2.co
    h2 = bezier_point_2.handle_left
    if p1 == h1 and p2 == h2:
        return (p2 - p1).normalized()
    return (
        (-3 * (1 - t) ** 2) * p1
        + (-6 * t * (1 - t) + 3 * (1 - t) ** 2) * h1
        + (-3 * (t**2) + 6 * t * (1 - t)) * h2
        + (3 * t**2) * p2
    ).normalized()


# class TestCalcPoint():
# co: mathutils.Vector
# handle_left: mathutils.Vector
# handle_right: mathutils.Vector
# def __init__(self, co, handle_left=None, handle_right=None):
# self.co = co
# if handle_left is not None:
# self.handle_left = handle_left
# if handle_right is not None:
# self.handle_right = handle_right


# a = TestCalcPoint(mathutils.Vector((0,0,0)), handle_right=mathutils.Vector((0,1,0)))
# b = TestCalcPoint(mathutils.Vector((1,0,0)), handle_left=mathutils.Vector((1,1,0)))
# c = TestCalcPoint(mathutils.Vector((0,0,0)), handle_right=mathutils.Vector((0,0,0)))
# d = TestCalcPoint(mathutils.Vector((1,0,0)), handle_left=mathutils.Vector((1,0,0)))
# calc_point_on_bezier(a,b,0.5)


def align_rotations_auto_pivot(
    mask, input_rotations, vectors, factors, local_main_axis
):
    output_rotations = [
        mathutils.Matrix().to_3x3() for _ in range(len(input_rotations))
    ]

    for i in mask:
        vector = mathutils.Vector(vectors[i]).normalized()
        input_rotation = mathutils.Euler(input_rotations[i])

        if vector.length < 1e-6:
            output_rotations[i] = input_rotation.to_matrix()
            continue

        old_rotation = input_rotation.to_matrix()
        old_axis = (old_rotation @ local_main_axis).normalized()
        new_axis = vector
        # rotation_axis = (-(old_axis) + new_axis).normalized()
        rotation_axis = old_axis.cross(new_axis).normalized()

        if rotation_axis.length < 1e-6:
            # Vectors are linearly dependent, fallback to another axis
            rotation_axis = (old_axis + mathutils.Matrix().to_3x3().col[2]).normalized()

            if rotation_axis.length < 1e-6:
                # This is now guaranteed to not be zero
                rotation_axis = (
                    -(old_axis) + mathutils.Matrix().to_3x3().col[1]
                ).normalized()

        # full_angle = radians(sqrt((4 * pow(input_rotation.to_quaternion().dot(mathutils.Quaternion(vectors[i].normalized())), 2) - 3)))
        # dot = old_axis.dot(new_axis)
        # normalized_diff = (old_axis - new_axis).normalized()
        # full_angle = acos(min((old_axis * new_axis + normalized_diff.dot(2)).length, 1))
        full_angle = old_axis.angle(new_axis)
        angle = factors[i] * full_angle

        rotation = mathutils.Quaternion(rotation_axis, angle).to_matrix()
        new_rotation_matrix = old_rotation @ rotation
        output_rotations[i] = new_rotation_matrix

    return [mat.to_4x4() for mat in output_rotations]


def calc_bezier_length(bezier_point_1, bezier_point_2, resolution=20):
    step = 1 / resolution
    previous_p = bezier_point_1.co
    length = 0
    for i in range(-1, resolution):
        t = (i + 1) * step
        p = calc_point_on_bezier(bezier_point_1, bezier_point_2, t)
        length += (p - previous_p).length
        previous_p = p
    return length


def get_hook_modifiers(blender_object: bpy.types.Object):
    return [m for m in blender_object.modifiers if m.type == "HOOK"]


class BezierSplinePoint:
    def __init__(
        self,
        co: mathutils.Vector,
        handle_left: mathutils.Vector,
        handle_right: mathutils.Vector,
    ):
        self.co: mathutils.Vector = co
        self.handle_left: mathutils.Vector = handle_left
        self.handle_right: mathutils.Vector = handle_right


class BezierSpline:
    def __init__(
        self,
        n: int,
        use_cyclic_u: bool,
        resolution_u: int,
    ):
        self.bezier_points = [BezierSplinePoint] * n
        self.use_cyclic_u: int = use_cyclic_u
        self.resolution_u: int = resolution_u
        self.beziers: []
        self.lengths: [float]
        self.total_length: float

    def calc_length(self, resolution) -> float:
        # ignore resolution when accessing length to imitate blender function
        print(f"{self.total_length=}")
        return self.total_length


class BezierData:
    def __init__(self, n):
        self.splines = [BezierSpline] * n


class BezierCurve:
    def __init__(self, blender_curve: bpy.types.Object, resolution_factor=1.0):
        self.data = BezierData(len(blender_curve.data.splines))
        i = 0
        hooks = get_hook_modifiers(blender_curve)
        print(f"{blender_curve.name=} =============================================")
        for si, blender_spline in enumerate(blender_curve.data.splines):
            self.data.splines[si] = BezierSpline(
                len(blender_spline.bezier_points),
                blender_spline.use_cyclic_u,
                blender_spline.resolution_u,
            )
            for pi, blender_bezier_point in enumerate(blender_spline.bezier_points):
                self.data.splines[si].bezier_points[pi] = BezierSplinePoint(
                    blender_bezier_point.co,
                    blender_bezier_point.handle_left,
                    blender_bezier_point.handle_right,
                )
                print(pi)
                for hook in hooks:
                    hook_co = False
                    hook_handle_left = False
                    hook_handle_right = False
                    for vi in hook.vertex_indices:
                        if vi == i * 3:
                            hook_handle_left = True
                        elif vi == i * 3 + 1:
                            hook_co = True
                        elif vi == i * 3 + 2:
                            hook_handle_right = True
                    if hook_co:
                        location = (
                            blender_curve.matrix_world.inverted()
                            @ hook.object.matrix_world.translation
                        )
                        print(f"co           {location=}")
                        self.data.splines[si].bezier_points[pi].co = (
                            self.data.splines[si]
                            .bezier_points[pi]
                            .co.lerp(location, hook.strength)
                        )
                    # if hook_handle_left:
                    #     location = (
                    #         hook.object.matrix_world.translation
                    #         - blender_curve.matrix_world.translation
                    #     ) + mathutils.Vector((-1, 0, 0))
                    #     print(f"handle_left  {location=}")
                    #     self.data.splines[si].bezier_points[pi].handle_left = (
                    #         self.data.splines[si]
                    #         .bezier_points[pi]
                    #         .handle_left.lerp(location, hook.strength)
                    #     )
                    # if hook_handle_right:
                    #     location = (
                    #         hook.object.matrix_world.translation
                    #         - blender_curve.matrix_world.translation
                    #     )
                    #     self.data.splines[si].bezier_points[pi].handle_right = (
                    #         self.data.splines[si]
                    #         .bezier_points[pi]
                    #         .handle_right.lerp(location, hook.strength)
                    #     )
                i += 1
            (
                self.data.splines[si].beziers,
                self.data.splines[si].lengths,
                self.data.splines[si].total_length,
            ) = get_real_beziers_and_lengths(self.data.splines[si], resolution_factor)
            print(f"total length {self.data.splines[si].total_length}")


def get_real_beziers_and_lengths(bezier_spline_obj, resolution_factor):
    beziers = []
    lengths = []
    total_length = 0
    n_bezier_points = len(bezier_spline_obj.bezier_points)
    real_n_bezier_points = len(bezier_spline_obj.bezier_points)
    if bezier_spline_obj.use_cyclic_u:
        n_bezier_points += 1
    for i in range(0, n_bezier_points - 1):
        i_a = i % (n_bezier_points - 1)
        i_b = (i_a + 1) % real_n_bezier_points
        bezier = [
            bezier_spline_obj.bezier_points[i_a],
            bezier_spline_obj.bezier_points[i_b],
        ]
        length = calc_bezier_length(
            bezier[0],
            bezier[1],
            int(bezier_spline_obj.resolution_u * resolution_factor),
        )
        total_length += length
        beziers.append(bezier)
        lengths.append(length)
        # if total_length > distance:
        # break
    return beziers, lengths, total_length


def calc_point_on_bezier_spline(
    bezier_spline_obj, distance, output_tangent=False, resolution_factor=1.0
):
    # what's the point of just one point
    # assert len(bezier_spline_obj.bezier_points) >= 2
    # however, maybe let's have it not crash and do this
    if len(bezier_spline_obj.bezier_points) < 1:
        print(
            f"{utils.prefix()}::butils::calc_point_on_bezier_spline: whoops, no points. panicking. return 0,0,0"
        )
        if output_tangent:
            return mathutils.Vector((0, 0, 0)), mathutils.Vector((1, 0, 0))
        else:
            return mathutils.Vector((0, 0, 0))
    if len(bezier_spline_obj.bezier_points) == 1:
        p = bezier_spline_obj.bezier_points[0]
        travel = (p.handle_left - p.co).normalized() * distance
        if output_tangent:
            tangent = mathutils.Vector((1, 0, 0))
            return travel, tangent
        else:
            return travel

    if distance <= 0:
        p = bezier_spline_obj.bezier_points[0]
        travel = (p.co - p.handle_left).normalized() * distance

        # in case the handles sit on the points
        # we interpolate the travel from points of the bezier
        # if the bezier points sit on each other we have same issue
        # but that is then to be fixed in the bezier
        if p.handle_left == p.co and len(bezier_spline_obj.bezier_points) > 1:
            beziers, lengths, total_length = (
                get_real_beziers_and_lengths(bezier_spline_obj, resolution_factor)
                if not isinstance(bezier_spline_obj, BezierSpline)
                else (
                    bezier_spline_obj.beziers,
                    bezier_spline_obj.lengths,
                    bezier_spline_obj.total_length,
                )
            )
            travel_point = calc_point_on_bezier(beziers[0][1], beziers[0][0], 0.001)
            travel = travel_point.normalized() * distance

        location = p.co + travel
        if output_tangent:
            p2 = bezier_spline_obj.bezier_points[1]
            tangent = calc_tangent_on_bezier(p, p2, 0)
            return location, tangent
        else:
            return location

    beziers, lengths, total_length = (
        get_real_beziers_and_lengths(bezier_spline_obj, resolution_factor)
        if not isinstance(bezier_spline_obj, BezierSpline)
        else (
            bezier_spline_obj.beziers,
            bezier_spline_obj.lengths,
            bezier_spline_obj.total_length,
        )
    )

    iterated_distance = 0
    for i in range(0, len(beziers)):
        if iterated_distance + lengths[i] > distance:
            distance_on_bezier = distance - iterated_distance
            d = distance_on_bezier / lengths[i]
            # print(f"i: {i}, d: {d}, distance_on_bezier: {distance_on_bezier}, distance: {distance}")
            location = calc_point_on_bezier(beziers[i][0], beziers[i][1], d)
            if output_tangent:
                tangent = calc_tangent_on_bezier(beziers[i][0], beziers[i][1], d)
                return location, tangent
            else:
                return location
        iterated_distance += lengths[i]
    # if we are here, the point is outside the spline
    last_i = len(beziers) - 1
    p = beziers[last_i][1]

    travel = (p.handle_right - p.co).normalized() * (distance - total_length)

    # in case the handles sit on the points
    # we interpolate the travel from points of the bezier
    # if the bezier points sit on each other we have same issue
    # but that is then to be fixed in the bezier
    if p.handle_right == p.co and len(beziers) > 0:
        travel_point = calc_point_on_bezier(beziers[-1][1], beziers[-1][0], 0.001)
        travel = travel_point.normalized() * (distance - total_length)
    location = p.co + travel
    if output_tangent:
        tangent = calc_tangent_on_bezier(beziers[last_i][0], p, 1)
        return location, tangent
    else:
        return location


def calc_point_on_bezier_curve(
    bezier_curve_obj,
    distance,
    output_tangent=False,
    output_spline_index=False,
    resolution_factor=1.0,
):
    # bezier_curve = BezierCurve(bezier_curve_obj)
    # curve = bezier_curve.data
    curve = bezier_curve_obj.data

    # Loop through all splines in the curve
    total_length = 0
    for i, spline in enumerate(curve.splines):
        resolution = int(spline.resolution_u * resolution_factor)
        length = spline.calc_length(resolution=resolution)
        print(f"{utils.LINE()} {length=}")
        if total_length + length > distance or i == len(curve.splines) - 1:
            if output_spline_index and output_tangent:
                # return value from c_p_o_b_s is a tuple
                # so we need to append tuple + tuple
                return calc_point_on_bezier_spline(
                    spline, (distance - total_length), output_tangent, resolution_factor
                ) + (i,)
            if output_spline_index and not output_tangent:
                # return value from c_p_o_b_s is a location vector
                # so we need to append with a comma
                return (
                    calc_point_on_bezier_spline(
                        spline,
                        (distance - total_length),
                        output_tangent,
                        resolution_factor,
                    ),
                    i,
                )
            else:
                return calc_point_on_bezier_spline(
                    spline, (distance - total_length), output_tangent, resolution_factor
                )
        total_length += length

    # NOTE: this is a fallback
    # and should not happen usually
    return bezier_curve_obj.matrix_world @ mathutils.Vector((distance, 0, 0))


# def get_objects_by_name(name, startswith="", endswith=""):
# return [obj for obj in bpy.context.scene.objects if obj.name.startswith(startswith) and if obj.name.endswith(endswith)]


def find_objects_by_name(objects, equals="", contains="", startswith="", endswith=""):
    # handle equals
    if equals != "":
        index = objects.find(equals)
        if index >= 0:
            return [objects[index]]
        return []
    # handle others is more permissive
    return [
        obj
        for obj in objects
        if obj.name.startswith(startswith)
        and obj.name.endswith(endswith)
        and obj.name.find(contains) >= 0
    ]


def find_objects_by_custom_property(objects, property_name="", property_value=""):
    return [
        obj
        for obj in objects
        if property_name in obj and obj[property_name] == property_value
    ]


# not verified
# def turn_collection_hierarchy_into_path(obj):
#     parent_collection = obj.users_collection[0]
#     parent_names = []
#     parent_names.append(parent_collection.name)
#     get_parent_collection_names(parent_collection, parent_names)
#     parent_names.reverse()
#     return "\\".join(parent_names)


def find_font_object(fontcollection, font_name):
    fonts = find_objects_by_custom_property(fontcollection.objects, "is_font", True)
    for font in fonts:
        if font["font_name"] == font_name and font.parent is None:
            return font
    return None


def find_font_face_object(font_obj, face_name):
    faces = find_objects_by_custom_property(font_obj.children, "is_face", True)
    for face in faces:
        if face["face_name"] == face_name:
            return face
    return None


def move_in_fontcollection(obj, fontcollection, allow_duplicates=False):
    # parent nesting structure
    # the font object
    font_obj = find_font_object(fontcollection, obj["font_name"])
    if font_obj is None:
        font_obj = bpy.data.objects.new(obj["font_name"], None)
        font_obj.empty_display_type = "PLAIN_AXES"
        fontcollection.objects.link(font_obj)

    # ensure custom properties are set
    font_obj["font_name"] = obj["font_name"]
    font_obj["is_font"] = True

    # the face object as a child of font object
    face_obj = find_font_face_object(font_obj, obj["face_name"])
    if face_obj is None:
        face_obj = bpy.data.objects.new(obj["face_name"], None)
        face_obj.empty_display_type = "PLAIN_AXES"
        face_obj["is_face"] = True
        fontcollection.objects.link(face_obj)

    # ensure custom properties are set
    face_obj["face_name"] = obj["face_name"]
    face_obj["font_name"] = obj["font_name"]

    if face_obj.parent != font_obj:
        face_obj.parent = font_obj

    # create glyphs if it does not exist
    glyphs_objs = find_objects_by_name(face_obj.children, startswith="glyphs")
    if len(glyphs_objs) <= 0:
        glyphs_obj = bpy.data.objects.new("glyphs", None)
        glyphs_obj.empty_display_type = "PLAIN_AXES"
        fontcollection.objects.link(glyphs_obj)
        glyphs_obj.parent = face_obj
    elif len(glyphs_objs) > 1:
        print(
            f"{utils.prefix()}::move_in_fontcollection: found more glyphs objects than expected"
        )

    # now it must exist
    glyphs_obj = find_objects_by_name(face_obj.children, startswith="glyphs")[0]
    glyphs_obj["face_name"] = obj["face_name"]
    glyphs_obj["font_name"] = obj["font_name"]

    def get_hash(o):
        return hash(tuple(tuple(v.co) for v in o.data.vertices))

    for other_obj in find_objects_by_custom_property(
        glyphs_obj.children, "glyph", obj["glyph"]
    ):
        if get_hash(other_obj) == get_hash(obj) and not allow_duplicates:
            return other_obj

    # and now parent it!
    if obj.parent != glyphs_obj:
        obj.parent = glyphs_obj

    for c in obj.users_collection:
        c.objects.unlink(obj)
    if fontcollection.objects.find(obj.name) < 0:
        fontcollection.objects.link(obj)

    return obj


def bpy_to_abspath(blender_path):
    return os.path.realpath(bpy.path.abspath(blender_path))


def register_font_from_filepath(filepath):
    from .bimport import get_font_faces_in_file

    availables = get_font_faces_in_file(filepath)

    fonts = {}
    for a in availables:
        font_name = a["font_name"]
        face_name = a["face_name"]
        glyph = a["glyph"]
        if font_name not in fonts:
            fonts[font_name] = {}
        if face_name not in fonts[font_name]:
            fonts[font_name][face_name] = []
        fonts[font_name][face_name].append(glyph)
    for font_name in fonts:
        for face_name in fonts[font_name]:
            Font.register_font(
                font_name, face_name, fonts[font_name][face_name], filepath
            )


def load_font_from_filepath(filepath, glyphs="", font_name="", face_name=""):
    if not filepath.endswith(".glb") and not filepath.endswith(".gltf"):
        ShowMessageBox(
            "Font loading error",
            "ERROR",
            f"Filepath({filepath}) is not a *.glb or *.gltf file",
        )
        return False

    marker_property = "font_import"
    bpy.ops.abc3d.import_font_gltf(
        filepath=filepath,
        glyphs=glyphs,
        marker_property=marker_property,
        font_name=font_name,
        face_name=face_name,
    )

    fontcollection = bpy.data.collections.get("ABC3D")
    if fontcollection is None:
        fontcollection = bpy.data.collections.new("ABC3D")

    modified_font_faces = []
    all_glyph_os = []

    for o in bpy.context.scene.objects:
        if marker_property in o:
            if "type" in o and o["type"] == "glyph":
                all_glyph_os.append(o)

    for o in all_glyph_os:
        glyph_id = o["glyph"]
        font_name = o["font_name"]
        face_name = o["face_name"]

        glyph_obj = move_in_fontcollection(o, fontcollection)
        glyph_obj_pointer = bpy.types.PointerProperty(glyph_obj)

        if glyph_obj == o:
            del o[marker_property]

        Font.add_glyph(font_name, face_name, glyph_id, glyph_obj_pointer)
        for c in o.children:
            if is_metrics_object(c):
                add_metrics_obj_from_bound_box(
                    glyph_obj, bound_box_as_array(c.bound_box)
                )
        modified_font_faces.append({"font_name": font_name, "face_name": face_name})

    for mff in modified_font_faces:
        mff_glyphs = []
        face: Font.FontFace = Font.get_font_face(mff["font_name"], mff["face_name"])
        if face is None:
            print(
                f"{utils.prefix()}::load_font_from_path({filepath=}, {glyphs=}, {font_name=}, {face_name=}) failed"
            )
            print(
                f"{utils.prefix()}::                   modified font face {mff=} could not be accessed."
            )
            continue
        # iterate glyphs
        for g in face.glyphs:
            # iterate alternates
            for glyph in face.glyphs[g]:
                mff_glyphs.append(get_original(glyph))
        if len(mff_glyphs) > 0:
            add_default_metrics_to_objects(mff_glyphs)
            # calculate unit factor
            h = get_glyph_height(mff_glyphs[0])
            if h != 0:
                face.unit_factor = 1 / h

    update_available_fonts()
    remove_list = []
    for o in bpy.context.scene.collection.all_objects:
        if o.name not in fontcollection.all_objects:
            if marker_property in o and o[marker_property] == True:
                remove_list.append(o)

    simply_delete_objects(remove_list)

    # completely_delete_objects(remove_list)


def is_glyph_used(glyph_alternates):
    fontcollection: bpy_types.Collection = bpy.data.collections.get("ABC3D")
    glyph = bpy.types.PointerProperty
    for glyph in glyph_alternates:
        for o in bpy.context.scene.objects:
            # only check other glyphs
            if is_glyph_object(o):
                # then attempt to compare properties
                if (
                    get_key("font_name") in o
                    and get_key("face_name") in o
                    and get_key("glyph_id") in o
                    and o[get_key("font_name")] == glyph["font_name"]
                    and o[get_key("face_name")] == glyph["face_name"]
                    and o[get_key("glyph_id")] == glyph["glyph"]
                ):
                    # following check is not necessary,
                    # but we leave it in for backwards compatibility
                    # properties in the fontcollection start with prefix
                    # and so they should be caught by previous check
                    if fontcollection.users == 0 or not (
                        fontcollection in o.users_collection
                        and len(o.users_collection) <= 1
                    ):
                        # it's in the scene and has the correct properties
                        # it is used
                        return True
            # following check is possibly overkill
            # but we also check for objects that use the data
            # and are not glyph objects, in that case we don't pull the data
            # from under their feet
            if is_mesh(o) and o.data == glyph.data:
                # in this case, yes we need to check if it is a glyph in the fontcollection
                if fontcollection.users == 0 or not (
                    fontcollection in o.users_collection
                    and len(o.users_collection) <= 1
                ):
                    # bam!
                    return True
    # whoosh!
    return False


def clean_text_properties():
    abc3d_data = bpy.context.scene.abc3d_data
    remove_these = []
    for i, text_properties in enumerate(abc3d_data.available_texts):
        if len(text_properties.text_object.users_collection) <= 0:
            remove_these.append(i)
    remove_these.reverse()
    for i in remove_these:
        abc3d_data.available_texts.remove(i)


def clean_fontcollection(fontcollection=None):
    if fontcollection is None:
        fontcollection = bpy.data.collections.get("ABC3D")
    if fontcollection is None:
        print(
            f"{utils.prefix()}::clean_fontcollection: failed because fontcollection is none"
        )
        return False

    collection_fonts = find_objects_by_custom_property(
        fontcollection.all_objects, "is_font", True
    )

    delete_these_fonts = []
    delete_these_font_faces = []
    delete_these_glyph_moms = []
    for font_and_face in Font.get_loaded_fonts_and_faces():
        font_name = font_and_face[0]
        face_name = font_and_face[1]

        collection_font_list = find_objects_by_custom_property(
            collection_fonts, "font_name", font_name
        )
        for collection_font in collection_font_list:
            collection_font_face_list = find_objects_by_custom_property(
                collection_font.children, "face_name", face_name
            )
            count_font_faces = 0
            for collection_font_face in collection_font_face_list:
                glyphs_mom_list = find_objects_by_name(
                    collection_font_face.children, startswith="glyphs"
                )
                count_glyphs_moms = 0
                for glyphs_mom in glyphs_mom_list:
                    if len(glyphs_mom.children) == 0:
                        delete_these_glyph_moms.append(glyphs_mom)
                        count_glyphs_moms += 1
                if len(collection_font_face.children) == count_glyphs_moms:
                    delete_these_font_faces.append(collection_font_face)
                    count_font_faces += 1
            if len(collection_font.children) == count_font_faces:
                delete_these_fonts.append(collection_font)

    completely_delete_objects(delete_these_glyph_moms)
    completely_delete_objects(delete_these_font_faces)
    completely_delete_objects(delete_these_fonts)


def unload_unused_glyph(font_name, face_name, glyph_id, do_clean_fontcollection=True):
    fontcollection: bpy_types.Collection = bpy.data.collections.get("ABC3D")
    glyph_variations = Font.get_glyphs(font_name, face_name, glyph_id)
    if is_glyph_used(glyph_variations):
        return False

    delete_these = []
    for glyph_pointer in glyph_variations:
        for o in fontcollection.all_objects:
            if (
                is_glyph_object(o)
                and o["font_name"] == font_name
                and o["face_name"] == face_name
                and o["glyph"] == glyph_id
            ):
                if len(o.users_collection) <= 1:
                    delete_these.append(o)
    completely_delete_objects(delete_these)

    Font.unloaded_glyph(font_name, face_name, glyph_id)
    if do_clean_fontcollection:
        clean_fontcollection(fontcollection)
    return True


def unload_unused_glyphs(do_clean_fontcollection=True):
    fontcollection: bpy_types.Collection = bpy.data.collections.get("ABC3D")
    if fontcollection is not None:
        for font_and_face in Font.get_loaded_fonts_and_faces():
            font_name = font_and_face[0]
            face_name = font_and_face[1]
            face: Font.FontFace | None = Font.get_font_face(font_name, face_name)
            if face is None:
                print(
                    f"{utils.prefix()}::unload_unused_glyphs: face is None {font_name=} {face_name=}"
                )
                continue
            unloaded_these = []
            for glyph_id in face.loaded_glyphs.copy():
                unload_unused_glyph(
                    font_name, face_name, glyph_id, do_clean_fontcollection=False
                )
    if do_clean_fontcollection:
        clean_fontcollection(fontcollection)


def update_available_fonts():
    abc3d_data = bpy.context.scene.abc3d_data

    for font_and_face in Font.get_loaded_fonts_and_faces():
        found = False
        font_name = font_and_face[0]
        face_name = font_and_face[1]
        for f in abc3d_data.available_fonts.values():
            if font_name == f.font_name and face_name == f.face_name:
                found = True
        if not found:
            f = abc3d_data.available_fonts.add()
            f.font_name = font_name
            f.face_name = face_name
            print(
                f"{utils.prefix()}::update_available_fonts: {__name__} added {font_name} {face_name}"
            )


# def update_available_texts():
# abc3d_data = bpy.context.scene.abc3d_data
# for o in bpy.context.scene.objects:
# if "text_id" in o.keys():
# i = o["text_id"]
# found = False
# if len(abc3d_data.available_texts) > i:
# if abc3d_data.available_texts[i].glyphs


def getPreferences(context):
    preferences = context.preferences
    return preferences.addons["abc3d"].preferences


# clear available fonts
def clear_available_fonts():
    bpy.context.scene.abc3d_data.available_fonts.clear()


def load_installed_fonts():
    preferences = getPreferences(bpy.context)
    font_dir = os.path.join(preferences.assets_dir, "fonts")
    if os.path.exists(font_dir):
        for file in os.listdir(font_dir):
            if file.endswith(".glb") or file.endswith(".gltf"):
                font_path = os.path.join(font_dir, file)
                # ShowMessageBox("Loading Font", "INFO", f"loading font from {font_path}")
                # print(f"loading font from {font_path}")
                # for f in bpy.context.scene.abc3d_data.available_fonts.values():
                # print(f"available font: {f.font_name} {f.face_name}")
                register_font_from_filepath(font_path)
                load_font_from_filepath(font_path)


def register_installed_fonts():
    preferences = getPreferences(bpy.context)
    font_dir = os.path.join(preferences.assets_dir, "fonts")
    if os.path.exists(font_dir):
        for file in os.listdir(font_dir):
            if file.endswith(".glb") or file.endswith(".gltf"):
                font_path = os.path.join(font_dir, file)
                # ShowMessageBox("Loading Font", "INFO", f"loading font from {font_path}")
                # print(f"loading font from {font_path}")
                # for f in bpy.context.scene.abc3d_data.available_fonts.values():
                # print(f"available font: {f.font_name} {f.face_name}")
                register_font_from_filepath(font_path)


message_memory = []


def ShowMessageBox(title="Message Box", icon="INFO", message="", prevent_repeat=False):
    """Show a simple message box

    taken from `Link here <https://blender.stackexchange.com/questions/169844/multi-line-text-box-with-popup-menu>`_

    :param title: The title shown in the message top bar
    :type title: str
    :param icon: The icon to be shown in the message top bar
    :type icon: str
    :param message: lines of text to display, a.k.a. the message
    :type message: str or (str, str, ..)

    TIP: Check `Link blender icons <https://docs.blender.org/api/current/bpy_types_enum_items/icon_items.html>`_ for icons you can use
    TIP: Or even better, check `Link this addons <https://docs.blender.org/manual/en/latest/addons/development/icon_viewer.html>`_ to also see the icons.

    usage:
    .. code-block:: python
       myLines=("line 1","line 2","line 3")
       butils.ShowMessageBox(message=myLines)

    or:
    .. code-block:: python
       butils.ShowMessageBox(title="",message=("AAAAAH","NOOOOO"),icon=)

    """
    global message_memory
    if prevent_repeat:
        for m in message_memory:
            if m[0] == title and m[1] == icon and m[2] == message:
                return
        message_memory.append([title, icon, message])
    myLines = message

    def draw(self, context):
        if isinstance(myLines, str):
            self.layout.label(text=myLines)
        elif hasattr(myLines, "__iter__"):
            for n in myLines:
                self.layout.label(text=n)

    bpy.context.window_manager.popup_menu(draw, title=title, icon=icon)


def simply_delete_objects(objs):
    completely_delete_objects(objs)


def completely_delete_objects(objs, recursive=True):
    for g in objs:
        if type(g) != type(None):
            if recursive:
                try:
                    if hasattr(g, "children") and len(g.children) > 0:
                        completely_delete_objects(g.children)
                except ReferenceError:
                    # not important
                    pass

            try:
                bpy.data.objects.remove(g, do_unlink=True)
            except ReferenceError:
                # not important
                pass
            except RuntimeError:
                pass


def is_mesh(o):
    return type(o.data) == bpy.types.Mesh


def is_metrics_object(o):
    if f"{utils.prefix()}_type" in o:
        return o[f"{utils.prefix()}_type"] == "metrics"
    return (
        re.match(".*_metrics$", o.name) is not None
        or re.match(".*_metrics.[\d]{3}$", o.name) is not None
    ) and is_mesh(o)


def is_text_object(o):
    if f"{utils.prefix()}_type" in o:
        return o[f"{utils.prefix()}_type"] == "textobject"
    for t in bpy.context.scene.abc3d_data.available_texts:
        if o == t.text_object:
            return True
    return False


def is_glyph_object(o):
    if f"{utils.prefix()}_type" in o:
        return o[f"{utils.prefix()}_type"] == "glyph"
    try:
        return (
            o.parent is not None
            and "glyphs" in o.parent.name
            and is_mesh(o)
            and not is_metrics_object(o)
        )
    except ReferenceError:
        return False


def is_glyph(o):
    return is_glyph_object(o)


def update_types():
    scene = bpy.context.scene
    abc3d_data = scene.abc3d_data
    for t in abc3d_data.available_texts:
        t.text_object[f"{utils.prefix()}_type"] = "textobject"
        for g in t.glyphs:
            g.glyph_object[f"{utils.prefix()}_type"] = "glyph"


# blender bound_box vertices
#
# 3------7.
# |`.    | `.     +y
# |  `2------6     |
# |   |  |   |     |
# 0---|--4.  |     +--- +x
#  `. |    `.|      `.
#    `1------5        `+z


def get_glyph_advance(glyph_obj):
    for c in glyph_obj.children:
        if is_metrics_object(c):
            return abs(c.bound_box[4][0] - c.bound_box[0][0])
    return abs(glyph_obj.bound_box[4][0] - glyph_obj.bound_box[0][0])


def get_glyph_prepost_advances(glyph_obj):
    for c in glyph_obj.children:
        if is_metrics_object(c):
            return -1 * c.bound_box[0][0], c.bound_box[4][0]
    return -1 * glyph_obj.bound_box[0][0], glyph_obj.bound_box[4][0]


def get_glyph_height(glyph_obj):
    for c in glyph_obj.children:
        if is_metrics_object(c):
            return abs(c.bound_box[0][1] - c.bound_box[3][1])
    return abs(glyph_obj.bound_box[0][1] - glyph_obj.bound_box[3][1])


def prepare_text(font_name, face_name, text, allow_replacement=True):
    availability = Font.test_glyphs_availability(font_name, face_name, text)
    if isinstance(availability, int):
        if availability == Font.MISSING_FONT:
            print(
                f"{utils.prefix()}::prepare_text({font_name=}, {face_name=}, {text=}) failed with MISSING_FONT"
            )
        if availability is Font.MISSING_FACE:
            print(
                f"{utils.prefix()}::prepare_text({font_name=}, {face_name=}, {text=}) failed with MISSING_FACE"
            )
        return False
    loadable = availability.unloaded
    # possibly replace upper and lower case letters with each other
    if len(availability.missing) > 0 and allow_replacement:
        replacement_search = ""
        for m in availability.missing:
            if m.isalpha():
                replacement_search += m.swapcase()
        r = Font.test_availability(font_name, face_name, replacement_search)
        loadable += r.unloaded
        # not update (loaded, missing, files), we only use loadable/maybe later

    if len(loadable) > 0:
        for filepath in availability.filepaths:
            load_font_from_filepath(filepath, loadable, font_name, face_name)
    return True


def predict_actual_text(text_properties):
    availability = Font.test_availability(
        text_properties.font_name, text_properties.face_name, text_properties.text
    )
    AVAILABILITY = Font.test_availability(
        text_properties.font_name,
        text_properties.face_name,
        text_properties.text.swapcase(),
    )
    t_text = text_properties.text
    for c in availability.missing:
        C = c.swapcase()
        if C in AVAILABILITY.missing:
            t_text = t_text.replace(c, "")
        else:
            t_text = t_text.replace(c, C)
    return t_text


def is_bezier(curve):
    if curve.type != "CURVE":
        return False
    if len(curve.data.splines) < 1:
        return False
    for spline in curve.data.splines:
        if spline.type != "BEZIER":
            return False
    return True


text_object_keys = [
    "font_name",
    "face_name",
    "type",
    "text_id",
    "font_size",
    "letter_spacing",
    "distribution_type",
    "orientation",
    "translation",
    "offset",
    "text",
]

glyph_object_keys = [
    "type",
    "glyph_index",
    "glyph_id",
    "text_id",
    "font_name",
    "face_name",
    "font_size",
    "letter_spacing",
    "alternate",
]

ignore_keys_in_text_object_comparison = [
    "type",
]

ignore_keys_in_glyph_object_comparison = [
    "type",
    "glyph_index",
    "font_name",
    "face_name",
    "text_id",
]

ignore_keys_in_glyph_object_transfer = [
    "type",
    "text_id",
    "glyph_index",
]

keys_trigger_regeneration = [
    "font_name",
    "face_name",
]

COMPARE_TEXT_OBJECT_SAME = 0
COMPARE_TEXT_OBJECT_DIFFER = 1
COMPARE_TEXT_OBJECT_REGENERATE = 2


def find_free_text_id():
    scene = bpy.context.scene
    abc3d_data = scene.abc3d_data
    text_id = 0
    found_free = False
    while not found_free:
        occupied = False
        for t in abc3d_data.available_texts:
            if text_id == t.text_id:
                occupied = True
        if occupied:
            text_id += 1
        else:
            found_free = True
    return text_id


def compare_text_properties_to_text_object(text_properties, o):
    for key in text_object_keys:
        if key in ignore_keys_in_text_object_comparison:
            continue
        object_key = get_key(key)
        text_property = (
            text_properties[key]
            if key in text_properties
            else getattr(text_properties, key)
        )
        text_object_property = o[object_key] if object_key in o else False
        if text_property != text_object_property:
            if key in keys_trigger_regeneration:
                return COMPARE_TEXT_OBJECT_REGENERATE
            elif key in ["translation", "orientation"]:
                if (
                    text_property[0] != text_object_property[0]
                    or text_property[1] != text_object_property[1]
                    or text_property[2] != text_object_property[2]
                ):
                    return COMPARE_TEXT_OBJECT_DIFFER
                # else same
            else:
                return COMPARE_TEXT_OBJECT_DIFFER
        # else same
    return COMPARE_TEXT_OBJECT_SAME


def transfer_text_properties_to_text_object(text_properties, o):
    for key in text_object_keys:
        if key in ignore_keys_in_text_object_comparison:
            continue
        object_key = get_key(key)
        text_property = (
            text_properties[key]
            if key in text_properties
            else getattr(text_properties, key)
        )
        o[object_key] = text_property
    o[get_key("type")] = "textobject"


def get_glyph(glyph_id, font_name, face_name, notify_on_replacement=False):
    glyph_tmp = Font.get_glyph(font_name, face_name, glyph_id, -1)
    if glyph_tmp is None:
        space_width = Font.is_space(glyph_id)
        if space_width:
            return space_width

        message = f"Glyph not found for font_name='{text_properties.font_name}' face_name='{text_properties.face_name}' glyph_id='{glyph_id}'"
        replaced = False
        if glyph_id.isalpha():
            possible_replacement = glyph_id.swapcase()
            glyph_tmp = Font.get_glyph(
                text_properties.font_name,
                text_properties.face_name,
                possible_replacement,
                -1,
            )
            if glyph_tmp is not None:
                message = message + f" (replaced with '{possible_replacement}')"
                replaced = True

        if notify_on_replacement:
            ShowMessageBox(
                title="Glyph replaced" if replaced else "Glyph missing",
                icon="INFO" if replaced else "ERROR",
                message=message,
                prevent_repeat=True,
            )
        if not replaced:
            return None

    return glyph_tmp.original


def get_text_properties(text_id, scene=None):
    if scene is None:
        scene = bpy.context.scene
    abc3d_data = scene.abc3d_data
    for t in abc3d_data.available_texts:
        if text_id == t.text_id:
            return t
    return None


def get_text_properties_by_index(text_index, scene=None):
    if scene is None:
        scene = bpy.context.scene
    abc3d_data = scene.abc3d_data
    if text_index >= len(abc3d_data.available_texts):
        return None
    return abc3d_data.available_texts[text_index]


def duplicate(
    obj,
    data=True,
    actions=True,
    add_to_collection=True,
    collection=None,
    recursive=True,
):
    obj_copy = obj.copy()
    if add_to_collection:
        if collection:
            collection.objects.link(obj_copy)
        elif len(obj.users_collection) > 0:
            obj.users_collection[0].objects.link(obj_copy)
    if data and obj.data:
        obj_copy.data = obj.data.copy()
    if actions and obj.animation_data:
        obj_copy.animation_data.action = obj.animation_data.action.copy()
    if recursive and hasattr(obj, "children"):
        for child in obj.children:
            child_copy = duplicate(child)
            child_copy.parent_type = child.parent_type
            child_copy.parent = obj_copy
            # child_copy.matrix_parent_inverse = obj_copy.matrix_world.inverted()
    return obj_copy


def transfer_text_object_to_text_properties(
    text_object, text_properties, id_from_text_properties=True
):
    possible_brother_text_id = (
        text_object[get_key("text_id")] if get_key("text_id") in text_object else ""
    )
    for key in text_object_keys:
        if key in ignore_keys_in_text_object_comparison:
            continue
        object_key = get_key(key)
        if id_from_text_properties and key == "text_id":
            text_object[object_key] = text_properties["text_id"]
        else:
            text_object_property = (
                text_object[object_key] if object_key in text_object else False
            )
            if text_object_property is not False:
                text_properties[key] = text_object_property

    if len(text_object.children) == 0:
        if (
            possible_brother_text_id != text_properties["text_id"]
            and possible_brother_text_id != ""
        ):
            possible_brother_properties = get_text_properties(possible_brother_text_id)
            possible_brother_object = possible_brother_properties.text_object
            if possible_brother_object is not None:
                for child in possible_brother_object.children:
                    if is_glyph_object(child):
                        child_copy = duplicate(child)
                        child_copy.parent_type = child.parent_type
                        child_copy.parent = text_object
                        parent_to_curve(child_copy, text_object)
                        # child_copy.matrix_parent_inverse = text_object.matrix_world.inverted()

    found_reconstructable_glyphs = False
    glyph_objects_with_indices = []
    required_keys = ["glyph_index", "glyph_id", "type"]
    for glyph_object in text_object.children:
        if is_glyph_object(glyph_object):
            has_required_keys = True
            for key in required_keys:
                if get_key(key) not in glyph_object:
                    has_required_keys = False
            if has_required_keys:
                inner_node = None
                glyph_id = glyph_object[get_key("glyph_id")]
                for c in glyph_object.children:
                    if c.name.startswith(f"{glyph_id}_mesh"):
                        inner_node = c
                if inner_node is not None:
                    glyph_objects_with_indices.append(glyph_object)

    glyph_objects_with_indices.sort(key=lambda g: g[get_key("glyph_index")])
    text = ""
    for g in glyph_objects_with_indices:
        text += g[get_key("glyph_id")]
    is_good_text = False
    if len(text) > 0:
        if text == text_properties.text:
            is_good_text = True
        else:
            t_text = predict_actual_text(text_properties)
            if t_text == text:
                is_good_text = True
    if is_good_text:
        text_properties.actual_text = text
        text_properties.glyphs.clear()
        prepare_text(text_properties.font_name, text_properties.face_name, text)
        fail_after_all = False
        for glyph_index, glyph_object in enumerate(glyph_objects_with_indices):
            glyph_id = glyph_object[get_key("glyph_id")]
            # glyph_tmp = Font.get_glyph(text_properties.font_name,
            # text_properties.face_name,
            # glyph_id)
            # glyph = glyph_tmp.original
            glyph_properties = text_properties.glyphs.add()

            transfer_glyph_object_to_glyph_properties(glyph_object, glyph_properties)
            # glyph_properties["glyph_object"] = glyph_object
            inner_node = None
            for c in glyph_object.children:
                if c.name.startswith(f"{glyph_id}_mesh"):
                    inner_node = c
            if inner_node is None:
                fail_after_all = True
                pass
            glyph_properties["glyph_object"] = glyph_object
            glyph_properties["glyph_index"] = glyph_index
            glyph_properties["text_id"] = text_properties.text_id
            glyph_object["text_id"] = text_properties.text_id
        if not fail_after_all:
            found_reconstructable_glyphs = True

    if not found_reconstructable_glyphs:
        text_properties.actual_text = ""
        text_properties.glyphs.clear()
        unfortunate_children = text_object.children
        completely_delete_objects(unfortunate_children)

        def kill_children():
            completely_delete_objects(unfortunate_children)

        run_in_main_thread(kill_children)

    if "font_name" in text_properties and "face_name" in text_properties:
        font_name = text_properties["font_name"]
        face_name = text_properties["face_name"]
        text_properties.font = f"{font_name} {face_name}"


def link_text_object_with_new_text_properties(text_object, scene=None):
    if scene is None:
        scene = bpy.context.scene
    text_id = find_free_text_id()
    text_properties = scene.abc3d_data.available_texts.add()
    text_properties["text_id"] = text_id
    # text_object[get_key("text_id")] = text_id
    prepare_text(
        text_object[get_key("font_name")],
        text_object[get_key("face_name")],
        text_object[get_key("text")],
    )
    text_properties.text_object = text_object
    transfer_text_object_to_text_properties(text_object, text_properties)


def test_finding():
    scene = bpy.context.scene
    abc3d_data = scene.abc3d_data
    text_id = find_free_text_id()
    t = abc3d_data.available_texts.add()
    t["text_id"] = text_id
    o = bpy.context.active_object
    transfer_text_object_to_text_properties(o, t)


def is_text_object_legit(text_object):
    must_have_keys = [
        get_key("font_name"),
        get_key("face_name"),
        get_key("text"),
        get_key("type"),
    ]
    for key in must_have_keys:
        if key not in text_object:
            return False
    if text_object[get_key("type")] != "textobject":
        return False
    return True


# def detect_texts():
# scene = bpy.context.scene
# abc3d_data = scene.abc3d_data
# for o in bpy.data.objects:
# if get_key("type") in o \
# and o[get_key("type") == "textobject" \
# and o[get_key("t


def link_text_object_and_text_properties(o, text_properties):
    text_id = text_properties.text_id
    o["text_id"] = text_id
    text_properties.textobject = o


def get_glyph_object_property(text_properties, glyph_properties, key):
    if key in glyph_properties:
        return glyph_properties[key]
    if hasattr(glyph_properties, key):
        return getattr(glyph_properties, key)
    return (
        text_properties[key]
        if key in text_properties
        else getattr(text_properties, key)
    )


def transfer_properties_to_glyph_object(
    text_properties, glyph_properties, glyph_object
):
    for key in glyph_object_keys:
        if key in ignore_keys_in_glyph_object_transfer:
            continue
        object_key = get_key(key)
        glyph_object[object_key] = get_glyph_object_property(
            text_properties, glyph_properties, key
        )
    glyph_object[get_key("type")] = "glyph"
    glyph_object[get_key("text_id")] = text_properties["text_id"]


def transfer_glyph_object_to_glyph_properties(glyph_object, glyph_properties):
    for key in glyph_object_keys:
        if key in ignore_keys_in_glyph_object_transfer:
            continue
        glyph_properties[key] = glyph_object[get_key(key)]
    glyph_properties["text_id"] = glyph_object[get_key("text_id")]


def get_text_difference_index(text_a, text_b):
    len_a = len(text_a)
    len_b = len(text_b)
    len_min = min(len_a, len_b)
    len_max = max(len_a, len_b)
    for i in range(0, len_max):
        if i >= len_min or text_a[i] != text_b[i]:
            return i
    return False


def would_regenerate(text_properties):
    predicted_text = predict_actual_text(text_properties)
    if text_properties.actual_text != predicted_text:
        return get_text_difference_index(text_properties.actual_text, predicted_text)
    if len(text_properties.glyphs) == 0:
        return True

    for i, g in enumerate(text_properties.glyphs):
        if not hasattr(g.glyph_object, "type"):
            return True
        elif g.glyph_object.type != "EMPTY":
            return True
        # check if perhaps one glyph was deleted
        elif g.glyph_object is None:
            return True
        elif g.glyph_object.parent is None:
            return True
        elif g.glyph_object.parent.users_collection != g.glyph_object.users_collection:
            return True
        elif len(text_properties.text) > i and g.glyph_id != text_properties.text[i]:
            return True
        elif len(text_properties.text) > i and (
            g.glyph_object[f"{utils.prefix()}_font_name"] != text_properties.font_name
            or g.glyph_object[f"{utils.prefix()}_face_name"]
            != text_properties.face_name
        ):
            return True

    return False


def update_matrices(obj):
    if obj.parent is None:
        obj.matrix_world = obj.matrix_basis

        # else:
        obj.matrix_world = (
            obj.parent.matrix_world * obj.matrix_parent_inverse * obj.matrix_basis
        )


def is_or_has_parent(o, parent, if_is_parent=True, max_depth=10):
    if o == parent and if_is_parent:
        return True
    oo = o
    for i in range(0, max_depth):
        oo = oo.parent
        if oo == parent:
            return True
        if oo is None:
            return False
    return False


def parent_to_curve(o, c):
    # https://projects.blender.org/blender/blender/issues/100661
    o.parent_type = "OBJECT"
    o.parent = c
    # o.matrix_parent_inverse = c.matrix_world.inverted()

    if c.data.use_path and len(c.data.splines) > 0:
        if c.data.splines[0].type == "BEZIER":
            i = -1 if c.data.splines[0].use_cyclic_u else 0
            p = c.data.splines[0].bezier_points[i].co
            o.matrix_parent_inverse.translation = p * -1.0
        elif c.data.splines[0].type == "NURBS":
            cm = c.to_mesh()
            p = cm.vertices[0].co
            o.matrix_parent_inverse.translation = p * -1.0


def get_original_glyph(text_properties, glyph_properties):
    glyph_tmp = Font.get_glyph(
        text_properties.font_name,
        text_properties.face_name,
        glyph_properties.glyph_id,
        glyph_properties.alternate,
    )
    if glyph_tmp is None:
        return None
    return glyph_tmp.original


def ensure_glyph_object(text_properties, glyph_properties):
    glyph_index = glyph_properties["glyph_index"]
    # First, let's see if there was ever a glyph object constructed
    if (
        glyph_properties.glyph_object is None
        or not isinstance(glyph_properties.glyph_object, bpy_types.Object)
        or not is_glyph_object(glyph_properties.glyph_object)
    ):
        # we do need a text_object though
        # if there is not, let's give up for this iteration
        if not isinstance(text_properties.text_object, bpy_types.Object):
            print(
                f"{utils.prefix()}::ensure_glyph_object: failed! text object is not an object"
            )
            return False

        outer_node = bpy.data.objects.new(f"{glyph_properties.glyph_id}", None)
        inner_node = bpy.data.objects.new(
            f"{glyph_properties.glyph_id}_mesh",
            get_original_glyph(text_properties, glyph_properties).data,
        )
        transfer_properties_to_glyph_object(
            text_properties, glyph_properties, outer_node
        )

        # Add into the scene.
        text_properties.text_object.users_collection[0].objects.link(outer_node)
        text_properties.text_object.users_collection[0].objects.link(inner_node)

        # Parenting is hard.
        inner_node.parent_type = "OBJECT"
        inner_node.parent = outer_node
        inner_node.matrix_parent_inverse = outer_node.matrix_world.inverted()
        parent_to_curve(outer_node, text_properties.text_object)

        # outer_node["inner_node"] = bpy.types.PointerProperty(inner_node)
        # for some funny reason we cannot set 'glyph_object' by key, but need to set the attribute
        glyph_properties.glyph_object = outer_node
        outer_node[f"{utils.prefix()}_glyph_index"] = glyph_index
    else:
        outer_node = glyph_properties.glyph_object
        outer_node[f"{utils.prefix()}_glyph_index"] = glyph_index

    # we might just want to update the data
    # imagine a different font, letter or alternate
    # this way we keep all manual transforms
    if (
        glyph_properties.glyph_object[get_key("glyph_id")] != glyph_properties.glyph_id
        or glyph_properties.glyph_object[get_key("alternate")]
        != glyph_properties.alternate
        or glyph_properties.glyph_object[get_key("font_name")]
        != text_properties.font_name
        or glyph_properties.glyph_object[get_key("face_name")]
        != text_properties.face_name
    ):

        inner_node = None
        old_font_name = glyph_properties.glyph_object[get_key("font_name")]
        old_face_name = glyph_properties.glyph_object[get_key("face_name")]
        old_face = Font.get_font_face(old_font_name, old_face_name)
        face = Font.get_font_face(text_properties.font_name, text_properties.face_name)
        ratio = old_face.unit_factor / face.unit_factor
        # try:
        #     inner_node = glyph_properties["inner_node"].original
        #     inner_node.location = inner_node.location * ratio
        # except KeyError:
        old_glyph_id = glyph_properties.glyph_object[get_key("glyph_id")]
        for c in glyph_properties.glyph_object.children:
            if c.name.startswith(f"{old_glyph_id}_mesh"):
                inner_node = c
                inner_node.location = inner_node.location * ratio
                inner_node.name = f"{glyph_properties.glyph_id}_mesh"
                # outer_node["inner_node"] = bpy.types.PointerProperty(inner_node)
        if inner_node is None:
            print(f"{utils.prefix()}::ensure_glyph_object: failed! no inner_node found")
            return False
        inner_node.data = get_original_glyph(text_properties, glyph_properties).data
        glyph_properties.glyph_object[get_key("glyph_id")] = glyph_properties.glyph_id
        glyph_properties.glyph_object[get_key("alternate")] = glyph_properties.alternate
        glyph_properties.glyph_object[get_key("font_name")] = text_properties.font_name
        glyph_properties.glyph_object[get_key("face_name")] = text_properties.face_name

    glyph_properties.glyph_object.hide_set(True)

    return True


def ensure_glyphs(text_properties, predicted_text: str):

    ######### REQUIREMENTS

    # turns out this is not a requirement
    # and can be a case we want to tackle
    #
    # if not text_properties.get("glyphs"):
    #     ShowMessageBox(
    #         title="text_properties has no glyphs", message="well, what I said"
    #     )
    #     return False

    ######### SETUP

    n_glyphs = len(text_properties.glyphs)
    n_predicted = len(predicted_text)

    ########## ENSURE AMOUNT

    if n_glyphs == n_predicted:
        # same amount of glyphs
        # this is the most common case
        # don't do anything
        pass

    elif n_glyphs > n_predicted:
        # more glyphs than predicted
        # it's a shorter word, or letters were deleted
        count = n_glyphs - n_predicted
        for i in range(0, count):
            reverse_i = n_glyphs - (i + 1)
            # let's attempt to remove the glyph_object first
            # so we avoid dangling data
            if isinstance(
                text_properties.glyphs[reverse_i].glyph_object, bpy_types.Object
            ):
                # bam!
                completely_delete_objects(
                    [text_properties.glyphs[reverse_i].glyph_object]
                )
            # else:
            #     # nothing to do, if there is no blender object
            #     # possibly we could do a 'del', but we can also
            #     # just comment out the whole conditional fork
            #     pass

            # now that blender data is gone, we can remove the glyph
            text_properties.glyphs.remove(reverse_i)

    elif n_glyphs < n_predicted:
        # less glyphs than predicted
        # it's a longer word, or letters were added
        while n_glyphs < n_predicted:
            glyph_id = predicted_text[n_glyphs]
            glyph_properties = text_properties.glyphs.add()
            glyph_properties["glyph_id"] = predicted_text[n_glyphs]
            glyph_properties["glyph_index"] = n_glyphs
            glyph_properties["text_id"] = text_properties.text_id
            glyph_properties["letter_spacing"] = 0
            n_glyphs += 1

    ######### ENSURE VALUES

    for i, glyph_properties in enumerate(text_properties.glyphs):
        glyph_properties["glyph_index"] = i
        glyph_properties["text_id"] = text_properties.text_id
        glyph_properties["glyph_id"] = predicted_text[i]
        if not ensure_glyph_object(text_properties, glyph_properties):
            print(f"{utils.prefix()}::ensure_glyphs: could not ensure glyph_object")
    transfer_text_properties_to_text_object(
        text_properties, text_properties.text_object
    )

    return True


# C.scene.abc3d_data.available_texts[0]
# import abc3d
# abc3d.butils.ensure_glyphs(C.scene.abc3d_data.available_texts[0], "whatever")


def set_text_on_curve(
    text_properties, reset_timeout_s=0.1, reset_depsgraph_n=4, can_regenerate=False
):
    """set_text_on_curve

    An earlier reset cancels the other.
    To disable reset, set both to false.

    :param text_properties: all information necessary to set text on a curve
    :type text_properties: ABC3D_text_properties
    :param reset_timeout_s: reset external parameters after timeout. (<= 0) = immediate, (> 0) = non-blocking reset timeout in seconds, (False) = no timeout reset
    :type reset_timeout_s: float
    :param reset_depsgraph_n: reset external parameters after n-th depsgraph update. (<= 0) = immediate, (> 0) = reset after n-th depsgraph update, (False) = no depsgraph reset
    :type reset_depsgraph_n: int
    """
    # NOTE: depsgraph update not locked
    # as we fixed data_path with parent_to_curve trick
    # global lock_depsgraph_update_n_times

    # starttime = time.perf_counter_ns()
    if text_properties is None:
        return False
    mom = text_properties.text_object
    if mom is None:
        return False
    if mom.type != "CURVE":
        return False
    if len(mom.users_collection) < 1:
        return False

    distribution_type = "CALCULATE" if is_bezier(mom) else "FOLLOW_PATH"

    predicted_text = predict_actual_text(text_properties)
    ensure_glyphs(text_properties, predicted_text)

    curve_length = get_curve_length(mom)
    advance = text_properties.offset
    glyph_advance = 0
    glyph_index = 0
    is_command = False
    previous_spline_index = -1

    actual_text = ""
    # we need to iterate over the original text, as we want commands
    # however, ideally it could be an array of glyphs, commands and spaces
    # now we need to handle non existing characters etc everytime in the loop
    for i, c in enumerate(text_properties.text):
        face = Font.get_font_face(text_properties.font_name, text_properties.face_name)
        scalor = face.unit_factor * text_properties.font_size
        if c == "\\":
            is_command = True
            continue
        is_newline = False
        if is_command:
            if c == "n":
                is_newline = True
                next_line_advance = get_next_line_advance(mom, advance, glyph_advance)
                if advance == next_line_advance:
                    print(
                        f"would like to add new line for {text_properties.text} please"
                    )
                    # TODO: add a new line
                advance = next_line_advance + text_properties.offset
                continue
            is_command = False
        glyph_id = c

        spline_index = 0

        ############### HANDLE SPACES

        if glyph_id not in predicted_text:
            space_width = Font.is_space(glyph_id)
            if space_width:
                advance = advance + space_width * text_properties.font_size
            continue

        ############### GLYPH PROPERTIES

        glyph_properties = text_properties.glyphs[glyph_index]
        # ensure_glyph_object(text_properties, glyph_properties)

        ############### ACTUAL TEXT

        actual_text += glyph_id

        ############### NODE SCENE MANAGEMENT

        # outsourced to ensure_glyph_object

        ############### TRANSFORMS

        glyph = get_original_glyph(text_properties, glyph_properties)

        # origins could be shifted
        # so we need to apply a pre_advance
        glyph_pre_advance, glyph_post_advance = get_glyph_prepost_advances(glyph)
        advance += glyph_pre_advance * scalor

        # check if we want to loop
        applied_advance = advance
        if text_properties.loop_in:
            if applied_advance < 0:
                applied_advance %= curve_length

        if text_properties.loop_out:
            if applied_advance > curve_length:
                applied_advance %= curve_length

        if distribution_type == "FOLLOW_PATH":
            outer_node.constraints.new(type="FOLLOW_PATH")
            outer_node.constraints["Follow Path"].target = mom
            outer_node.constraints["Follow Path"].use_fixed_location = True
            outer_node.constraints["Follow Path"].offset_factor = (
                applied_advance / curve_length
            )
            outer_node.constraints["Follow Path"].use_curve_follow = True
            outer_node.constraints["Follow Path"].forward_axis = "FORWARD_X"
            outer_node.constraints["Follow Path"].up_axis = "UP_Y"
            spline_index = 0
        elif distribution_type == "CALCULATE":
            previous_glyph_object_rotation_mode = None
            if glyph_properties.glyph_object.rotation_mode != "QUATERNION":
                previous_glyph_object_rotation_mode = (
                    glyph_properties.glyph_object.rotation_mode
                )
                glyph_properties.glyph_object.rotation_mode = "QUATERNION"

            # get info from bezier
            location, tangent, spline_index = calc_point_on_bezier_curve(
                mom, applied_advance, True, True
            )
            # location, tangent, spline_index = calc_point_on_bezier_curve(
            #     mom_hooked, applied_advance, True, True
            # )

            # check if we are on a new line
            if spline_index != previous_spline_index:
                is_newline = True

            # position
            glyph_properties.glyph_object.location = (
                location + text_properties.translation
            )

            # orientation / rotation
            mask = [0]
            input_rotations = [mathutils.Vector((0.0, 0.0, 0.0))]
            vectors = [tangent]
            factors = [1.0]
            local_main_axis = mathutils.Vector((1.0, 0.0, 0.0))
            motor = (
                align_rotations_auto_pivot(
                    mask, input_rotations, vectors, factors, local_main_axis
                )
                if not text_properties.ignore_orientation
                else [mathutils.Matrix()]
            )

            q = mathutils.Quaternion()
            q.rotate(text_properties.orientation)
            glyph_properties.glyph_object.rotation_quaternion = (
                motor[0].to_3x3() @ q.to_matrix()
            ).to_quaternion()

            # # NOTE: supercool but out of scope, as we wouldhave to update it everytime the curve object rotates,
            # # but this would ignore the curve objects orientation:
            # glyph_properties.glyph_object.rotation_quaternion = (mom.matrix_world.inverted().to_3x3() @ motor[0].to_3x3() @ q.to_matrix()).to_quaternion()

            # # scale
            glyph_properties.glyph_object.scale = (scalor, scalor, scalor)

            if previous_glyph_object_rotation_mode:
                glyph_properties.glyph_object.rotation_mode = (
                    previous_glyph_object_rotation_mode
                )

            # outer_node.hide_viewport = True

        ############### PREPARE FOR THE NEXT

        glyph_advance = (
            glyph_post_advance * scalor
            + text_properties.letter_spacing
            + glyph_properties.letter_spacing
        )

        # now we need to compensate for curvature
        # otherwise letters will be closer together the curvier the bezier is
        # NOTE: this could be done more efficiently
        curve_compensation = 0
        if distribution_type == "CALCULATE" and (not is_newline or spline_index == 0):
            if text_properties.compensate_curvature and glyph_advance > 0:
                previous_location, psi = calc_point_on_bezier_curve(
                    mom, advance, False, True
                )
                new_location, si = calc_point_on_bezier_curve(
                    mom, advance + glyph_advance, False, True
                )
                if psi == si:
                    n_max = 100
                    n = 0
                    while (
                        (previous_location - new_location).length > glyph_advance
                        and psi == si
                        and n < n_max
                    ):
                        curve_compensation = curve_compensation - glyph_advance * 0.01
                        tmp_new_location, si = calc_point_on_bezier_curve(
                            mom,
                            advance + glyph_advance + curve_compensation,
                            output_tangent=False,
                            output_spline_index=True,
                        )
                        if tmp_new_location == new_location:
                            print(
                                f"{utils.prefix()}::set_text_on_curve::compensate_curvature while loop overstaying welcome"
                            )
                            break
                        new_location = tmp_new_location
                        n += 1
                    n = 0
                    while (
                        (previous_location - new_location).length < glyph_advance
                        and psi == si
                        and n < n_max
                    ):
                        curve_compensation = curve_compensation + glyph_advance * 0.01
                        tmp_new_location, si = calc_point_on_bezier_curve(
                            mom,
                            advance + glyph_advance + curve_compensation,
                            output_tangent=False,
                            output_spline_index=True,
                        )
                        if tmp_new_location == new_location:
                            print(
                                f"{utils.prefix()}::set_text_on_curve::compensate_curvature while loop overstaying welcome"
                            )
                            break
                        new_location = tmp_new_location
                        n += 1

        advance = advance + glyph_advance + curve_compensation
        glyph_index += 1
        previous_spline_index = spline_index

    text_properties["actual_text"] = actual_text

    return True


verification_object = {
    f"{utils.prefix()}_type": "textobject",
    f"{utils.prefix()}_text_id": 0,
    f"{utils.prefix()}_font_name": "font_name",
    f"{utils.prefix()}_face_name": "face_name",
    f"{utils.prefix()}_font_size": 42,
    f"{utils.prefix()}_letter_spacing": 42,
    f"{utils.prefix()}_orientation": [0, 0, 0],
    f"{utils.prefix()}_translation": [0, 0, 0],
}


def verify_text_object(o):
    pass


# blender bound_box vertices
#
# 3------7.
# |`.    | `.       +y
# |  `2------6  -z   |
# |   |  |   |    `. |
# 0---|--4.  |      `+--- +x
#  `. |    `.|
#    `1------5


def add_metrics_obj_from_bound_box(glyph, bound_box=None):
    mesh = bpy.data.meshes.new(f"{glyph.name}_metrics")  # add the new mesh
    obj = bpy.data.objects.new(mesh.name, mesh)
    obj["font_name"] = glyph["font_name"]
    obj["face_name"] = glyph["face_name"]
    obj["glyph"] = glyph["glyph"]
    obj[f"{utils.prefix()}_type"] = "metrics"

    # remove already existing metrics
    remove_metrics = []
    for c in glyph.children:
        if is_metrics_object(c):
            remove_metrics.append(c)
    if len(remove_metrics) > 0:
        completely_delete_objects(remove_metrics)

    col = glyph.users_collection[0]
    col.objects.link(obj)
    # bpy.context.view_layer.objects.active = obj
    obj.parent = glyph

    if type(bound_box) == type(None):
        bound_box = glyph.bound_box

    verts = [
        bound_box[0],
        bound_box[1],
        bound_box[2],
        bound_box[3],
        bound_box[4],
        bound_box[5],
        bound_box[6],
        bound_box[7],
    ]
    edges = [
        [0, 1],
        [1, 2],
        [2, 3],
        [3, 0],
        [0, 4],
        [1, 5],
        [2, 6],
        [3, 7],
        [4, 5],
        [5, 6],
        [6, 7],
        [7, 4],
    ]
    faces = []

    mesh.from_pydata(verts, edges, faces)


def add_faces_to_metrics(obj):
    mesh = bpy.data.meshes.new(f"{obj.name}")  # add the new mesh
    print(f"add_faces_to_metrics for {obj.name}")
    bound_box = bound_box_as_array(obj.bound_box)
    verts = [
        bound_box[0],
        bound_box[1],
        bound_box[2],
        bound_box[3],
        bound_box[4],
        bound_box[5],
        bound_box[6],
        bound_box[7],
    ]
    edges = [
        [0, 1],
        [1, 2],
        [2, 3],
        [3, 0],
        [0, 4],
        [1, 5],
        [2, 6],
        [3, 7],
        [4, 5],
        [5, 6],
        [6, 7],
        [7, 4],
    ]
    faces = [
        [0, 1, 2],
        [2, 3, 0],
        [2, 6, 7],
        [7, 3, 2],
        [6, 5, 4],
        [4, 7, 6],
        [4, 5, 1],
        [0, 4, 1],
        [1, 5, 6],
        [1, 6, 2],
        [4, 0, 7],
        [7, 0, 3],
    ]

    mesh.from_pydata(verts, edges, faces)

    old_mesh = obj.data
    obj.data = mesh
    bpy.data.meshes.remove(old_mesh)


def remove_faces_from_metrics(obj):
    mesh = bpy.data.meshes.new(f"{obj.name}")  # add the new mesh
    bound_box = bound_box_as_array(obj.bound_box)
    verts = [
        bound_box[0],
        bound_box[1],
        bound_box[2],
        bound_box[3],
        bound_box[4],
        bound_box[5],
        bound_box[6],
        bound_box[7],
    ]
    edges = [
        [0, 1],
        [1, 2],
        [2, 3],
        [3, 0],
        [0, 4],
        [1, 5],
        [2, 6],
        [3, 7],
        [4, 5],
        [5, 6],
        [6, 7],
        [7, 4],
    ]
    faces = []

    mesh.from_pydata(verts, edges, faces)

    old_mesh = obj.data
    obj.data = mesh
    bpy.data.meshes.remove(old_mesh)


# duplicate
# def remove_metrics_from_selection():
# for o in bpy.context.selected_objects:
# is_possibly_glyph = is_mesh(o)
# if is_possibly_glyph:
# metrics = []
# for c in o.children:
# if is_metrics_object(c):
# metrics.append(c)
# completely_delete_objects(metrics)


def get_max_bound_box(bb_1, bb_2=None):
    if type(bb_2) == type(None):
        bb_2 = bb_1
    x_max = max(bb_1[4][0], bb_2[4][0])
    x_min = min(bb_1[0][0], bb_2[0][0])
    y_max = max(bb_1[3][1], bb_2[3][1])
    y_min = min(bb_1[0][1], bb_2[0][1])
    z_max = max(bb_1[1][2], bb_2[1][2])
    z_min = min(bb_1[0][2], bb_2[0][2])
    return [
        mathutils.Vector((x_min, y_min, z_min)),
        mathutils.Vector((x_min, y_min, z_max)),
        mathutils.Vector((x_min, y_max, z_max)),
        mathutils.Vector((x_min, y_max, z_min)),
        mathutils.Vector((x_max, y_min, z_min)),
        mathutils.Vector((x_max, y_min, z_max)),
        mathutils.Vector((x_max, y_max, z_max)),
        mathutils.Vector((x_max, y_max, z_min)),
    ]


# blender bound_box vertices
#
# 3------7.
# |`.    | `.     +y
# |  `2------6     |
# |   |  |   |     |
# 0---|--4.  |     +--- +x
#  `. |    `.|      `.
#    `1------5        `+z


# why not [ [0] * 3 ] * 8
# https://stackoverflow.com/questions/2397141/how-to-initialize-a-two-dimensional-array-list-of-lists-if-not-using-numpy-in
def bound_box_as_array(bound_box):
    array = [[0] * 3 for i in range(8)]
    for i in range(0, len(bound_box)):
        for j in range(0, len(bound_box[i])):
            array[i][j] = bound_box[i][j]
    return array


##
# @brief get_metrics_bound_box
#        generates a metrics bounding box
#        where x-width comes from bb
#        and y-height + z-depth from bb_uebermetrics
#
# @param bb
# @param bb_uebermetrics
#
# @return metrics
def get_metrics_bound_box(bb, bb_uebermetrics):
    metrics = [[0] * 3] * 8
    # hurrays
    if type(bb_uebermetrics) == bpy.types.bpy_prop_array:
        metrics = bound_box_as_array(bb_uebermetrics)
    else:
        metrics = bb_uebermetrics.copy()
    metrics[0][0] = bb[0][0]
    metrics[1][0] = bb[1][0]
    metrics[2][0] = bb[2][0]
    metrics[3][0] = bb[3][0]
    metrics[4][0] = bb[4][0]
    metrics[5][0] = bb[5][0]
    metrics[6][0] = bb[6][0]
    metrics[7][0] = bb[7][0]
    return metrics


def get_metrics_object(o):
    if is_glyph(o):
        for c in o.children:
            if is_metrics_object(c):
                return c
    return None


def get_original(o):
    if hasattr(o, "original"):
        return o.original
    else:
        return o


def add_default_metrics_to_objects(objects=None, overwrite_existing=False):
    if type(objects) == type(None):
        objects = bpy.context.selected_objects
    targets = []
    reference_bound_box = None
    for o in objects:
        is_possibly_glyph = is_glyph(o)
        if is_possibly_glyph:
            metrics = []
            for c in o.children:
                if is_metrics_object(c):
                    metrics.append(c)

            if len(metrics) == 0:
                targets.append(o)
                reference_bound_box = get_max_bound_box(
                    o.bound_box, reference_bound_box
                )
            elif len(metrics) >= 0 and overwrite_existing:
                completely_delete_objects(metrics)
                targets.append(o)
                reference_bound_box = get_max_bound_box(
                    o.bound_box, reference_bound_box
                )
            else:
                for m in metrics:
                    reference_bound_box = get_max_bound_box(
                        m.bound_box, reference_bound_box
                    )
    for t in targets:
        bound_box = get_metrics_bound_box(t.bound_box, reference_bound_box)
        add_metrics_obj_from_bound_box(t, bound_box)


def remove_metrics_from_objects(objects=None):
    if type(objects) == type(None):
        objects = bpy.context.selected_objects
    metrics = []
    for o in objects:
        for c in o.children:
            if is_metrics_object(c):
                metrics.append(c)
    completely_delete_objects(metrics)


def align_metrics_of_objects_to_active_object(objects=None):
    if type(objects) == type(None):
        objects = bpy.context.selected_objects
        if len(objects) == 0:
            return "no objects selected"

    # define the reference_bound_box
    reference_bound_box = None
    if type(bpy.context.active_object) == type(None):
        return "no active_object, but align_to_active_object is True"
    for c in bpy.context.active_object.children:
        if is_metrics_object(c):
            reference_bound_box = bound_box_as_array(c.bound_box)
            break
    if type(reference_bound_box) == type(None):
        if not is_mesh(bpy.context.active_object):
            return "active_object is not a mesh and does not have a metrics child"
        reference_bound_box = bound_box_as_array(bpy.context.active_object.bound_box)

    # do it
    for o in objects:
        is_possibly_glyph = is_glyph(o)
        if is_possibly_glyph and o is not bpy.context.active_object:
            metrics = []
            for c in o.children:
                if is_metrics_object(c):
                    metrics.append(c)

            bb = None
            if len(metrics) == 0:
                bb = get_metrics_bound_box(o.bound_box, reference_bound_box)
            else:
                bb = get_metrics_bound_box(metrics[0].bound_box, reference_bound_box)
            if len(metrics) > 0:
                completely_delete_objects(metrics)

            add_metrics_obj_from_bound_box(o, bb)
    return ""


def align_metrics_of_objects(objects=None):
    if type(objects) == type(None):
        objects = bpy.context.selected_objects
        if len(objects) == 0:
            return "no objects selected"

    targets = []
    reference_bound_box = None
    for o in objects:
        is_possibly_glyph = is_glyph(o)
        if is_possibly_glyph:
            metrics = []
            for c in o.children:
                if is_metrics_object(c):
                    metrics.append(c)

            if len(metrics) == 0:
                reference_bound_box = get_max_bound_box(
                    o.bound_box, reference_bound_box
                )
            elif len(metrics) > 0:
                reference_bound_box = get_max_bound_box(
                    metrics[0].bound_box, reference_bound_box
                )
            targets.append(o)
    for t in targets:
        metrics = []
        for c in t.children:
            if is_metrics_object(c):
                metrics.append(c)
        bound_box = None
        if len(metrics) == 0:
            bound_box = get_metrics_bound_box(t.bound_box, reference_bound_box)
        else:
            bound_box = get_metrics_bound_box(metrics[0].bound_box, reference_bound_box)
            completely_delete_objects(metrics)

        add_metrics_obj_from_bound_box(t, bound_box)
    return ""


def align_origins_to_active_object(objects=None, axis=2):
    if objects is None:
        objects = bpy.context.selected_objects
        if len(objects) == 0:
            return "no objects selected"

    if bpy.context.active_object is None:
        return "no active object selected"

    reference_origin_position = bpy.context.active_object.matrix_world.translation[axis]

    # do it
    for o in objects:
        is_possibly_glyph = is_glyph(o)
        if is_possibly_glyph and o is not bpy.context.active_object:
            if is_mesh(o):
                diff = reference_origin_position - o.matrix_world.translation[axis]

                for v in o.data.vertices:
                    v.co[axis] -= diff

                o.matrix_world.translation[axis] = reference_origin_position

    return ""


# NOTE:
# Following code is not necessary anymore,
# as we derive the advance through metrics
# boundaries

# def divide_vectors(v1=mathutils.Vector((1.0,1.0,1.0)), v2=mathutils.Vector((1.0,1.0,1.0))):
# return mathutils.Vector([v1[i] / v2[i] for i in range(3)])

# def get_origin_shift_metrics(o, axis=0):
# if not is_metrics_object(o):
# return False
# min_value = sys.float_info.max
# for v in o.data.vertices:
# if v.co[axis] < min_value:
# min_value = v.co[axis]
# if min_value == sys.float_info.max:
# return False
# return min_value

# def fix_origin_shift_metrics(o, axis=0):
# shift = get_origin_shift_metrics(o)
# if not shift:
# print("False")
# return False
# for v in o.data.vertices:
# v.co[axis] -= shift
# shift_vector = mathutils.Vector((0.0, 0.0, 0.0))
# shift_vector[axis] = shift
# # o.location = o.location - (divide_vectors(v2=o.matrix_world.to_scale()) * (o.matrix_world @ shift_vector))
# o.matrix_local.translation = o.matrix_local.translation + (shift_vector @ o.matrix_local.inverted())
# # update_matrices(o)
# return True


# def fix_objects_metrics_origins(objects=None, axis=0, handle_metrics_directly=True):
# if objects is None:
# objects = bpy.context.selected_objects
# if len(objects) == 0:
# return "no objects selected"

# for o in objects:
# is_possibly_glyph = is_glyph(o)
# if is_possibly_glyph:
# for c in o.children:
# if is_metrics_object(c):
# fix_origin_shift_metrics(c, axis)
# elif is_metrics_object(o) and handle_metrics_directly:
# fix_origin_shift_metrics(o, axis)
# return ""

# def align_origins_to_metrics(objects=None):
# if objects is None:
# objects = bpy.context.selected_objects
# if len(objects) == 0:
# return "no objects selected"

# for o in objects:
# is_possibly_glyph = is_glyph(o)
# if is_possibly_glyph:
# min_x = 9999999999
# for c in o.children:
# if is_metrics_object(c):
# for v in c.data.vertices:
# if v.co[0] < min_x:
# min_x = v.co[0]

# metrics_origin_x = c.matrix_world.translation[0] + min_x

# diff = metrics_origin_x - o.matrix_world.translation[0]

# for v in o.data.vertices:
# v.co[0] -= diff

# o.location += mathutils.Vector((diff, 0.0, 0.0)) @ o.matrix_world.inverted()

# for c in o.children:
# if is_metrics_object(c):
# c.location -= mathutils.Vector((diff, 0.0, 0.0)) @ o.matrix_world.inverted()

# return ""