# AUTHOR NikitaKrutov
# VERSION 0.0.1
# Align Cylinder according to the custom pivot translation

import lux
import luxmath
import math


def get_user_input():
    values = [
        ("rotate_name", lux.DIALOG_TEXT, "Rotated object", "rotatedObject"),
        ("pivot_name", lux.DIALOG_TEXT, "Object to be used as pivot", "pivotObject")
    ]
    return lux.getInputDialog("Get Oriantation", "Enter Object Name to get the orientation from", values)


def vector_angles(dx, dy, dz):
    # length of the vector
    r = math.sqrt(dx*dx + dy*dy + dz*dz)

    x = math.sqrt(dx*dx + dz*dz)
    y = dy

    #azimuth angle in XY-plane
    #azimuth = math.cos(x)
    azimuth = math.atan2(dy, dx)

    #elevation angle from XY-plane
    #elevation = math.atan(y/x)
    elevation = math.atan2(dz, math.sqrt(dx*dx + dy*dy))

    return math.degrees(azimuth), math.degrees(elevation)




def run():
    opts = get_user_input()
    if not opts:
        print("User cancelled.")
        return

    scene_root = lux.getSceneTree()

    rotate_name = opts["rotate_name"]
    model_nodes = scene_root.find(rotate_name, types=[lux.NODE_TYPE_MODEL,lux.NODE_TYPE_OBJECT,lux.NODE_TYPE_GROUP])

    if not model_nodes:
        print(f"Group '{group_name}' not found.")
        return

    for model_node in model_nodes:
        #print(model_node.getTransform().getTransformation())
        dx, dy, dz = tuple(translation for translation in model_node.getTransform().getTransformation()[2].val())

        print(dx, dy, dz)
        
        az, el = vector_angles(dx, dy, dz)
        print("Elevation (x-rotation):", round(el,4), "\nAzimuth (y-rotation):", round(az,4))

    pivot_name = opts["pivot_name"]
    pmodel_nodes = scene_root.find(pivot_name, types=[lux.NODE_TYPE_MODEL,lux.NODE_TYPE_OBJECT,lux.NODE_TYPE_GROUP])

    for pmodel_node in pmodel_nodes:
        rotation_matrix_inverse = pmodel_node.getTransform()
        rotation_matrix_inverse.invert()
        #rotation_matrix_inverse.translate([0, 0.5, 0])

        T = luxmath.Matrix().makeTranslate([0, -0.5, 0])

        #print(rotation_matrix_inverse)
        
        pmodel_node.applyTransform(rotation_matrix_inverse, absolute = False)
        pmodel_node.applyTransform(T, absolute = False)


        R = luxmath.Matrix().makeRotate([math.radians(el), 0, math.radians(az-90)])
        pmodel_node.applyTransform(R, absolute = False)

run()