#
#  duplicaeOnSurface.py
#
#
# ----------------------------------------------------------------------------
# "THE BEER-WARE LICENSE" (Revision 42):
# <michitaka_inoue@icloud.com> wrote this file.  As long as you retain this
# notice you can do whatever you want with this stuff. If we meet some day,
# and you think this stuff is worth it, you can buy me a beer in return.
# -Michitaka Inoue
# ----------------------------------------------------------------------------
#

from maya import OpenMaya
from maya import OpenMayaUI
from maya import OpenMayaMPx
from maya import cmds
try:
    from PySide.QtGui import QApplication
    from PySide import QtCore
except ImportError:
    from PySide2.QtWidgets import QApplication
    from PySide2 import QtCore
import math
import sys


DRAGGER = "duplicateOverSurfaceDragger"
UTIL = OpenMaya.MScriptUtil()


kPluginCmdName = "duplicateOverSurface"
kRotationFlag = "-r"
kRotationFlagLong = "-rotation"
kDummyFlag = "-d"
kDummyFlagLong = "-dummy"
kInstanceFlag = "-ilf"
kInstanceFlagLong = "-instanceLeaf"


# Syntax creator
def syntaxCreator():
    syntax = OpenMaya.MSyntax()
    syntax.addArg(OpenMaya.MSyntax.kString)
    syntax.addFlag(
        kDummyFlag,
        kDummyFlagLong,
        OpenMaya.MSyntax.kBoolean)
    syntax.addFlag(
        kRotationFlag,
        kRotationFlagLong,
        OpenMaya.MSyntax.kBoolean)
    syntax.addFlag(
        kInstanceFlag,
        kInstanceFlagLong,
        OpenMaya.MSyntax.kBoolean)
    return syntax


class DuplicateOverSurface(OpenMayaMPx.MPxCommand):

    def __init__(self):
        super(DuplicateOverSurface, self).__init__()

        self.ANCHOR_POINT = None
        self.DUPLICATED = None
        self.SOURCE = None
        self.SCALE_ORIG = None
        self.MATRIX_ORIG = None
        self.TARGET_FNMESH = None
        self.MOD_FIRST = None
        self.MOD_POINT = None
        self.SPACE = OpenMaya.MSpace.kWorld

        self.ROTATION = True
        self.InstanceFlag = False

        self.SHIFT = QtCore.Qt.ShiftModifier
        self.CTRL = QtCore.Qt.ControlModifier

    def doIt(self, args):

        # Parse the arguments.
        argData = OpenMaya.MArgDatabase(syntaxCreator(), args)
        self.SOURCE = argData.commandArgumentString(0)
        if argData.isFlagSet(kRotationFlag) is True:
            self.ROTATION = argData.flagArgumentBool(kRotationFlag, 0)

        if argData.isFlagSet(kInstanceFlag) is True:
            self.InstanceFlag = argData.flagArgumentBool(kInstanceFlag, 0)

        cmds.setToolTo(self.setupDragger())

    def setupDragger(self):
        """ Setup dragger context command """

        try:
            cmds.deleteUI(DRAGGER)
        except:
            pass

        dragger = cmds.draggerContext(
            DRAGGER,
            pressCommand=self.pressEvent,
            dragCommand=self.dragEvent,
            releaseCommand=self.releaseEvent,
            space='screen',
            projection='viewPlane',
            undoMode='step',
            cursor='hand')

        return dragger

    def pressEvent(self):
        button = cmds.draggerContext(DRAGGER, query=True, button=True)

        # Leave the tool by middle click
        if button == 2:
            cmds.setToolTo('selectSuperContext')
            return

        # Get clicked point in viewport screen space
        pressPosition = cmds.draggerContext(DRAGGER, query=True, ap=True)
        x = pressPosition[0]
        y = pressPosition[1]

        self.ANCHOR_POINT = [x, y]

        # Convert
        point_in_3d, vector_in_3d = convertTo3D(x, y)

        # Get MFnMesh of snap target
        targetDagPath = getDagPathFromScreen(x, y)

        # If draggin outside of objects
        if targetDagPath is None:
            return

        # Get origianl scale information
        self.SCALE_ORIG = cmds.getAttr(self.SOURCE + ".scale")[0]
        self.MATRIX_ORIG = cmds.xform(self.SOURCE, q=True, matrix=True)
        self.TARGET_FNMESH = OpenMaya.MFnMesh(targetDagPath)

        transformMatrix = self.getMatrix(
            point_in_3d,
            vector_in_3d,
            self.TARGET_FNMESH,
            self.SCALE_ORIG,
            self.MATRIX_ORIG)

        if transformMatrix is None:
            return

        # Create new object to snap
        self.DUPLICATED = self.getNewObject()

        # Reset transform of current object
        cmds.setAttr(self.DUPLICATED + ".translate", *[0, 0, 0])

        location = [-i for i
                    in cmds.xform(self.DUPLICATED, q=True, ws=True, rp=True)]
        cmds.setAttr(self.DUPLICATED + ".translate", *location)

        # Can't apply freeze to instances
        if self.InstanceFlag is not True:
            cmds.makeIdentity(self.DUPLICATED, apply=True, t=True)

        # Apply transformMatrix to the new object
        cmds.xform(self.DUPLICATED, matrix=transformMatrix)

    def getNewObject(self):
        return cmds.duplicate(self.SOURCE, ilf=self.InstanceFlag)[0]

    def dragEvent(self):
        """ Event while dragging a 3d view """

        if self.TARGET_FNMESH is None:
            return

        dragPosition = cmds.draggerContext(
            DRAGGER,
            query=True,
            dragPoint=True)

        x = dragPosition[0]
        y = dragPosition[1]

        modifier = cmds.draggerContext(
            DRAGGER,
            query=True,
            modifier=True)

        if modifier == "none":
            self.MOD_FIRST = True

        qtModifier = QApplication.keyboardModifiers()

        if qtModifier == self.CTRL or qtModifier == self.SHIFT:

            # If this is the first click of dragging
            if self.MOD_FIRST is True:
                self.MOD_POINT = [x, y]

                # global MOD_FIRST
                self.MOD_FIRST = False

            length, degree = self.getDragInfo(x, y)

            if qtModifier == self.CTRL:
                length = 1.0
            if qtModifier == self.SHIFT:
                degree = 0.0

            # Convert
            point_in_3d, vector_in_3d = convertTo3D(
                self.MOD_POINT[0],
                self.MOD_POINT[1])
        else:
            point_in_3d, vector_in_3d = convertTo3D(x, y)
            length = 1.0
            degree = 0.0

        # Get new transform matrix for new object
        transformMatrix = self.getMatrix(
            point_in_3d,
            vector_in_3d,
            self.TARGET_FNMESH,
            self.SCALE_ORIG,
            self.MATRIX_ORIG,
            length,
            degree
            )

        if transformMatrix is None:
            return

        # Apply new transform
        cmds.xform(self.DUPLICATED, matrix=transformMatrix)
        cmds.setAttr(self.DUPLICATED + ".shear", *[0, 0, 0])

        cmds.refresh(currentView=True, force=True)

    def releaseEvent(self):
        self.MOD_FIRST = True

    def getDragInfo(self, x, y):
        """ Get distance and angle in screen space. """

        start_x = self.MOD_POINT[0]
        start_y = self.MOD_POINT[1]
        end_x = x
        end_y = y

        cathetus = end_x - start_x
        opposite = end_y - start_y

        # Get distance using Pythagorean theorem
        length = math.sqrt(
            math.pow(cathetus, 2) + math.pow(opposite, 2))

        try:
            theta = cathetus / length
            degree = math.degrees(math.acos(theta))
            if opposite < 0:
                degree = -degree
            return cathetus, degree
        except ZeroDivisionError:
            return None, None

    def getIntersection(self, point_in_3d, vector_in_3d, fnMesh):
        """ Return a point Position of intersection..
            Args:
                point_in_3d  (OpenMaya.MPoint)
                vector_in_3d (OpenMaya.mVector)
            Returns:
                OpenMaya.MFloatPoint : hitPoint
        """

        hitPoint = OpenMaya.MFloatPoint()
        hitFacePtr = UTIL.asIntPtr()
        idSorted = False
        testBothDirections = False
        faceIDs = None
        triIDs = None
        accelParam = None
        hitRayParam = None
        hitTriangle = None
        hitBary1 = None
        hitBary2 = None
        maxParamPtr = 99999

        # intersectPoint = OpenMaya.MFloatPoint(
        result = fnMesh.closestIntersection(
            OpenMaya.MFloatPoint(
                point_in_3d.x,
                point_in_3d.y,
                point_in_3d.z),
            OpenMaya.MFloatVector(vector_in_3d),
            faceIDs,
            triIDs,
            idSorted,
            self.SPACE,
            maxParamPtr,
            testBothDirections,
            accelParam,
            hitPoint,
            hitRayParam,
            hitFacePtr,
            hitTriangle,
            hitBary1,
            hitBary2)

        faceID = UTIL.getInt(hitFacePtr)

        if result is True:
            return hitPoint, faceID
        else:
            return None, None

    def getMatrix(self,
                  mPoint,
                  mVector,
                  targetFnMesh,
                  scale_orig,
                  matrix_orig,
                  scale_plus=1,
                  degree_plus=0.0):

        """ Return a list of values which consist a new transform matrix.
            Args:
                mPoint  (OpenMaya.MPoint)
                mVector (OpenMaya.MVector)
            Returns:
                list : 16 values for matrixs
        """
        # Position of new object
        OP, faceID = self.getIntersection(mPoint, mVector, targetFnMesh)

        # If it doesn't intersect to any geometries, return None
        if OP is None and faceID is None:
            return None

        qtMod = QApplication.keyboardModifiers()
        if qtMod == (self.CTRL | self.SHIFT):
            OP = getClosestVertex(OP, faceID, targetFnMesh)

        # Get normal vector and tangent vector
        if self.ROTATION is False:
            NV = OpenMaya.MVector(
                matrix_orig[4],
                matrix_orig[5],
                matrix_orig[6])
            NV.normalize()
            TV = OpenMaya.MVector(
                matrix_orig[0],
                matrix_orig[1],
                matrix_orig[2])
            TV.normalize()
        else:
            NV = self.getNormal(OP, targetFnMesh)
            TV = self.getTangent(faceID, targetFnMesh)

        # Ctrl-hold rotation
        if qtMod == self.CTRL:
            try:
                rad = math.radians(degree_plus)
                q1 = NV.x * math.sin(rad / 2)
                q2 = NV.y * math.sin(rad / 2)
                q3 = NV.z * math.sin(rad / 2)
                q4 = math.cos(rad / 2)
                TV = TV.rotateBy(q1, q2, q3, q4)
            except TypeError:
                pass

        # Bitangent vector
        BV = TV ^ NV
        BV.normalize()

        # 4x4 Transform Matrix
        try:
            x = scale_orig[0] * (scale_plus / 100 + 1.0)
            y = scale_orig[1] * (scale_plus / 100 + 1.0)
            z = scale_orig[2] * (scale_plus / 100 + 1.0)
            TV *= x
            NV *= y
            BV *= z
        except TypeError:
            pass
        finally:
            matrix = [
                TV.x, TV.y, TV.z, 0,
                NV.x, NV.y, NV.z, 0,
                BV.x, BV.y, BV.z, 0,
                OP.x, OP.y, OP.z, 1
            ]

        return matrix

    def getTangent(self, faceID, targetFnMesh):
        """ Return a tangent vector of a face.
            Args:
                faceID  (int)
                mVector (OpenMaya.MVector)
            Returns:
                OpenMaya.MVector : tangent vector
        """

        tangentArray = OpenMaya.MFloatVectorArray()
        targetFnMesh.getFaceVertexTangents(
            faceID,
            tangentArray,
            self.SPACE)
        numOfVtx = tangentArray.length()
        x = sum([tangentArray[i].x for i in range(numOfVtx)]) / numOfVtx
        y = sum([tangentArray[i].y for i in range(numOfVtx)]) / numOfVtx
        z = sum([tangentArray[i].z for i in range(numOfVtx)]) / numOfVtx
        tangentVector = OpenMaya.MVector()
        tangentVector.x = x
        tangentVector.y = y
        tangentVector.z = z
        tangentVector.normalize()

        return tangentVector

    def getNormal(self, pointPosition, targetFnMesh):
        """ Return a normal vector of a face.
            Args:
                pointPosition  (OpenMaya.MFloatPoint)
                targetFnMesh (OpenMaya.MFnMesh)
            Returns:
                OpenMaya.MVector : tangent vector
                int              : faceID
        """

        ptr_int = UTIL.asIntPtr()
        origin = OpenMaya.MPoint(pointPosition)
        normal = OpenMaya.MVector()
        targetFnMesh.getClosestNormal(
            origin,
            normal,
            self.SPACE,
            ptr_int)
        normal.normalize()

        return normal


# Creator
def cmdCreator():
    return OpenMayaMPx.asMPxPtr(DuplicateOverSurface())


def initializePlugin(mObject):
    mPlugin = OpenMayaMPx.MFnPlugin(mObject, "Michitaka Inoue")
    try:
        mPlugin.registerCommand(kPluginCmdName, cmdCreator)
        mPlugin.setVersion("0.10")
    except:
        sys.stderr.write("Failed to register command: %s\n" % kPluginCmdName)
        raise


def uninitializePlugin(mObject):
    mPlugin = OpenMayaMPx.MFnPlugin(mObject)
    try:
        mPlugin.deregisterCommand(kPluginCmdName)
    except:
        sys.stderr.write("Failed to unregister command: %s\n" % kPluginCmdName)


def convertTo3D(screen_x, screen_y):
    """ Return point and vector of clicked point in 3d space.
        Args:
            screen_x  (int)
            screen_y (int)
        Returns:
            OpenMaya.MPoint : point_in_3d
            OpenMaya.MVector : vector_in_3d
    """
    point_in_3d = OpenMaya.MPoint()
    vector_in_3d = OpenMaya.MVector()

    OpenMayaUI.M3dView.active3dView().viewToWorld(
        int(screen_x),
        int(screen_y),
        point_in_3d,
        vector_in_3d)

    return point_in_3d, vector_in_3d


def getDagPathFromScreen(x, y):
    """ Args:
            x  (int or float)
            y (int or float)
        Returns:
            dagpath : OpenMaya.MDagPath
    """
    # Select from screen
    OpenMaya.MGlobal.selectFromScreen(
        int(x),
        int(y),
        OpenMaya.MGlobal.kReplaceList,
        OpenMaya.MGlobal.kSurfaceSelectMethod)

    # Get dagpath, or return None if fails
    tempSel = OpenMaya.MSelectionList()
    OpenMaya.MGlobal.getActiveSelectionList(tempSel)
    dagpath = OpenMaya.MDagPath()
    if tempSel.length() == 0:
        return None
    else:
        tempSel.getDagPath(0, dagpath)
        return dagpath


def getClosestVertex(point_orig, faceID, fnMesh):
    """ Args:
            point_orig  (OpenMaya.MFloatPoint)
            faceID (int)
            fnMesh (OpenMaya.MFnMesh)
        Returns:
            closestPoint : OpenMaya.MPoint
    """

    vertexIndexArray = OpenMaya.MIntArray()
    fnMesh.getPolygonVertices(faceID, vertexIndexArray)
    basePoint = OpenMaya.MPoint(point_orig)
    closestPoint = OpenMaya.MPoint()
    length = 99999.0
    for index in vertexIndexArray:
        point = OpenMaya.MPoint()
        fnMesh.getPoint(index, point, OpenMaya.MSpace.kWorld)
        lengthVector = point - basePoint
        if lengthVector.length() < length:
            length = lengthVector.length()
            closestPoint = point

    return closestPoint