import maya.cmds as cmds
import maya.mel as mel
import maya.api.OpenMaya as om
from six.moves import range
from collections import Counter, OrderedDict
from functools import partial
from webbrowser import open_new_tab
import six, math


def GetSelection(*args, **kwargs):
	type = kwargs["type"] if "type" in kwargs else "None"
	highlight = kwargs["highlight"] if "highlight" in kwargs else False
	flatten = kwargs["flatten"] if "flatten" in kwargs else False
	allParents = kwargs["allParents"] if "allParents" in kwargs else False

	# Check if there is any args
	if len(args) > 0:
		selection, objects = [], []
		# Get selection & objects from args
		for arg in args:
			selection.extend(arg)
			objects.extend(arg)
	else:
		# Get selection
		if flatten:
			selection = cmds.ls(sl=True, l=True, fl=True)
		else:
			selection = cmds.ls(sl=True, l=True)
		
		objects = list(selection)
		
		# Get highlighted objects
		if highlight:
			objects.extend(cmds.ls(hl=True, l=True))
	
	# Get shapes
	if type == "mesh":
		shapes = cmds.ls(objects, l=True, dag=True, ni=True, o=True, typ="mesh")
	elif type == "geometry" or type == "geo":
		shapes = cmds.ls(objects, l=True, dag=True, ni=True, o=True, g=True)
	elif type == "nurbsCurve" or type == "curve":
		shapes = cmds.ls(objects, l=True, dag=True, ni=True, typ="nurbsCurve")
	elif type == "transform":
		shapes = cmds.ls(objects, l=True, dag=True, ni=True, o=True, typ="transform")
	else:
		shapes = cmds.ls(objects, l=True, dag=True, ni=True, o=True)
	
	# Get objects
	if allParents:
		objects = cmds.listRelatives(shapes, f=True, ap=True, ni=True, typ="transform")
	else:
		objects = cmds.listRelatives(shapes, f=True, p=True, ni=True, typ="transform")
	
	# Remove intermediate objects
	objects = cmds.ls(objects, l=True, ni=True)
	
	# Remove duplicates objects
	if objects is not None:
		objects = list(OrderedDict.fromkeys(objects))
	
	return selection, shapes, objects

def GetComponentType(*args, **kwargs):
	# Create default args
	selection = None
	
	# Load arguments (override default args)
	for i, arg in enumerate(args):
		if i == 0:
			selection = arg
	
	# Load keyworded arguments (override *args)
	for key, value in six.iteritems(kwargs):
		if key == "selection" or key == "sel":
			selection = value
	
	selList = om.MSelectionList()
	
	if selection is not None:
		for each in selection:
			try:
				selList.add(each)
			except:
				pass
	else:
		selList = om.MGlobal.getActiveSelectionList()
	
	filterDict = OrderedDict([("v", om.MFn.kMeshVertComponent), ("eg", om.MFn.kMeshEdgeComponent), ("fc", om.MFn.kMeshPolygonComponent), ("puv", om.MFn.kMeshMapComponent), ("pvf", om.MFn.kMeshVtxFaceComponent), ("cv", om.MFn.kCurveCVComponent)])
	
	for key, filter in six.iteritems(filterDict):
		iter = om.MItSelectionList(selList, filter)
		try:
			if iter.hasComponents() is True:
				return key
		except:
			pass
	
	return None

def Eval(msg, mode='PRINT', deferred=False):
	if deferred is False:
		if mode == 'PRINT':
			from sys import stdout; stdout.write("{}\n".format(msg))
		elif mode == 'INFO':
			om.MGlobal.displayInfo(msg)
		elif mode == 'WARNING':
			om.MGlobal.displayWarning(msg)
		elif mode == 'ERROR':
			om.MGlobal.displayError(msg)
	else:
		if mode == 'PRINT':
			cmds.evalDeferred(r'from sys import stdout; stdout.write("{}\n")'.format(msg))
		elif mode == 'INFO':
			cmds.evalDeferred(r'import maya.api.OpenMaya as om; om.MGlobal.displayInfo("'+msg+'")')
		elif mode == 'WARNING':
			cmds.evalDeferred(r'import maya.api.OpenMaya as om; om.MGlobal.displayWarning("'+msg+'")')
		elif mode == 'ERROR':
			cmds.evalDeferred(r'import maya.api.OpenMaya as om; om.MGlobal.displayError("'+msg+'")')

def Print(object, mode='PRINT', deferred=False):
	if type(object) is not list:
		Eval(object, mode, deferred)
	else:
		for obj in object:
			Eval(obj, mode, deferred)

def IsInstanced(object):
    isInstanced = False
    shapes = cmds.listRelatives(object, f=True, s=True, ni=True)
    if shapes:
        parents = cmds.listRelatives(shapes, f=True, ap=True) or []
        if len(parents) > 1:
            isInstanced = True
    return isInstanced

def getOutlinerList(object=None):
	# If object has a parent, get a list of the childrens
	if object:
		parent = cmds.listRelatives(object, parent=True, fullPath=True)
		if parent:
			return cmds.listRelatives(parent, children=True, type="transform", fullPath=True)
	# Otherwise, get list of assemblies in the scene
	return cmds.ls(long=True, assemblies=True)

def getOutlinerPosition(obj):
	# Check if objects exists
	if cmds.objExists(obj):
		# Make sure it's long names
		obj = cmds.ls(obj, long=True)[0]
		# Get a list of the outliner
		outlinerList = getOutlinerList(obj)
		# Get the position of the object in the outliner
		sourceObjPosition = outlinerList.index(obj)+1
		# Get the position of the object from the bottom of the outliner
		return sourceObjPosition - len(outlinerList)

def crossProduct(v1, v2):
	vector = om.MVector(*v1) ^ om.MVector(*v2)
	return [vector.x, vector.y, vector.z]

def normalizeVector(v1=[1, 0, 0]):
	if isinstance(v1, (list, tuple)) is True and len(v1) >= 3:
		v1 = om.MVector(v1[0], v1[1], v1[2])
		v1.normalize()
		v1 = [v1.x, v1.y, v1.z]
	return v1

def vectorBetweenPoints(point1, point2):
	return normalizeVector([point2[i] - point1[i] for i in range(len(point1))])

def vectorAvg(vectors):
	sum = om.MVector()
	
	for vector in vectors:
		sum += vector
	
	return sum / len(vectors)

def cubicRoot(number):
	return number ** (1 / 3)

def GetVertexPosition(vertex):
	id = int(vertex.split("[")[-1][:-1])
	
	vtxList = om.MSelectionList().add(vertex)
	dagPath = vtxList.getDagPath(0)
	
	vtx_iter = om.MItMeshVertex(dagPath)
	vtx_iter.setIndex(id)
	
	# Get vertex position
	position = vtx_iter.position(space=om.MSpace.kWorld)
	
	return om.MVector(position)

def GetEdgePosition(edge):
	id = int(edge.split("[")[-1][:-1])
	
	edgeList = om.MSelectionList().add(edge)
	dagPath = edgeList.getDagPath(0)
	
	edge_iter = om.MItMeshEdge(dagPath)
	edge_iter.setIndex(id)
	
	# Get edge position
	position = edge_iter.center(space=om.MSpace.kWorld)
	
	return om.MVector(position)

def GetFacePosition(face):
	id = int(face.split("[")[-1][:-1])
	
	faceList = om.MSelectionList().add(face)
	dagPath = faceList.getDagPath(0)
	
	face_iter = om.MItMeshPolygon(dagPath)
	face_iter.setIndex(id)
	
	# Get edge position
	position = face_iter.center(space=om.MSpace.kWorld)
	
	return om.MVector(position)

def GetVertexVectors(vertex):
	space = om.MSpace.kWorld
	id = int(vertex.split("[")[-1][:-1])
	
	vtxList = om.MSelectionList().add(vertex)
	dagPath = vtxList.getDagPath(0)
	
	vtx_iter = om.MItMeshVertex(dagPath)
	vtx_iter.setIndex(id)
	
	# Get vertex normal & position
	normal = vtx_iter.getNormal(space=space)
	position = vtx_iter.position(space=space)
		
	# Get all connected vertices
	cvertices = list(vtx_iter.getConnectedVertices())
	vertices_dict = {}
	
	cvtx_iter = om.MItMeshVertex(dagPath)
	while len(cvertices):
		if cvertices[0] not in vertices_dict:
			cvtx_iter.setIndex(cvertices[0])
			cvtx_position = cvtx_iter.position(space=space)
			edge_v = vectorBetweenPoints(list(position), list(cvtx_position))
			vertices_dict[cvertices[0]] = tuple([round(v, 3) for v in edge_v])
		
		del cvertices[0]
	
	# Get the most common vector
	tangent, vector_count = Counter(vertices_dict.values()).most_common(1)[0]
	
	# If no common vector is found, check for parallel vectors
	if vector_count < 2:
		all_vectors = list(vertices_dict.values())
		parallel_vectors = {k: 1 for k in all_vectors}
		while len(all_vectors) > 0:
			omV = om.MVector(all_vectors[0])
			for ov in all_vectors:
				if ov == all_vectors[0]:
					continue
				if omV.isParallel(om.MVector(ov)):
					parallel_vectors[all_vectors[0]] += 1
					del parallel_vectors[ov]
			del all_vectors[0]
		v = max(parallel_vectors, key=parallel_vectors.get)
		if parallel_vectors[v] > 1:
			tangent, vector_count = v, parallel_vectors[v]
	
	# If no parallel vector is found, use first two points
	if vector_count < 2:
		vtx_id = list(vertices_dict.keys())[0]
	else:
		vtx_id = list(vertices_dict.keys())[list(vertices_dict.values()).index(tangent)]
	
	# Calculate tangent
	cvtx_iter.setIndex(vtx_id)
	cvtx_position = cvtx_iter.position(space=space)
	tangent = vectorBetweenPoints(list(position), list(cvtx_position))
	
	return list(normal), tangent

def GetEdgeVectors(edge):
	space = om.MSpace.kWorld
	
	# Calculate normal from face vertices
	vtxFaces = cmds.polyListComponentConversion(edge, fe=True, tvf=True)
	vtxFaceList = om.MSelectionList()
	for vtxFace in vtxFaces:
		vtxFaceList.add(vtxFace)
	
	normal = om.MVector()
	count = 0
	
	dagPath, component = vtxFaceList.getComponent(0)
	fnMesh = om.MFnMesh(dagPath)
	vtxFace_itr = om.MItMeshFaceVertex(dagPath, component)
	while not vtxFace_itr.isDone():
		faceId = vtxFace_itr.faceId()
		vertexId = vtxFace_itr.vertexId()
		
		normal += fnMesh.getFaceVertexNormal(faceId, vertexId, space=space)
		count += 1
		
		vtxFace_itr.next()
	
	normal = normal / count
	
	# Get tangent
	id = int(edge.split("[")[-1][:-1])
	edgeList = om.MSelectionList().add(edge)
	dagPath = edgeList.getDagPath(0)
	
	edge_iter = om.MItMeshEdge(dagPath)
	edge_iter.setIndex(id)
	
	position = om.MPoint()
	
	vertices = [edge_iter.vertexId(0), edge_iter.vertexId(1)]
	vtx_iter = om.MItMeshVertex(dagPath)
	for vtx in vertices:
		vtx_iter.setIndex(vtx)
		position += vtx_iter.position(space=space)

	avgPos = position / len(vertices)
	tangent = vectorBetweenPoints(list(avgPos), list(edge_iter.point(1, space)))
	
	return list(normal), list(tangent)
	
def GetFaceVectors(face):
	space = om.MSpace.kWorld 
	id = int(face.split("[")[-1][:-1])
	
	faceList = om.MSelectionList().add(face)
	dagPath = faceList.getDagPath(0)
	
	face_iter = om.MItMeshPolygon(dagPath)
	face_iter.setIndex(id)
	
	# Get face normal
	normal = face_iter.getNormal(space=space)
	
	# Get all connected faces that have similar normal
	cfaces = list(face_iter.getConnectedFaces())
	faces_dict = {id: True}
	
	cface_iter = om.MItMeshPolygon(dagPath)
	while len(cfaces):
		if cfaces[0] not in faces_dict:
			cface_iter.setIndex(cfaces[0])
			cface_normal = cface_iter.getNormal(space=space)
			if normal.isEquivalent(cface_normal, 0.01):
				faces_dict[cfaces[0]] = True
				for f in cface_iter.getConnectedFaces():
					if f not in faces_dict:
						cfaces.append(f)
			else:
				faces_dict[cfaces[0]] = False
		
		del cfaces[0]
	
	# Get edge vectors from connected faces
	cfaces = [f for f, value in six.iteritems(faces_dict) if value is True]
	edges_dict = {}
	
	cedge_iter = om.MItMeshEdge(dagPath)
	for f in cfaces:
		cface_iter.setIndex(f)
		cedges = list(cface_iter.getEdges())
		
		for edge in cedges:
			if edge not in edges_dict:
				cedge_iter.setIndex(edge)
				edge_v = vectorBetweenPoints(list(cedge_iter.point(0, space)), list(cedge_iter.point(1, space)))
				edges_dict[edge] = tuple([round(v, 3) for v in edge_v])
		
	# Get the most common vector
	tangent, vector_count = Counter(edges_dict.values()).most_common(1)[0]
	
	# if no common vector is found, check for parallel vectors
	if vector_count < 2:
		all_vectors = list(edges_dict.values())
		parallel_vectors = {k: 1 for k in all_vectors}
		while len(all_vectors) > 0:
			omV = om.MVector(all_vectors[0])
			for ov in all_vectors:
				if ov == all_vectors[0]:
					continue
				if omV.isParallel(om.MVector(ov)):
					parallel_vectors[all_vectors[0]] += 1
					del parallel_vectors[ov]
			del all_vectors[0]
		v = max(parallel_vectors, key=parallel_vectors.get)
		if parallel_vectors[v] > 1:
			tangent, vector_count = v, parallel_vectors[v]
	
	# if no parallel vector is found, use first two points
	if vector_count < 2:
		# get face-relative vertices positions
		vertices_position = face_iter.getPoints(space=space)
		vertices_dict = {}
		# convert face-relative indices to object-relative indices
		for i in range(face_iter.polygonVertexCount()):
			vertices_dict[int(face_iter.vertexIndex(i))] = vertices_position[i]
		vertices_dict = OrderedDict(sorted(vertices_dict.items()))
		vertices_position = []
		for pos in six.itervalues(vertices_dict):
			vertices_position.append(pos)
			if len(vertices_position) == 2:
				break
		tangent = vectorBetweenPoints(list(vertices_position[0]), list(vertices_position[1]))
	else:
		# Get back the original vector since we needed to round the values for comparing the vectors
		edge_id = list(edges_dict.keys())[list(edges_dict.values()).index(tangent)]
		cedge_iter.setIndex(edge_id)
		tangent = vectorBetweenPoints(list(cedge_iter.point(0, space)), list(cedge_iter.point(1, space)))
		
	return list(normal), tangent

def  GetOrientationFromVectors(normal, tangent):	
	binormal = normalizeVector(crossProduct(normal, tangent))
	
	position = [0, 0, 0]
	
	tMatrix = normal + [0] + tangent + [0] + binormal + [0] + position + [1]
	mMatrix = om.MMatrix(tMatrix)
	tmMatrix = om.MTransformationMatrix(mMatrix)
	rotation = tmMatrix.rotation(False).reorder(om.MEulerRotation.kXYZ)
	rotation = [math.degrees(x + 0) for x in list(rotation)[:3]]
	
	return rotation

def  SignedVolumeOfTriangle(p1, p2, p3):
	volume = (p1 * (p2 ^ p3)) / 6
	return volume

def GetObjectVolume(object):
	# Create face list
	faces = object + ".f[*]"
	faceList = om.MSelectionList().add(faces)
	dagPath, component = faceList.getComponent(0)
	
	# Get ids list
	compFn = om.MFnSingleIndexedComponent(component)
	ids = compFn.getElements()
	
	# Get all triangle volumes
	volumes = []
	border = False
	
	# Looping through each face
	face_iter = om.MItMeshPolygon(dagPath, component)
	for id in ids:
		face_iter.setIndex(id)
		numTriangles = face_iter.numTriangles()
		# Loop each face triangle
		for num in range(numTriangles):
			triangle = face_iter.getTriangle(num, space=om.MSpace.kWorld)[0]
			volume =  SignedVolumeOfTriangle(om.MVector(triangle[0]), om.MVector(triangle[1]), om.MVector(triangle[2]))
			volumes.append(volume)
		
		# Check if face is on open border
		if border is False:
			border = face_iter.onBoundary()
	
	# Calcule sum of every triangle volumes
	volume = abs(sum(volumes))

	# Print warning if object has open borders
	if border is True:
		Print.Print("{} has open borders, which could result in unexpected scale values.".format(object), mode='WARNING', deferred=True)
	
	# Return volume cubic root
	return cubicRoot(volume)

def GetEdgeScale(edge):
	id = int(edge.split("[")[-1][:-1])
	
	edgeList = om.MSelectionList().add(edge)
	dagPath = edgeList.getDagPath(0)
	
	edge_iter = om.MItMeshEdge(dagPath)
	edge_iter.setIndex(id)
	
	# Get edge position
	scale = edge_iter.length(space=om.MSpace.kWorld)
	
	return scale

def GetFaceScale(face):
	id = int(face.split("[")[-1][:-1])
	
	faceList = om.MSelectionList().add(face)
	dagPath = faceList.getDagPath(0)
	
	face_iter = om.MItMeshPolygon(dagPath)
	face_iter.setIndex(id)
	
	# Get edge position
	scale = face_iter.getArea(space=om.MSpace.kWorld)
	
	return math.sqrt(scale)

# Create empty MEL function for proper undo/redo operations
mel.eval('proc BakeTransformations(){}')

# Main function
def PerformBakeTransformations(bakeMode=1, setObjSpc=1, clearSel=1, bakePos=1, bakeRot=1, bakeScale=1):
	# Open undo chunk
	cmds.undoInfo(ock=True, cn="BakeTransformations")
	
	# Call empty MEL function for proper undo/redo operations
	mel.eval('BakeTransformations')

	# Get selection
	selection = GetSelection(highlight=False, flatten=True)[0]

	# Check that something is selected
	if not len(selection):
		Print("Nothing selected!", mode='ERROR')
		cmds.undoInfo(cck=True)
	
	# Get object from selection
	component = selection[-1]
	selectType = GetComponentType([component])
	object = GetSelection([component], type="mesh")[2][-1] if selectType else component
	
	# Check that a component is selected
	if bakeMode == 1 and not selectType:
			Print("No component selected!", mode='ERROR')
			cmds.undoInfo(cck=True)
			return
		
	# Check that object is not an instance
	if IsInstanced(object):
		Print("Selected object is an instance and cannot be baked.", mode='ERROR')
		cmds.undoInfo(cck=True)
		return
	
	# Get object parent and outliner position
	parent = cmds.listRelatives(object, f=True, p=True)
	currentPosition = getOutlinerPosition(object)
	
	# Get pivot manipulator context and mode
	if bakeMode == 2:
		currentCtx = cmds.currentCtx()
		if currentCtx == "moveSuperContext":
			manipMode = cmds.manipMoveContext("Move", q=True, m=True)	
		elif currentCtx == "RotateSuperContext":
			manipMode = cmds.manipRotateContext("Rotate", q=True, m=True)
			if manipMode == 1:
				manipMode = 2
			elif manipMode == 2:
				manipMode = 0
			elif manipMode == 3:
				manipMode = 6	
		elif currentCtx == "scaleSuperContext":
			manipMode = cmds.manipScaleContext("Scale", q=True, m=True)
	
	# Store current units and temporarily change for centimeters
	units = cmds.currentUnit(q=True, l=True)
	cmds.currentUnit(l="cm")
	
	# Get translation
	if bakePos or not clearSel:
		# From Component
		if bakeMode == 1:
			if selectType == "v": 
				# Get vertex position
				position = GetVertexPosition(component)
			if selectType == "eg":
				# Get edge position
				position = GetEdgePosition(component)
			if selectType == "fc":
				# Get face position
				position = GetFacePosition(component)
		# From Pivot
		elif bakeMode == 2:
			# Case 1: Get move tool position
			if currentCtx == "moveSuperContext" and cmds.manipMoveContext("Move", q=True, vis=True):
				position = cmds.manipMoveContext("Move", q=True, p=True)
			elif currentCtx == "moveSuperContext" and cmds.manipMoveContext("Move", q=True, epm=True):
				position = cmds.manipMoveContext("Move", q=True, epp=True)
			# Case 2: Get rotate tool position
			elif currentCtx == "RotateSuperContext" and cmds.manipRotateContext("Rotate", q=True, vis=True):
				position = cmds.manipRotateContext("Rotate", q=True, p=True)
			elif currentCtx == "RotateSuperContext" and cmds.manipRotateContext("Rotate", q=True, epm=True):
				position = cmds.manipRotateContext("Rotate", q=True, epp=True)
			# Case 3: Get scale tool position
			elif currentCtx == "scaleSuperContext" and cmds.manipScaleContext("Scale", q=True, vis=True):
				position = cmds.manipScaleContext("Scale", q=True, p=True)
			elif currentCtx == "scaleSuperContext" and cmds.manipScaleContext("Scale", q=True, epm=True):
				position = cmds.manipScaleContext("Scale", q=True, epp=True)
			# Case 4: Get object pivot position
			else:
				rotatePivot = om.MVector(cmds.xform(object, q=True, a=True, ws=True, rp=True))
				scalePivot = om.MVector(cmds.xform(object, q=True, a=True, ws=True, sp=True))
				position = vectorAvg([rotatePivot, scalePivot])
	
	# Get rotation
	if bakeRot or not clearSel:
		# From Component
		if bakeMode == 1:
			if selectType == "v":
				# Get vertex normal and tangent
				normal, tangent = GetVertexVectors(component)
			elif selectType == "eg":
				# Get edge normal and tangent
				normal, tangent = GetEdgeVectors(component)	
			elif selectType == "fc":
				# Get face normal and tangent
				normal, tangent = GetFaceVectors(component)
		
			# Get rotation from the component normal and corresponding edge vector
			rotation =  GetOrientationFromVectors(normal, tangent)
		# From Pivot
		elif bakeMode == 2:
			rotation = cmds.manipPivot(q=True, o=True)[0]
			
			if any([currentCtx == "moveSuperContext", currentCtx == "RotateSuperContext", currentCtx == "scaleSuperContext"]):
				if any([manipMode == 0, manipMode == 4, manipMode == 10]):
					rotation = cmds.xform(object, q=True, a=True, eu=True, ro=True)
				elif manipMode == 1:
					if parent is not None:
						rotation = cmds.xform(parent[0], q=True, a=True, eu=True, ro=True)
				elif manipMode == 5:
					live = cmds.ls(l=True, lv=True)
					if len(live):
						live = cmds.listRelatives(live, f=True, p=True, ni=True, typ="transform")[0]
						rotation = cmds.xform(live, q=True, a=True, eu=True, ro=True)
	
	# Get scale
	if bakeScale:
		# From Component
		if bakeMode == 1:
			if selectType == "v":
				# Get vertex scale
				scale = GetObjectVolume(object)
			elif selectType == "eg":
				# Get edge scale
				scale = GetEdgeScale(component)	
			elif selectType == "fc":
				# Get face scale
				scale = GetFaceScale(component)
		# From Pivot
		elif bakeMode == 2:
			# Get pivot scale
			scale = GetObjectVolume(object)
	
	# Store components selection
	cmds.selectMode(co=True)
	cmds.selectType(pv=True)
	vertices = cmds.ls(sl=True, l=True)
	cmds.selectType(pe=True)
	edges = cmds.ls(sl=True, l=True)
	cmds.selectType(pf=True)
	faces = cmds.ls(sl=True, l=True)

	# Create null and apply transformations
	null = cmds.ls(cmds.group(em=True), l=True)[0]
	cmds.matchTransform(null, object)
	
	# Set translation
	if bakePos:
		# Move null
		cmds.xform(null, a=True, ws=True, t=position)
		# Move pivot
		cmds.xform(object, a=True, ws=True, piv=position)
	
	# Set rotation
	if bakeRot:
		# Rotate null
		cmds.xform(null, a=True, eu=True, roo="xyz", ro=rotation)
	
	# Set scale
	if bakeScale:
		# Scale null
		cmds.xform(null, a=True, ws=True, s=[scale, scale, scale])
	
	# Freeze null transformations
	cmds.makeIdentity(null, a=True, t=1-bakePos, r=1-bakeRot, s=1-bakeScale, n=False, pn=True)
	
	# Parent object to null
	if parent is not None:
		null = cmds.ls(cmds.parent(null, parent), l=True)[0]
	
	object = cmds.ls(cmds.parent(object, null), l=True)[0]
	
	# Freeze object transformations
	cmds.makeIdentity(object, a=True, t=bakePos, r=bakeRot, s=bakeScale, n=False, pn=True)
	
	# Unparent object from null
	if parent is not None:
		object = cmds.ls(cmds.parent(object, parent), l=True)[0]
	else:
		object = cmds.ls(cmds.parent(object, w=True), l=True)[0]
	
	# Delete null
	cmds.delete(null)
	
	# Restore outliner position
	cmds.reorder(object, relative=currentPosition)
	
	# Restore components selection
	cmds.selectMode(co=True)
	cmds.selectType(pv=True)
	cmds.select(vertices, r=True)
	cmds.selectType(pe=True)
	cmds.select(edges, r=True)
	cmds.selectType(pf=True)
	cmds.select(faces, r=True)

	# Select object
	if clearSel:
		cmds.selectMode(o=True)
		cmds.select(object, r=True)
	elif selectType is not None:
		mel.eval("selectType -"+selectType+" 1;")
		cmds.select(selection, r=True)
	
	# Set tools axis to object space
	if setObjSpc:
		cmds.manipMoveContext("Move", e=True, m=0)
		cmds.manipRotateContext("Rotate", e=True, m=0)
		cmds.manipScaleContext("Scale", e=True, m=0)
	elif bakeMode == 2:
		cmds.manipPivot(p=position, o=rotation)
	
	# Recover units
	cmds.currentUnit(l=units)
	
	# Close undo chunk
	cmds.undoInfo(cck=True)

# Create a new partial class to print the correct command name when undoing
class rpartial(partial):
	def __repr__(self):
		return __name__.split(".")[-1]

# Create window
class BakeTransformations(object):
	def __init__(self, optionBox=False, *args, **kwargs):
		# Create default variables
		self.pfx = "BT_"
		self.windowName = self.pfx + "Window"
		self.windowSizeMenuItem = self.pfx + "SaveWindowSize_menuItem"

		self.windowTitle = "Bake Transformations"
		self.runLabel = "Bake"
		self.windowSize = [546, 350]

		# Create option variables
		self.saveWindowSize = self.pfx + "SaveWindowSize"
		self.bakeMode = self.pfx + "BakeMode"
		self.setObjSpc = self.pfx + "SetObjSpc"
		self.clearSel = self.pfx + "ClearSel"
		self.bakePos = self.pfx + "BakePos"
		self.bakeRot = self.pfx + "BakeRot"
		self.bakeScale = self.pfx + "BakeScale"

		# Create window or run command
		if optionBox is True:
			self.createWindow()
		else:
			self.runCmd(closeWindow=False, **kwargs)
	
	# Help command
	def helpCmd(self, *args):
		open_new_tab("https://gabrielnadeau.com/pages/gn-baketransformations")
	
	# Run command
	def runCmd(self, closeWindow, **kwargs):
		# Get option variables
		self.defaultSettings(reset=False)
		
		if "bakeMode" in kwargs:
			bakeMode = kwargs["bakeMode"]
		else:
			bakeMode = cmds.optionVar(q=self.bakeMode)
		
		if "setObjSpc" in kwargs:
			setObjSpc = kwargs["setObjSpc"]
		else:
			setObjSpc = cmds.optionVar(q=self.setObjSpc)
		
		if "clearSel" in kwargs:
			clearSel = kwargs["clearSel"]
		else:
			clearSel = cmds.optionVar(q=self.clearSel)
		
		if "bakePos" in kwargs:
			bakePos = kwargs["bakePos"]
		else:
			bakePos = cmds.optionVar(q=self.bakePos)
		
		if "bakeRot" in kwargs:
			bakeRot = kwargs["bakeRot"]
		else:
			bakeRot = cmds.optionVar(q=self.bakeRot)
		
		if "bakeScale" in kwargs:
			bakeScale = kwargs["bakeScale"]
		else:
			bakeScale = cmds.optionVar(q=self.bakeScale)
		
		# Bake Transformations
		PerformBakeTransformations(bakeMode, setObjSpc, clearSel, bakePos, bakeRot, bakeScale)
		
		# Close window if specified
		if closeWindow is True:
			self.closeWindow()
	
	# Close window
	def closeWindow(self):
		if cmds.window(self.windowName, ex=True) is True:
			cmds.evalDeferred('import maya.cmds as cmds; cmds.deleteUI("'+self.windowName+'", wnd=True)')
			
	# Window size
	def resizeWindow(self):
		if cmds.optionVar(q=self.saveWindowSize) == 0:
			cmds.window(self.windowName, e=True, wh=self.windowSize)
	
	# Default settings
	def defaultSettings(self, reset=False):
		if cmds.optionVar(ex=self.saveWindowSize) == 0:
			cmds.optionVar(iv=(self.saveWindowSize, 1))
		if reset is True or cmds.optionVar(ex=self.bakeMode) == 0:
			cmds.optionVar(iv=(self.bakeMode, 1))
		if reset is True or cmds.optionVar(ex=self.setObjSpc) == 0:
			cmds.optionVar(iv=(self.setObjSpc, 1))
		if reset is True or cmds.optionVar(ex=self.clearSel) == 0:
			cmds.optionVar(iv=(self.clearSel, 1))
		if reset is True or cmds.optionVar(ex=self.bakePos) == 0:
			cmds.optionVar(iv=(self.bakePos, 1))
		if reset is True or cmds.optionVar(ex=self.bakeRot) == 0:
			cmds.optionVar(iv=(self.bakeRot, 1))
		if reset is True or cmds.optionVar(ex=self.bakeScale) == 0:
			cmds.optionVar(iv=(self.bakeScale, 1))
	
	# Reset settings
	def resetSettings(self, *args):
		self.defaultSettings(reset=True)
		self.windowSetup()
	
	# Save settings
	def saveSettings(self, *args):
		cmds.optionVar(iv=(self.saveWindowSize, cmds.menuItem(self.windowSizeMenuItem, q=True, cb=True)))
		cmds.optionVar(iv=(self.bakeMode, cmds.radioButtonGrp(self.bakeMode, q=True, sl=True)))
		cmds.optionVar(iv=(self.setObjSpc, cmds.checkBoxGrp(self.setObjSpc, q=True, v1=True)))
		cmds.optionVar(iv=(self.clearSel, cmds.checkBoxGrp(self.clearSel, q=True, v1=True)))
		cmds.optionVar(iv=(self.bakePos, cmds.checkBoxGrp(self.bakePos, q=True, v1=True)))
		cmds.optionVar(iv=(self.bakeRot, cmds.checkBoxGrp(self.bakeRot, q=True, v1=True)))
		cmds.optionVar(iv=(self.bakeScale, cmds.checkBoxGrp(self.bakeScale, q=True, v1=True)))
	
	# Setup window
	def windowSetup(self):
		cmds.menuItem(self.windowSizeMenuItem, e=True, cb=cmds.optionVar(q=self.saveWindowSize))
		cmds.radioButtonGrp(self.bakeMode, e=True, sl=cmds.optionVar(q=self.bakeMode))
		cmds.checkBoxGrp(self.setObjSpc, e=True, v1=cmds.optionVar(q=self.setObjSpc))
		cmds.checkBoxGrp(self.clearSel, e=True, v1=cmds.optionVar(q=self.clearSel))
		cmds.checkBoxGrp(self.bakePos, e=True, v1=cmds.optionVar(q=self.bakePos))
		cmds.checkBoxGrp(self.bakeRot, e=True, v1=cmds.optionVar(q=self.bakeRot))
		cmds.checkBoxGrp(self.bakeScale, e=True, v1=cmds.optionVar(q=self.bakeScale))
		self.saveSettings()
	
	def initializeWindow(self):
		cmds.showWindow(self.windowName)
		self.resizeWindow()
		cmds.setFocus(self.windowName)
		
	# Create window
	def createWindow(self):
		# If window already opened, set focus on it
		if cmds.window(self.windowName, ex=True) is True:
			self.initializeWindow()
			return
		
		# Window
		cmds.window(self.windowName, t=self.windowTitle, mb=True, wh=self.windowSize)
		
		# Edit Menu
		cmds.menu(l="Edit")
		cmds.menuItem(l="Save Settings", c=partial(self.saveSettings), ecr=False)
		cmds.menuItem(l="Reset Settings", c=partial(self.resetSettings), ecr=False)
		cmds.menuItem(d=True)
		cmds.menuItem(self.windowSizeMenuItem, l="Save Window Size", c=partial(self.saveSettings), cb=False, ecr=False)
		cmds.setParent("..")
		
		# Help Menu
		cmds.menu(l="Help", helpMenu=True)
		cmds.menuItem(l="Help on "+self.windowTitle, i="help.png", c=partial(self.helpCmd), ecr=False)
		cmds.setParent("..")
		
		# Window Form (START)
		cmds.formLayout(self.pfx+"windowForm")
		
		# Tab Layout (START)
		cmds.tabLayout(self.pfx+"tabLayout", tv=False)
		cmds.formLayout(self.pfx+"tabForm")
		
		# Scroll Layout (START)
		cmds.scrollLayout(self.pfx+"scrollLayout", cr=True)
		cmds.formLayout(self.pfx+"scrollForm")
		
		# Description Frame (START)
		cmds.frameLayout(self.pfx+"Description_frameLayout", cll=True, l="Description", li=5, bgs=True, mh=4, mw=0)
		
		# Description Column (START)
		cmds.columnLayout(cat=("left", 20), adj=1)
		
		# Description
		cmds.text(l="Bakes selected component or current tool pivot transformations on object.", al="left")
		cmds.setParent("..")
		
		# Description Column (END)
		cmds.setParent("..")
		
		# Settings Frame (START)
		cmds.frameLayout(self.pfx+"Settings_frameLayout", cll=True, l="Settings", li=5, bgs=True, mh=4, mw=0)
		
		# Settings Column (START)
		cmds.columnLayout(cat=("left", 0), adj=1)
		
		# Space
		cmds.checkBoxGrp(self.setObjSpc, l1="Set tools axis to object space", cat=(1, "left", 143), cc=partial(self.saveSettings))
		
		# Clear
		cmds.checkBoxGrp(self.clearSel, l1="Set selection type to object", cat=(1, "left", 143), cc=partial(self.saveSettings))
		
		# Separation
		cmds.rowLayout(h=3)
		cmds.setParent("..")
		cmds.rowLayout(h=2, bgc=[0.266, 0.266, 0.266])
		cmds.setParent("..")
		cmds.rowLayout(h=3)
		cmds.setParent("..")
		
		# Bake
		cmds.rowLayout(nc=2, cw=(1, 134), cat=(1, "right", 0), ct2=("left", "left"))
		cmds.text(l="Bake:")
		cmds.radioButtonGrp(self.bakeMode, nrb=2, l="", la2=("Component", "Pivot"), cw3=(4, 110, 110), cc=partial(self.saveSettings))
		cmds.setParent("..")
		
		# Transformations
		cmds.rowLayout(nc=2, cw=(1, 134), cat=(1, "right", 0), ct2=("left", "left"))
		cmds.text(l="Transformations:")
		cmds.checkBoxGrp(self.bakePos, l1="Translation", cat=(1, "left", 6), cc=partial(self.saveSettings))
		cmds.setParent("..")
		
		cmds.checkBoxGrp(self.bakeRot, l1="Rotation", cat=(1, "left", 143), cc=partial(self.saveSettings))
		cmds.checkBoxGrp(self.bakeScale, l1="Scale", cat=(1, "left", 143), cc=partial(self.saveSettings))
		
		# Settings Column (END)
		cmds.setParent("..")
		
		# Settings Frame (END)
		cmds.setParent("..")
		
		# Scroll Layout (END)
		cmds.setParent("..")
		cmds.setParent("..")
		
		# Tab Layout (END)
		cmds.setParent("..")
		cmds.setParent("..")
		
		# Buttons
		cmds.formLayout(self.pfx+"Buttons_formLayout", nd=150)
		if int(cmds.about(mjv=True)) < 2020:
			cmds.iconTextButton(self.pfx+"ApplyAndClose_button", st="textOnly", l=self.runLabel, c=rpartial(self.runCmd, closeWindow=True), fla=False, h=26, rpt=True)
			cmds.iconTextButton(self.pfx+"Apply_button", st="textOnly", l="Apply", c=rpartial(self.runCmd, closeWindow=False), fla=False, h=26, rpt=True)
		else:
			cmds.iconTextButton(self.pfx+"ApplyAndClose_button", st="textOnly", l=self.runLabel, c=partial(self.runCmd, closeWindow=True), fla=False, h=26, rpt=True)
			cmds.iconTextButton(self.pfx+"Apply_button", st="textOnly", l="Apply", c=partial(self.runCmd, closeWindow=False), fla=False, h=26, rpt=True)
		cmds.iconTextButton(self.pfx+"Close_button", st="textOnly", l="Close", c=partial(self.closeWindow), fla=False, h=26, rpt=True)
		cmds.setParent("..")
		
		# Window Form (END)
		cmds.setParent("..")
		
		# Window Form Layout
		cmds.formLayout(self.pfx+"windowForm", e=True,
			af=[(self.pfx+"tabLayout", "top", 0), (self.pfx+"tabLayout", "left", 0), (self.pfx+"tabLayout", "right", 0), (self.pfx+"tabLayout", "bottom", 36)])
		
		cmds.formLayout(self.pfx+"windowForm", e=True,
			ac=(self.pfx+"Buttons_formLayout", "top", 5, self.pfx+"tabLayout"),
			af=[(self.pfx+"Buttons_formLayout", "left", 5), (self.pfx+"Buttons_formLayout", "right", 5)],
			an=(self.pfx+"Buttons_formLayout", "bottom"))
		
		# Tabs Form Layout
		cmds.formLayout(self.pfx+"tabForm", e=True,
			af=[(self.pfx+"scrollLayout", "top", 2), (self.pfx+"scrollLayout", "left", 2), (self.pfx+"scrollLayout", "right", 2), (self.pfx+"scrollLayout", "bottom", 2)])
		
		# Scroll Form Layout
		cmds.formLayout(self.pfx+"scrollForm", e=True,
			af=[(self.pfx+"Description_frameLayout", "top", 0), (self.pfx+"Description_frameLayout", "left", 0), (self.pfx+"Description_frameLayout", "right", 0)],
			an=(self.pfx+"Description_frameLayout", "bottom"))
		
		cmds.formLayout(self.pfx+"scrollForm", e=True,
			ac=(self.pfx+"Settings_frameLayout", "top", 0, self.pfx+"Description_frameLayout"),
			af=[(self.pfx+"Settings_frameLayout", "left", 0), (self.pfx+"Settings_frameLayout", "right", 0)],
			an=(self.pfx+"Settings_frameLayout", "bottom"))
		
		# Buttons Form Layout
		cmds.formLayout(self.pfx+"Buttons_formLayout", e=True,
			af=[(self.pfx+"ApplyAndClose_button", "top", 0), (self.pfx+"ApplyAndClose_button", "left", 0)],
			ap=(self.pfx+"ApplyAndClose_button", "right", 2, 50),
			an=(self.pfx+"ApplyAndClose_button", "bottom"))
		
		cmds.formLayout(self.pfx+"Buttons_formLayout", e=True,
			af=(self.pfx+"Apply_button", "top", 0),
			ap=[(self.pfx+"Apply_button", "left", 2, 50), (self.pfx+"Apply_button", "right", 2, 100)],
			an=(self.pfx+"Apply_button", "bottom"))
			
		cmds.formLayout(self.pfx+"Buttons_formLayout", e=True,
			af=[(self.pfx+"Close_button", "top", 0), (self.pfx+"Close_button", "right", 0)],
			ap=(self.pfx+"Close_button", "left", 2, 100),
			an=(self.pfx+"Close_button", "bottom"))
		
		# Window Setup
		self.defaultSettings(reset=False)
		self.windowSetup()
		self.initializeWindow()