from maya import cmds
import maya.api.OpenMaya as om

def rad_to_deg(rad = [0,0,0]):
     deg = om.MAngle.kDegrees
     ang = om.MAngle
     angles = [angle.asRadians() for angle in (ang(rad[0],deg), ang(rad[1],deg), ang(rad[2],deg))]
     return om.MVector(angles)

def deg_to_rad(deg = [0,0,0]):
     rad = om.MAngle.kRadians
     ang = om.MAngle
     rotate = [angle.asDegrees() for angle in (ang(deg[0],rad), ang(deg[1],rad), ang(deg[2],rad))]
     return om.MVector(rotate)


def compNames(name, components, attr='vtx'):
    results = []
    for c in components:
        results.append(name+'.%s[%s]'%(attr, str(c)))
    return results

def getFaceMatrix(mesh, faceId, point):
    meshFn = getMeshFn(mesh)
    space = om.MSpace.kWorld

    itMeshPly = getMItMeshPolygon(mesh)
    itMeshPly.setIndex(faceId)
    vtxIds = itMeshPly.getVertices()

    normal = om.MVector()
    tangent = om.MVector()
    binormal = om.MVector()

    print(compNames(mesh, vtxIds, attr='vtx'))
    print(compNames(mesh, [faceId], attr='f'))

    for vtx in vtxIds:
        normal += meshFn.getVertexNormal(vtx, space)
        tangent += meshFn.getFaceVertexTangent(faceId, vtx, space)
        binormal += meshFn.getFaceVertexBinormal(faceId, vtx, space)

    normal.normalize()
    tangent.normalize()
    binormal.normalize()


    pt = point
    if not isinstance(point, om.MPoint):
        pt = om.MPoint(*point)

    mm=[binormal.x, binormal.y, binormal.z, 0,
        normal.x,   normal.y,   normal.z,   0,
        tangent.x,  tangent.y,  tangent.z,  0,
        pt.x,  pt.y,  pt.z,  1]

    return om.MMatrix(mm)

def getMItMeshPolygon(mesh):
    selList = om.MSelectionList()
    selList.add(mesh)
    dagPath = selList.getDagPath(0)
    dagPath.extendToShape()

    if not dagPath.hasFn( om.MFn.kMesh ):
        return None

    itMeshPly  = om.MItMeshPolygon(dagPath)
    return itMeshPly

def getMeshFn(mesh):
    selList = om.MSelectionList()
    selList.add(mesh)
    dagPath = selList.getDagPath(0)
    dagPath.extendToShape()

    if not dagPath.hasFn( om.MFn.kMesh ):
        return None

    meshFn  = om.MFnMesh(dagPath)
    return meshFn


def getPointAtUV(mesh, u, v, uvset=None):
    meshFn = getMeshFn(mesh)
    space = om.MSpace.kWorld
    if not uvset:
        uvset = meshFn.getUVSetNames()
        uvset = uvset[0]
    for i in range(meshFn.numPolygons):
        try:
            point = meshFn.getPointAtUV(i,u,v, space=space, uvSet=uvset, tolerance=0.0)
            return point, i
        except:
            pass
    return None, None


def getUVAtPoint(mesh, position):
    meshFn = getMeshFn(mesh)
    space = om.MSpace.kWorld
    pos = om.MPoint(*position)
    uvset = meshFn.getUVSetNames()
    u,v,faceId = meshFn.getUVAtPoint(pos,space, uvSet=uvset[0])
    return u,v,faceId, uvset[0]



comp = cmds.ls(sl=1, fl=1)
mesh = comp[0].split('.')[0]
bpos = cmds.xform(comp, q=1, ws=1, bb=1)
pos = [(bpos[0]+bpos[3])/2, (bpos[1]+bpos[4])/2, (bpos[2]+bpos[5])/2]

node = cmds.createNode('transform', n= mesh+'_loc_#')
cmds.createNode('locator', n=node+'Shape', p=node)

u,v,faceids,uvset = getUVAtPoint(mesh, pos)

# setPointAtUV transform
point, faceId = getPointAtUV(mesh, u, v, uvset=uvset)
facemx = getFaceMatrix(mesh, faceId, point)
mt = om.MTransformationMatrix(facemx)
mt.reorderRotation(om.MEulerRotation.kXYZ+1)
space = om.MSpace.kWorld
cmds.setAttr(node+'.t', *mt.translation(space))
cmds.setAttr(node+'.r', *deg_to_rad(deg = mt.rotation()))