import bpy
import bmesh
import operator
import time
import math
from mathutils import Vector

# Find a mesh that contains UV mesh shape keys 
def find_uv_mesh(objects, insideModifiers=True):
	for obj in objects:
		# Requires mesh & UV channel
		if obj and obj.type == 'MESH':

			# Contains shape keys?
			if obj.data.shape_keys and len(obj.data.shape_keys.key_blocks) == 2:
				if "uv" in obj.data.shape_keys.key_blocks and "model" in obj.data.shape_keys.key_blocks:
					return obj

			if insideModifiers:
				# Find via mesh deform modifier
				if len(obj.modifiers) > 0:
					for modifier in obj.modifiers:
	 					if modifier.type == 'SURFACE_DEFORM':
	 						if modifier.target:
	 							if modifier.target.data.shape_keys and len(modifier.target.data.shape_keys.key_blocks) == 2:
	 								return modifier.target
	return None



# # Find meshes that can be wrapped aka texture meshes
def find_texture_meshes(objects):
	obj_textures = []

	for obj in objects:
		if obj and obj.type == 'MESH':
			if find_uv_mesh([obj], insideModifiers=False) == None:
				if obj not in obj_textures:
					obj_textures.append(obj)

	return obj_textures



def uv_mesh_clear(obj_uv):
	# Remove Previous Modifiers
	if "Solidify" in obj_uv.modifiers:
		obj_uv.modifiers.remove( obj_uv.modifiers["Solidify"] )
	# Remove Solidify and push modifiers



def uv_mesh_fit(obj_uv, obj_textures):
	# Clear first shape transition
	bpy.context.scene.texToolsSettings.meshtexture_wrap = 0

	# Clear modifiers first
	uv_mesh_clear(obj_uv)


	# Add solidify modifier
	modifier_solid = obj_uv.modifiers.new(name="Solidify", type='SOLIDIFY')
	modifier_solid.offset = 1
	modifier_solid.thickness = 0 #scale*0.1 #10% height
	modifier_solid.use_even_offset = True
	modifier_solid.thickness_clamp = 0
	modifier_solid.use_quality_normals = True

	min_z = obj_uv.location.z
	max_z = obj_uv.location.z
	for i in range(len(obj_textures)):
		obj = obj_textures[i]
		
		# Min Max Z
		if i == 0:
			min_z = get_bbox(obj)['min'].z
			max_z = get_bbox(obj)['max'].z
		else:
			min_z = min(min_z, get_bbox(obj)['min'].z)
			max_z = max(max_z, get_bbox(obj)['max'].z)
	
	# Set thickness
	size = max(0.1, (max_z - min_z))
	min_z-= size*0.25 #Padding
	max_z+= size*0.25
	size = (max_z - min_z)
	
	modifier_solid.thickness = size

	# Set offset
	if size > 0:
		p_z = (obj_uv.location.z - min_z) / (max_z - min_z)
		modifier_solid.offset = -(p_z-0.5)/0.5
	else:
		modifier_solid.offset = 0



def get_bbox(obj):
	corners = [obj.matrix_world @ Vector(corner) for corner in obj.bound_box]

	# Get world space Min / Max
	box_min = Vector((corners[0].x, corners[0].y, corners[0].z))
	box_max = Vector((corners[0].x, corners[0].y, corners[0].z))
	for corner in corners:
		# box_min.x = -8
		box_min.x = min(box_min.x, corner.x)
		box_min.y = min(box_min.y, corner.y)
		box_min.z = min(box_min.z, corner.z)
		
		box_max.x = max(box_max.x, corner.x)
		box_max.y = max(box_max.y, corner.y)
		box_max.z = max(box_max.z, corner.z)

	return {
		'min':box_min, 
		'max':box_max, 
		'size':(box_max-box_min),
		'center':box_min+(box_max-box_min)/2
	}