import bpy
from bpy.props import *
from mathutils import *
from pprint import pprint
from copy import copy
from itertools import islice
import math, struct, csv, sys
import os.path


""" FORMAT
	
	BUFFER: (min size = 4)
	- uint32 size
	- uint8 data[size]
	
	SMALLBUF: (min size = 1)
	- uint8 size
	- uint8 data[size]
	
	PART: (min size = 20)
	- uint8 flags
	- uint8 blendmode
	- uint32 voff
	- uint32 vcount
	- uint32 ioff
	- uint32 icount
	- uint8 texcount
	- smallbuf shader
	- smallbuf textures[texcount]
	
	MESH:
	- magic "SS3DMESH"
	- uint32 flags
	
	- float boundsmin[3]
	- float boundsmax[3]
	
	- buffer vdata
	- buffer idata
	- smallbuf format
	- uint8 numparts
	- part parts[numparts]
	
	minimum size = 12+24+10 = 46
"""


bl_info = {
	"name": "SS3DMESH Mesh Format (.ssm)",
	"author": "Arvīds Kokins",
	"version": (0, 5, 2),
	"blender": (2, 6, 9),
	"api": 38019,
	"location": "File > Export > SS3DMESH (.ssm)",
	"description": "SS3DMESH Mesh Export (.ssm)",
	"warning": "",
	"wiki_url": "http://cragegames.com",
	"tracker_url": "http://cragegames.com",
	"category": "Import-Export"
}


def write_smallbuf( f, bytebuf ):
	if len( bytebuf ) > 255:
		raise Exception( "smallbuf too big" )
	if type( bytebuf ) == str:
		bytebuf = bytes( bytebuf, "UTF-8" )
	f.write( struct.pack( "B", len( bytebuf ) ) )
	f.write( bytebuf )
#

def write_buffer( f, bytebuf ):
	if len( bytebuf ) > 0xffffffff:
		raise Exception( "buffer too big" )
	if type( bytebuf ) == str:
		bytebuf = bytes( bytebuf, "UTF-8" )
	f.write( struct.pack( "L", len( bytebuf ) ) )
	f.write( bytebuf )
#

def serialize_matrix( m ):
	return struct.pack( "16f",
		m[0][0], m[1][0], m[2][0], m[3][0],
		m[0][1], m[1][1], m[2][1], m[3][1],
		m[0][2], m[1][2], m[2][2], m[3][2],
		m[0][3], m[1][3], m[2][3], m[3][3] )

def write_part( f, part ):
	if len( part["textures"] ) > 8:
		raise Exception( "too many textures (max. 8 allowed)" )
	f.write( struct.pack( "=BB", part["flags"], part["blendmode"] ) )
	write_smallbuf( f, part["name"] )
	f.write( serialize_matrix( part[ "mtx" ] ) )
	f.write( struct.pack( "=LLLLB", part["voff"], part["vcount"],
		part["ioff"], part["icount"], len( part["textures"] ) ) )
	write_smallbuf( f, bytes( part["shader"], "UTF-8" ) )
	for tex in part["textures"]:
		write_smallbuf( f, tex.replace("\\", "/") )
#

def write_mesh( f, meshdata, armdata, boneorder ):
	is_skinned = armdata != None
	bbmin = meshdata["bbmin"]
	bbmax = meshdata["bbmax"]
	vertices = meshdata["vertices"]
	indices = meshdata["indices"]
	format = meshdata["format"]
	parts = meshdata["parts"]
	
	if len( parts ) > 255:
		raise Exception( "too many parts (max. 255 allowed)" )
	
	is_i32 = len( vertices ) > 65535
	
	print( "--- MESH STATS ---" )
	print( "Vertex count: %d" % ( len(vertices) ) )
	print( "Index count: %d" % ( len(indices) ) )
	print( "Format string: " + format )
	print( "Part count: %d" % ( len(parts) ) )
	for part_id, part in enumerate( parts ):
		print( "- part %d: name=%s voff=%d vcount=%d ioff=%d icount=%d flags=%d blendmode=%d texcount=%d shader='%s'" % (
			part_id, part["name"], part["voff"], part["vcount"], part["ioff"], part["icount"],
			part["flags"], part["blendmode"], len( part["textures"] ), part["shader"] ) )
	
	f.write( bytes( "SS3DMESH", "UTF-8" ) )
	# mesh data flags, 0x100 = extended mtl data, 0x200 = part name data
	f.write( struct.pack( "L", 0x100 + 0x200 +
		(1 if is_i32 else 0) * 0x01 + \
		(1 if is_skinned else 0) * 0x80 ) )
	f.write( struct.pack( "6f", bbmin.x, bbmin.y, bbmin.z, bbmax.x, bbmax.y, bbmax.z ) )
	
	vdata = bytes()
	for vertex in vertices:
		vdata += vertex
	write_buffer( f, vdata )
	
	idata = bytes()
	if( is_i32 ):
		for index in indices:
			idata += struct.pack( "L", index )
	else:
		for index in indices:
			idata += struct.pack( "H", index )
	write_buffer( f, idata )
	
	write_smallbuf( f, format )
	f.write( struct.pack( "B", len(parts) ) )
	for part in parts:
		write_part( f, part )
	
	if is_skinned:
		f.write( struct.pack( "B", len(boneorder) ) )
		for bonename in boneorder:
			bone = armdata.bones[ bonename ]
			print( "Bone found: " + bone.name )
			write_smallbuf( f, bone.name )
			pid = 255
			m = bone.matrix_local
			if bone.parent is not None:
				m = bone.parent.matrix_local.inverted() * m
				for bpid, pbone in enumerate(boneorder):
					if bone.parent.name == pbone:
						pid = bpid
						break
			#
			# print(m)
			f.write( struct.pack( "B", pid ) )
			f.write( serialize_matrix( m ) )
		#
	#
	
	return
#

def write_anims( f, anims ):
	
	print( "--- ANIMATIONS' STATS ---" )
	print( "Count: %d" % len( anims ) )
	
	f.write( bytes( "SS3DANIM", "UTF-8" ) )
	f.write( struct.pack( "L", len( anims ) ) )
	
	i = 0
	for anim in anims:
		i += 1
		print( "Animation #%d: %s" % ( i, anim["name"] ) )
		
		a_name = anim["name"]
		a_frames = anim["frames"]
		a_tracks = anim["tracks"]
		a_markers = anim["markers"]
		a_speed = anim["speed"]
		
		a_name_bytes = bytes( a_name, "UTF-8" )
		animbuf = struct.pack( "B", len(a_name_bytes) ) + a_name_bytes
		animbuf += struct.pack( "=LfBB", a_frames, a_speed, len( a_tracks ), len( a_markers ) )
		
		for track_name, track_matrices in a_tracks.items():
			track_name_bytes = bytes( track_name, "UTF-8" )
			trackbuf = struct.pack( "B", len(track_name_bytes) ) + track_name_bytes
			
			for fid in range(a_frames):
				mtx = track_matrices[ fid ]
				
				# decompose
				pos = mtx.to_translation()
				rot = mtx.to_quaternion()
				scl = mtx.to_scale()
				
				# write
				trackbuf += struct.pack( "10f",
					pos.x, pos.y, pos.z,
					rot.x, rot.y, rot.z, rot.w,
					scl.x, scl.y, scl.z
				)
			#
			
			animbuf += struct.pack( "L", len(trackbuf) ) + trackbuf
		#
		
		for marker in a_markers:
			animbuf += struct.pack( "=16sL", bytes( marker["name"], "UTF-8" ), marker["frame"] )
		
		write_buffer( f, animbuf )
	#
#

def serialize_vec3_array( arr ):
	out = bytes()
	for item in arr:
		out += struct.pack( "fff", item.x, item.y, item.z )
	return out

def serialize_quat_array( arr ):
	out = bytes()
	for item in arr:
		out += struct.pack( "ffff", item.x, item.y, item.z, item.w )
	return out

def wrap_small_string( strdata ):
	data = bytes( strdata, "UTF-8" )
	return struct.pack( "B", len(data) ) + data

def wrap_chunk( name, data ):
	return bytes( name, "UTF-8" ) + struct.pack( "L", len( data ) ) + data

def reduce_array( arr ):
	if len(arr) > 1:
		diff = False
		for item in arr:
			if item != arr[0]:
				diff = True
				break
		if diff == False:
			arr = arr[:1]
	return arr

def write_anims_anbd( f, anims ):
	
	print( "--- ANIMATIONS' STATS ---" )
	print( "Count: %d" % len( anims ) )
	
	anbd_chunk = bytes()
	
	i = 0
	for anim in anims:
		i += 1
		print( "Animation #%d: %s" % ( i, anim["name"] ) )
		
		a_name = anim["name"]
		a_frames = anim["frames"]
		a_tracks = anim["tracks"]
		a_markers = anim["markers"]
		a_speed = anim["speed"]
		
		anim_chunk = struct.pack( "fH", a_speed, a_frames )
		
		# parse animation
		float_data = bytes()
		track_data = bytes()
		track_count = 0
		
		for track_name, track_matrices in a_tracks.items():
			track_offset = len( float_data ) // 4
			pos_arr = []
			rot_arr = []
			scl_arr = []
			
			# decompose animation matrices into position/rotation/scale
			for fid in range(a_frames):
				mtx = track_matrices[ fid ]
				
				pos = mtx.to_translation()
				rot = mtx.to_quaternion()
				scl = mtx.to_scale()
				
				pos_arr.append( pos )
				rot_arr.append( rot )
				scl_arr.append( scl )
			#
			
			# see if each list is constant and reduce it if so
			pos_arr = reduce_array( pos_arr )
			rot_arr = reduce_array( rot_arr )
			scl_arr = reduce_array( scl_arr )
			
			track_data += wrap_small_string( track_name )
			track_data += struct.pack( "LHHHH", track_offset, len(pos_arr), len(rot_arr), len(scl_arr), 0 )
			track_count += 1
			
			float_data += serialize_vec3_array( pos_arr )
			float_data += serialize_quat_array( rot_arr )
			float_data += serialize_vec3_array( scl_arr )
		#
		
		# floats
		anim_chunk += struct.pack( "L", len( float_data ) // 4 ) + float_data
		
		# tracks
		anim_chunk += struct.pack( "L", track_count ) + track_data
		
		# markers
		anim_chunk += struct.pack( "L", len( a_markers ) )
		for marker in a_markers:
			anim_chunk += struct.pack( "16sH", bytes( marker["name"], "UTF-8" ), marker["frame"] )
		
		anbd_chunk += wrap_chunk( "ANIM", anim_chunk ) + wrap_small_string( a_name )
	#
	
	anbd_chunk = wrap_chunk( "SGRXANBD", anbd_chunk )
	f.write( anbd_chunk )
#

def addCached( olist, o, minpos = 0 ):
	try:
		return olist[ minpos: ].index( o )
	except:
		olist.append( o )
		return len( olist ) - 1 - minpos
#

def find_in_userdata( obj, key, default = None ):
	for prop in obj.items():
		if type( prop[ 1 ] ) in ( int, str, float, bool ):
			if prop[ 0 ] == key:
				return prop[ 1 ]
	return default
#

def parse_materials( geom_node, textures ):
	materials = []
	print( "Parsing materials... ", end="" )
	for mtl in geom_node.data.materials:
		outmtl = { "textures": [], "shader": "default", "flags": 0, "blendmode": 0 }
		for tex in  mtl.texture_slots:
			outmtl["textures"].append( textures[ tex.name ] if tex != None else "" )
		while len(outmtl["textures"]) and outmtl["textures"][-1] == "":
			outmtl["textures"].pop()
		shdr = find_in_userdata( mtl, "shader" )
		if type( shdr ) == str:
			outmtl["shader"] = shdr
		bmode = find_in_userdata( mtl, "blendmode" )
		if type( bmode ) == str:
			if bmode == "none":
				outmtl["blendmode"] = 0
			if bmode == "basic":
				outmtl["blendmode"] = 1
			if bmode == "additive":
				outmtl["blendmode"] = 2
			if bmode == "multiply":
				outmtl["blendmode"] = 3
		if find_in_userdata( mtl, "unlit", False ):
			outmtl["flags"] |= 1
		if find_in_userdata( mtl, "nocull", False ):
			outmtl["flags"] |= 2
		materials.append( outmtl )
	print( "OK!" )
	return materials

def parse_geometry( geom_node, textures, opt_boneorder, props ):
	
	if props.apply_modifiers == "NONE":
		MESH = geom_node.to_mesh( bpy.context.scene, False, "PREVIEW" )
	else:
		preview_settings = []
		if props.apply_modifiers == "SKIPARM":
			for mod in geom_node.modifiers:
				preview_settings.append( mod.show_viewport )
				if mod.type == "ARMATURE":
					mod.show_viewport = False
		#
		MESH = geom_node.to_mesh( bpy.context.scene, True, "PREVIEW" )
		if props.apply_modifiers == "SKIPARM":
			for i, mod in enumerate( geom_node.modifiers ):
				mod.show_viewport = preview_settings[ i ]
		#
	#
		
	opt_vgroups = geom_node.vertex_groups if len(geom_node.vertex_groups) else None
	
	materials = parse_materials( geom_node, textures )
	
	print( "Generating geometry for %s... " % geom_node.name, end="" )
	MESH.calc_normals_split()
	
	# SORT BY MATERIAL
	MID2FACES = {} # material index -> faces
	FACE2MID = {} # face -> material index
	
	for face in MESH.polygons:
		
		if face.material_index not in MID2FACES:
			MID2FACES[ face.material_index ] = []
		MID2FACES[ face.material_index ].append( face )
	
	# GENERATE COMPACT DATA
	Plist = []
	Nlist = []
	Tlists = [ [] for tl in MESH.uv_layers ]
	Clists = [ [] for cl in MESH.vertex_colors ]
	genParts = [] # array of Part ( array of Face ( array of Vertex ( position index, normal index, texcoord indices, color indices ) ) )
	foundMIDs = []
	
	if len( Tlists ) > 2:
		print( "Too many UV layers" )
		Tlists = Tlists[:1]
	if len( Clists ) > 1:
		print( "Too many color layers" )
		Clists = Clists[:1]
	
	for flist_id in MID2FACES:
		genPart = []
		flist = MID2FACES[ flist_id ]
		m_id = 0
		for face in flist:
			m_id = face.material_index
			if flist_id != m_id:
				continue
			
			genFace = []
			
			for vid in range( len( face.vertices ) ):
				v_id = face.vertices[ vid ]
				l_id = face.loop_start + vid
				VTX = MESH.vertices[ v_id ]
				
				pos_id = addCached( Plist, VTX.co )
				if face.use_smooth != False:
					nrm_id = addCached( Nlist, MESH.loops[ l_id ].normal )
				else:
					nrm_id = addCached( Nlist, face.normal )
				
				genVertex = [ pos_id, nrm_id ]
				
				for si in range( len( Tlists ) ):
					txc_id = addCached( Tlists[ si ], MESH.uv_layers[ si ].data[ l_id ].uv )
					genVertex.append( txc_id )
				for si in range( len( Clists ) ):
					col_id = addCached( Clists[ si ], MESH.vertex_colors[ si ].data[ l_id ].color )
					genVertex.append( col_id )
				
				if opt_vgroups != None and opt_boneorder != None:
					groupweights = []
					for vg in VTX.groups:
						for grp in opt_vgroups:
							if vg.group == grp.index:
								groupweights.append([ opt_boneorder.index( grp.name ), vg.weight ])
								break
							#
						#
					#
					# sort by importance
					groupweights.sort( key=lambda x: x[1], reverse = True )
					# trim useless
					for gwoff, gw in enumerate(groupweights):
						if gw[1] < 1.0/256.0:
							del groupweights[ gwoff: ]
							break
					# check if more than 4, warn / trim if so
					if len(groupweights) > 4:
						print( "Too many weights (%d > 4) for vertex %d at %s" % ( len(groupweights), v_id, VTX.co ) )
						del groupweights[ 4: ]
					if len(groupweights) == 0:
						groupweights.append([ 0, 1.0 ])
					# renormalize
					wsum = 0.0
					for gw in groupweights:
						wsum += gw[1]
					wsum /= 255.0
					for gw in groupweights:
						gw[1] = round( gw[1] / wsum )
					# finish quantization to bytes
					wsum = 0.0
					for gw in groupweights:
						wsum += gw[1]
					gwoff = 0
					while wsum != 255:
						sgnadd = -1 if wsum > 255 else 1
						groupweights[ gwoff ][1] += sgnadd
						wsum += sgnadd
					# compress
					while len(groupweights) < 4:
						groupweights.append([ 0, 0 ])
					gw_groups = struct.pack( "4B", groupweights[0][0], groupweights[1][0], groupweights[2][0], groupweights[3][0] )
					gw_weights = struct.pack( "4B", groupweights[0][1], groupweights[1][1], groupweights[2][1], groupweights[3][1] )
					
					genVertex.append( gw_groups )
					genVertex.append( gw_weights )
				#
				
				genFace.append( genVertex )
			genPart.append( genFace )
		genParts.append( genPart )
		foundMIDs.append( m_id )
	#
	
	# VALIDATION
	if len( Plist ) <= 0:
		raise Exception( "Mesh has no vertices!" )
	#
	
	# CONVERT TO VERTEX BUFFER FORMAT
	vertices = []
	indices = []
	parts = []
	defmtl = { "textures": [], "shader": "default", "flags": 0, "blendmode": 0 }
	
	mtl_num = -1
	for part in genParts:
		mtl_num += 1
		mtl_id = foundMIDs[ mtl_num ]
		vroot = len(vertices)
		outpart = {
			"name": geom_node.name + "#" + str(mtl_num),
			"mtx": geom_node.matrix_world,
			"voff": len(vertices),
			"vcount": 0,
			"ioff": len(indices),
			"icount": 0,
			"flags": materials[ mtl_id ]["flags"] if mtl_id in materials else defmtl["flags"],
			"blendmode": materials[ mtl_id ]["blendmode"] if mtl_id in materials else defmtl["blendmode"],
			"shader": materials[ mtl_id ]["shader"] if mtl_id in materials else defmtl["shader"],
			"textures": materials[ mtl_id ]["textures"] if mtl_id in materials else defmtl["textures"],
		}
		
		for face in part:
			tmpidcs = []
			for vertex in face:
				P = Plist[ vertex[0] ]
				N = Nlist[ vertex[1] ]
				vertexdata = struct.pack( "3f3f", P.x, P.y, P.z, N.x, N.y, N.z )
				vip = 2
				for si in range( len( Tlists ) ):
					T = Tlists[ si ][ vertex[ vip ] ]
					vip += 1
					vertexdata += struct.pack( "2f", T.x, 1 - T.y )
				for si in range( len( Clists ) ):
					C = Clists[ si ][ vertex[ vip ] ]
					vip += 1
					vertexdata += struct.pack( "4B", int(C.r * 255), int(C.g * 255), int(C.b * 255), 255 )
				if opt_vgroups != None and opt_boneorder != None:
					vertexdata += vertex[ vip ] # indices (groups)
					vip += 1
					vertexdata += vertex[ vip ] # weights
					vip += 1
				tmpidcs.append( addCached( vertices, vertexdata, vroot ) )
			#
			for i in range( 2, len( tmpidcs ) ):
				indices.append( tmpidcs[ 0 ] )
				indices.append( tmpidcs[ i ] )
				indices.append( tmpidcs[ i - 1 ] )
			#
		#
		
		outpart["vcount"] = len(vertices) - outpart["voff"]
		outpart["icount"] = len(indices) - outpart["ioff"]
		parts.append( outpart )
	#
	
	# TANGENT SPACE CALC
	if len( Tlists ) > 0:
		tan1list = [ Vector([0,0,0]) for i in range(len(vertices)) ]
		tan2list = [ Vector([0,0,0]) for i in range(len(vertices)) ]
		hitlist = [ 0 for i in range(len(vertices)) ]
		
		for part in parts:
			voff = part["voff"]
			ioff = part["ioff"]
			for i in range( 0, part["icount"], 3 ):
				i1 = indices[ ioff + i + 0 ] + voff
				i2 = indices[ ioff + i + 1 ] + voff
				i3 = indices[ ioff + i + 2 ] + voff
				
				Pdc1 = struct.unpack( "3f", vertices[ i1 ][ :12 ] )
				Pdc2 = struct.unpack( "3f", vertices[ i2 ][ :12 ] )
				Pdc3 = struct.unpack( "3f", vertices[ i3 ][ :12 ] )
				
				v1 = Vector([ Pdc1[0], Pdc1[1], Pdc1[2] ])
				v2 = Vector([ Pdc2[0], Pdc2[1], Pdc2[2] ])
				v3 = Vector([ Pdc3[0], Pdc3[1], Pdc3[2] ])
				
				Tdc1 = struct.unpack( "2f", vertices[ i1 ][ 24:32 ] )
				Tdc2 = struct.unpack( "2f", vertices[ i2 ][ 24:32 ] )
				Tdc3 = struct.unpack( "2f", vertices[ i3 ][ 24:32 ] )
				
				w1 = Vector([ Tdc1[0], Tdc1[1], 0 ])
				w2 = Vector([ Tdc2[0], Tdc2[1], 0 ])
				w3 = Vector([ Tdc3[0], Tdc3[1], 0 ])
				
				x1 = v2.x - v1.x;
				x2 = v3.x - v1.x;
				y1 = v2.y - v1.y;
				y2 = v3.y - v1.y;
				z1 = v2.z - v1.z;
				z2 = v3.z - v1.z;
				
				s1 = w2.x - w1.x;
				s2 = w3.x - w1.x;
				t1 = w2.y - w1.y;
				t2 = w3.y - w1.y;
				
				ir = s1 * t2 - s2 * t1
				if True: # abs( ir ) > 0.000001:
					r = abs( ir ) # 1.0 / ir
					sdir = Vector([(t2 * x1 - t1 * x2) * r, (t2 * y1 - t1 * y2) * r, (t2 * z1 - t1 * z2) * r])
					tdir = Vector([(s1 * x2 - s2 * x1) * r, (s1 * y2 - s2 * y1) * r, (s1 * z2 - s2 * z1) * r])
					
					tan1list[ i1 ] += sdir
					tan1list[ i2 ] += sdir
					tan1list[ i3 ] += sdir
					
					tan2list[ i1 ] += tdir
					tan2list[ i2 ] += tdir
					tan2list[ i3 ] += tdir
					
					hitlist[ i1 ] += 1
					hitlist[ i2 ] += 1
					hitlist[ i3 ] += 1
				else:
					print( "Bad triangle UV map!!! invR: %f | UV0: %f;%f | UV1: %f;%f | UV2: %f;%f" % \
						(ir, Tdc1[0],Tdc1[1],Tdc2[0],Tdc2[1],Tdc3[0],Tdc3[1]))
				#
			#
		#
		
		for v_id, vertex in enumerate( vertices ):
			Ndc = struct.unpack( "3f", vertex[ 12:24 ] )
			n = Vector([ Ndc[0], Ndc[1], Ndc[2] ])
			t = tan1list[ v_id ]
			t2 = tan2list[ v_id ]
			
			outtan = ( t - n * n.dot( t ) ).normalized()
			if outtan == Vector([0.0,0.0,0.0]):
				outtan = Vector([0.0,0.0,1.0])
				print( "Tangent was detected to be 0,0,0 on vertex %d - changed to 0,0,1" % v_id )
				Tdc = struct.unpack( "2f", vertex[ 24:32 ] )
				print( "HC: %d, Nrm: %s, Tx1: %s, Tg2: %s" % ( hitlist[ v_id ], n, Tdc, t2 ) )
			sign = -1.0 if n.cross( t ).dot( t2 ) < 0.0 else 1.0
			vertices[ v_id ] = vertex[ :24 ] + struct.pack( "4f", outtan.x, outtan.y, outtan.z, sign ) + vertex[ 24: ]
		#
	#
	
	# AABB
	bbmin = Plist[0].copy()
	bbmax = Plist[0].copy()
	for pos in Plist:
		if bbmin.x > pos.x:
			bbmin.x = pos.x
		if bbmin.y > pos.y:
			bbmin.y = pos.y
		if bbmin.z > pos.z:
			bbmin.z = pos.z
		if bbmax.x < pos.x:
			bbmax.x = pos.x
		if bbmax.y < pos.y:
			bbmax.y = pos.y
		if bbmax.z < pos.z:
			bbmax.z = pos.z
	#
	
	# FORMAT STRING
	format = "pf3nf3"
	if len( Tlists ) > 0:
		format += "tf4"
	for si in range( len( Tlists ) ):
		format += "%df2" % ( si )
	for si in range( len( Clists ) ): # only one expected
		format += "cb4"
	if opt_vgroups != None and opt_boneorder != None:
		format += "ib4wb4"
	#
	
	print( "OK!" )
	
	if MESH is not geom_node.data:
		bpy.data.meshes.remove( MESH )
	
	return {
		"bbmin": bbmin, "bbmax": bbmax,
		"vertices": vertices, "indices": indices,
		"format": format, "parts": parts,
	}
#

def gen_empty_mesh_data():
	return {
		"bbmin": Vector([ sys.float_info.max, sys.float_info.max, sys.float_info.max ]),
		"bbmax": Vector([ -sys.float_info.max, -sys.float_info.max, -sys.float_info.max ]),
		"vertices": [], "indices": [], "format": "pf3nf3", "parts": [],
	}
#

def mesh_data_add( meshdata, ndata ):
	# AABB
	if meshdata["bbmin"].x > ndata["bbmin"].x:
		meshdata["bbmin"].x = ndata["bbmin"].x
	if meshdata["bbmin"].y > ndata["bbmin"].y:
		meshdata["bbmin"].y = ndata["bbmin"].y
	if meshdata["bbmin"].z > ndata["bbmin"].z:
		meshdata["bbmin"].z = ndata["bbmin"].z
	if meshdata["bbmax"].x < ndata["bbmax"].x:
		meshdata["bbmax"].x = ndata["bbmax"].x
	if meshdata["bbmax"].y < ndata["bbmax"].y:
		meshdata["bbmax"].y = ndata["bbmax"].y
	if meshdata["bbmax"].z < ndata["bbmax"].z:
		meshdata["bbmax"].z = ndata["bbmax"].z
	
	# parts
	for part in ndata["parts"]:
		part = copy(part)
		part["voff"] += len(meshdata["vertices"])
		part["ioff"] += len(meshdata["indices"])
		meshdata["parts"].append( part )
	
	# format diff
	format_part_order = [ "pf3", "nf3", "tf4", "0f2", "1f2",
		"3f2", "4f2", "cb4", "ib4", "wb4", "DUMMY",
	]
	# - split into chunks
	oldfmt_A = meshdata["format"]
	oldfmt_B = ndata["format"]
	fmt_A = [oldfmt_A[i:i+3] for i in range(0, len(oldfmt_A), 3)] + [ "DUMMY" ]
	fmt_B = [oldfmt_B[i:i+3] for i in range(0, len(oldfmt_B), 3)] + [ "DUMMY" ]
	
	# - iterate through
	i = 0
	while i < len(fmt_A) or i < len(fmt_B):
		if fmt_A[ i ] == fmt_B[ i ]:
			i += 1
			continue
		# - formats not equal, need to pad one side
		# - pad the side whose index is higher
		if format_part_order.index( fmt_A[ i ] ) > format_part_order.index( fmt_B[ i ] ):
			fmt_tgt = fmt_A
			fmt_src = fmt_B
			data_tgt = meshdata["vertices"]
		else:
			fmt_src = fmt_A
			fmt_tgt = fmt_B
			data_tgt = ndata["vertices"]
		# - pad the format
		curfmt = fmt_src[ i ]
		fmt_tgt.insert( i, curfmt )
		# - calculate padding offset
		pad_offset = 0
		for f in islice( fmt_src, i ):
			nominal = 4 if f[1] == "f" else 1
			multiplier = int(f[2])
			pad_offset += nominal * multiplier
		# - calculate padding data
		if curfmt == "pf3" or curfmt == "nf3":
			raise Exception( "UNEXPECTED PADDING FORMAT" )
		pad_core = struct.pack( "f", 0.0 ) if curfmt[1] == "f" else struct.pack( "B", 0 )
		pad_mult = int(curfmt[2])
		pad_data = pad_core * pad_mult
		# print( "pad with %d bytes of data by format %s" % ( len(pad_data), curfmt ) )
		# - perform padding on each vertex
		for v in range( len( data_tgt ) ):
			data_tgt[ v ] = data_tgt[ v ][ : pad_offset ] + pad_data + data_tgt[ v ][ pad_offset : ]
		# - move on because formats have been made equal here
		i += 1
	#
	
	# - set new format
	meshdata["format"] = "".join( fmt_A[:-1] )
	
	# validate vertex size
	if len(meshdata["vertices"]) > 0 and len(ndata["vertices"]) > 0:
		if len(meshdata["vertices"][0]) != len(ndata["vertices"][0]):
			raise Exception(
				"Vertex sizes not equal: old=%d new=%d fmtA=%s fmtB=%s newfmtA=%s newfmtB=%s" % (
					len(meshdata["vertices"][0]),
					len(ndata["vertices"][0]),
					oldfmt_A,
					oldfmt_B,
					"".join( fmt_A[:-1] ),
					"".join( fmt_B[:-1] ),
				)
			)
	#
	
	# combine vertex/index data
	meshdata["vertices"] += ndata["vertices"]
	meshdata["indices"] += ndata["indices"]
#

def parse_armature( node ):
	for mod in node.modifiers:
		if mod.type == "ARMATURE":
			return mod.object
	return None
#

def generate_bone_order( armdata ):
	if armdata == None:
		return None
	bonelist = []
	bonequeue = []
	for bone in armdata.bones:
		if bone.parent == None:
			bonequeue.append( bone )
	#
	while len(bonequeue) != 0:
		bone = bonequeue.pop(0)
		bonelist.append( bone.name )
		for bone in bone.children:
			bonequeue.append( bone )
	#
	return bonelist
#

def parse_animations( armobj, boneorder, filepath ):
	animations = []
	if armobj is not None and armobj.animation_data is not None:
		print( "Generating animations... " )
		oldact = armobj.animation_data.action
		for action in bpy.data.actions:
			if action.use_fake_user is False:
				continue # do not export animations that are not pinned (likely to be deleted)
			armobj.animation_data.action = action
			anim_tracks = {}
			for bonename in boneorder:
				anim_tracks[ bonename ] = []
			frame_begin, frame_end = [ int(x) for x in action.frame_range ]
			for frame in range( frame_begin, frame_end + 1 ):
				bpy.context.scene.frame_set( frame )
				for bonename in boneorder:
					bone = armobj.pose.bones[ bonename ]
					track = anim_tracks[ bonename ]
					
					# input: object space pose/anim matrices (CP, CA, PP, PA)
					# output: pose space anim matrix (out)
					# out = inv( inv(PP) * CP ) * ( inv(PA) * CA )
					mtx_anim = bone.matrix
					mtx_base = bone.bone.matrix_local
					if bone.parent is not None:
						mtx_anim = bone.parent.matrix.inverted() * mtx_anim
						mtx_base = bone.parent.bone.matrix_local.inverted() * mtx_base
					mtx = mtx_base.inverted() * mtx_anim
					
					track.append( mtx )
				#
			#
			anim_markers = []
			for pmrk in action.pose_markers:
				anim_markers.append({ "name": pmrk.name, "frame": pmrk.frame })
			#
			animspeed = bpy.context.scene.render.fps / bpy.context.scene.render.fps_base
			animlistname = os.path.dirname( filepath ) + "/" + action.name + ".animlist.csv"
			print( "Looking for animation descriptor - " + animlistname )
			if os.path.isfile( animlistname ):
				print( "Found it, decoding action..." )
				try:
					animlist = csv.reader( open( animlistname, "r" ), delimiter = ",", quotechar = '"' )
					for anim in animlist:
						tstart = int(anim[0], 10)
						tend = int(anim[1], 10)
						tname = anim[2].strip()
						anim_sliced_tracks = {}
						for track_name, track_matrices in anim_tracks.items():
							anim_sliced_tracks[ track_name ] = track_matrices[ tstart : tend ]
						animations.append({ "name": tname, "frames": tend - tstart, "tracks": anim_sliced_tracks, "speed": animspeed })
					#
				except IOError as e:
					print( "I/O error({0}): {1}".format(e.errno, e.strerror) )
				except ValueError:
					print( "Could not convert data to an integer." )
				#
			else:
				print( "Did not find it, will append the whole action." )
				animations.append({ "name": action.name, "frames": frame_end - frame_begin + 1, "tracks": anim_tracks, "markers" : anim_markers, "speed": animspeed })
			#
		#
		armobj.animation_data.action = oldact
		print( "\tOK!" )
	#
	return animations
#

def parse_textures():
	textures = {}
	print( "Parsing textures... ", end="" )
	for tex in bpy.data.textures:
		texpath = ""
		if hasattr( tex, "image" ) and tex.image != None:
			texpath = tex.image.filepath[ 2: ]
		textures[ tex.name ] = texpath
	print( "OK!" )
	return textures

def write_ss3dmesh( ctx, props ):
	filepath = props.filepath
	print( "\n\\\\\n>>> SS3DMESH Exporter v0.5!\n//\n\n" )
	print( "Exporting..." )
	
	textures = parse_textures()
	
	meshdata = gen_empty_mesh_data()
	armobj = None
	armdata = None
	boneorder = []
	for node in ctx.scene.objects:
		if node.type != "MESH":
			continue
		
		if props.export_selected and not node.select:
			continue
		
		cur_armobj = parse_armature( node )
		# do not allow multiple armatures
		if armobj is not None and cur_armobj is not None and armobj.name != cur_armobj.name:
			props.report( {"ERROR"},
				"multiple armatures are not supported (curr=%s, new=%s)" % (
					armobj.name, cur_armobj.name ) )
			return {'CANCELLED'}
		# do this only for the first time
		if armobj is None and cur_armobj is not None:
			armobj = cur_armobj
			armdata = None if armobj is None else armobj.data
			boneorder = generate_bone_order( armdata )
		cur_meshdata = parse_geometry( node, textures, boneorder, props )
		mesh_data_add( meshdata, cur_meshdata )
	
	if props.export_anim:
		print( "Parsing animations..." )
		animations = parse_animations( armobj, boneorder, filepath )
		print( "OK!" )
	
	print( "Writing mesh... " )
	with open( filepath, 'wb' ) as f:
		write_mesh( f, meshdata, armdata, boneorder )
	
	if props.export_anim:
		if len(animations) == 0:
			props.report( {"WARNING"}, "No animations found!" )
		else:
			print( "Writing animations... " )
			with open( filepath + ".anm", 'wb' ) as f:
				write_anims( f, animations )
			with open( filepath + ".anb", 'wb' ) as f:
				write_anims_anbd( f, animations )
	#
	
	print( "\n\\\\\n>>> Done!\n//\n\n" )

	return {'CANCELLED'}
#

def write_sgrxanbd( ctx, props ):
	print( "\n\\\\\n>>> SGRXANBD Exporter v0.5!\n//\n\n" )
	print( "Exporting..." )
	
	filepath = props.filepath
	
	print( "Parsing nodes... ", end="" )
	armobj = None
	geom_node = bpy.context.active_object
	if bpy.context.active_object.type == "ARMATURE":
		armobj = bpy.context.active_object
	for node in ctx.scene.objects:
		if node.type == "ARMATURE":
			armobj = node
			break
	#
	if armobj is None:
		props.report( {"ERROR"}, "No armature found!" )
		return {'CANCELLED'}
	else:
		armdata = armobj.data
	print( "OK!" )
	
	boneorder = generate_bone_order( armdata )
	
	print( "Parsing animations..." )
	animations = parse_animations( armobj, boneorder, filepath )
	print( "OK!" )
	
	if len(animations) == 0:
		props.report( {"WARNING"}, "No animations found!" )
	else:
		print( "Writing animations... " )
		with open( filepath, 'wb' ) as f:
			write_anims_anbd( f, animations )
	#
	
	print( "\n\\\\\n>>> Done!\n//\n\n" )

	return {'CANCELLED'}

# ExportHelper is a helper class, defines filename and
# invoke() function which calls the file selector.
from bpy_extras.io_utils import ExportHelper
from bpy.props import StringProperty, BoolProperty, EnumProperty


apply_mod_ui_items = [
	( "NONE", "None", "Don't apply any modifiers" ),
	( "SKIPARM", "All except armatures", "Apply non-armature modifiers" ),
	( "ALL", "All", "Apply all modifiers" ),
]


class ExportSS3DMESH( bpy.types.Operator, ExportHelper ):
	'''SS3DMESH Exporter'''
	bl_idname = "export.ss3dmesh"
	bl_label = "[SGRX] Export .ssm"
	bl_options = {'REGISTER', 'UNDO'}
	
	# ExportHelper mixin class uses this
	filename_ext = ".ssm"
	
	filter_glob = StringProperty(
		default = "*.ssm",
		options = {'HIDDEN'},
	)
	export_anim = BoolProperty(name="Export animation", default=False)
	export_selected = BoolProperty(name="Export selected mesh only", default=True)
	apply_modifiers = EnumProperty(items=apply_mod_ui_items,
		name="Apply modifiers", default="SKIPARM")
	
	def execute( self, ctx ):
		return write_ss3dmesh( ctx, self )

class ExportSGRXANBD( bpy.types.Operator, ExportHelper ):
	'''SGRXANBD (anim. bundle) Exporter'''
	bl_idname = "export.sgrxanbd"
	bl_label = "[SGRX] Export .anb"
	bl_options = {'REGISTER', 'UNDO'}
	
	filename_ext = ".anb"
	
	filter_glob = StringProperty(
		default = "*.anb",
		options = {'HIDDEN'},
	)
	
	def execute( self, ctx ):
		return write_sgrxanbd( ctx, self )


# Only needed if you want to add into a dynamic menu
def menu_func_export( self, ctx ):
	self.layout.operator( ExportSS3DMESH.bl_idname, text="SS3DMESH Exporter" )
	self.layout.operator( ExportSGRXANBD.bl_idname, text="SGRXANBD (anim. bundle) Exporter" )



def makeMaterial(name, uvlayer):
	tex = bpy.data.textures.new(name, type = 'IMAGE')
	
	mat = bpy.data.materials.new(name)
	mat.diffuse_color = (1,1,1)
	mat.diffuse_shader = 'LAMBERT'
	mat.diffuse_intensity = 1.0 
	mat.specular_color = (1,1,1)
	mat.specular_shader = 'COOKTORR'
	mat.specular_intensity = 0.2
	mat.alpha = 1
	mat.ambient = 1
	
	mtex = mat.texture_slots.add()
	mtex.texture = tex
	mtex.texture_coords = 'UV'
	mtex.use_map_color_diffuse = True
	mtex.mapping = 'FLAT'
	mtex.uv_layer = uvlayer
	
	return mat

class DialogOperator(bpy.types.Operator):
	bl_idname = "object.generate_material"
	bl_label = "Generate Material"
	
	prop_mtlname = StringProperty(name="Material name", default="newmtl")
	
	def execute(self, context):
		active = bpy.context.active_object.data
		if hasattr(active, "materials"):
			mtlname = self.prop_mtlname
			active.materials.append( makeMaterial( mtlname, active.uv_layers.keys()[0] ) )
			self.report({'INFO'}, "Material created: %s!" % mtlname)
		else:
			self.report({'INFO'}, "Object cannot have materials!")
		#
		return {'FINISHED'}
	
	def invoke(self, context, event):
		return context.window_manager.invoke_props_dialog(self)



class DialogPanel(bpy.types.Panel):
	bl_label = "Texturing Tools"
	bl_space_type = "VIEW_3D"
	bl_region_type = "UI"
	
	def draw(self, context):
		self.layout.operator("object.generate_material")


def register():
	bpy.utils.register_class( ExportSS3DMESH )
	bpy.utils.register_class( ExportSGRXANBD )
	bpy.utils.register_class( DialogOperator )
	bpy.utils.register_class( DialogPanel )
	bpy.types.INFO_MT_file_export.append( menu_func_export )
	# bpy.types.VIEW3D_PT_tools_object.append( generate_material_func )


def unregister():
	bpy.utils.unregister_class( ExportSS3DMESH )
	bpy.utils.unregister_class( ExportSGRXANBD )
	bpy.utils.unregister_class( DialogOperator )
	bpy.utils.unregister_class( DialogPanel )
	bpy.types.INFO_MT_file_export.remove( menu_func_export )
	# bpy.types.VIEW3D_PT_tools_object.remove( generate_material_func )


if __name__ == "__main__":
	register()
#