# MIT License
#
# Copyright (c) 2023 Mark McKay
# https://github.com/blackears/cyclopsLevelBuilder
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.

@tool
extends Resource
class_name MeshVectorData


#@export var selected:bool = false
#@export var active:bool = false
#@export var collision:bool = true
#@export_flags_3d_physics var physics_layer:int
#@export_flags_3d_physics var physics_mask:int

@export var num_vertices:int
@export var num_edges:int
@export var num_faces:int
@export var num_face_vertices:int

@export var active_vertex:int
@export var active_edge:int
@export var active_face:int
@export var active_face_vertex:int


@export var edge_vertex_indices:PackedInt32Array
@export var edge_face_indices:PackedInt32Array

@export var face_vertex_count:PackedInt32Array #Number of verts in each face
@export var face_vertex_indices:PackedInt32Array #Vertex index per face

@export var vertex_data:Dictionary
@export var edge_data:Dictionary
@export var face_data:Dictionary
@export var face_vertex_data:Dictionary

const V_POSITION: StringName = "position"
const V_SELECTED: StringName = "selected"
const V_COLOR: StringName = "color"

const E_SELECTED: StringName = "selected"

const F_MATERIAL_INDEX: StringName = "material_index"
const F_UV_XFORM: StringName = "uv_transform"
const F_VISIBLE: StringName = "visible"
const F_COLOR: StringName = "color"
const F_SELECTED: StringName = "selected"

const FV_VERTEX_INDEX: StringName = "vertex_index"
const FV_FACE_INDEX: StringName = "face_index"
const FV_VERTEX_LOCAL_INDEX: StringName = "vertex_local_index"
const FV_SELECTED: StringName = "selected"
const FV_COLOR: StringName = "color"
const FV_NORMAL: StringName = "normal"
const FV_UV1: StringName = "uv1"
const FV_UV2: StringName = "uv2"


func create_from_convex_block(block_data:ConvexBlockData):

	#selected = block_data.selected
	#active = block_data.active
	#collision = block_data.collision
	#physics_layer = block_data.physics_layer
	#physics_mask = block_data.physics_mask

	active_vertex = block_data.active_vertex
	active_edge = block_data.active_edge
	active_face = block_data.active_face
	active_face_vertex = block_data.active_face_vertex
		
	num_vertices = block_data.vertex_points.size()
	num_edges = block_data.edge_vertex_indices.size() / 2
	num_faces = block_data.face_vertex_count.size()
	
	set_vertex_data(DataVectorFloat.new(V_POSITION, 
		block_data.vertex_points.to_byte_array().to_float32_array(), 
		DataVector.DataType.VECTOR3))

	set_vertex_data(DataVectorByte.new(V_SELECTED, 
		block_data.vertex_selected, 
		DataVector.DataType.BOOL))

	set_edge_data(DataVectorByte.new(E_SELECTED, 
		block_data.edge_selected, 
		DataVector.DataType.BOOL))

	set_face_data(DataVectorInt.new(F_MATERIAL_INDEX, 
		block_data.face_material_indices, 
		DataVector.DataType.INT))

	set_face_data(DataVectorByte.new(F_VISIBLE, 
		block_data.face_visible, 
		DataVector.DataType.BOOL))

	set_face_data(DataVectorFloat.new(F_COLOR,
		block_data.face_color.to_byte_array().to_float32_array(),
		DataVector.DataType.COLOR))

	var f_uv_xform:PackedFloat32Array	
	for t in block_data.face_uv_transform:
		f_uv_xform.append_array([t.x.x, t.x.y, t.y.x, t.y.y, t.origin.x, t.origin.y])
	set_face_data(DataVectorFloat.new(F_UV_XFORM, 
		f_uv_xform,
		DataVector.DataType.TRANSFORM_2D))
		
		
	set_face_data(DataVectorByte.new(F_SELECTED, 
		block_data.face_selected, 
		DataVector.DataType.BOOL))

	set_face_data(DataVectorFloat.new(F_COLOR, 
		block_data.face_color.to_byte_array().to_float32_array(), 
		DataVector.DataType.COLOR))

	
	#Create face-vertex data
	edge_vertex_indices = block_data.edge_vertex_indices
	edge_face_indices = block_data.edge_face_indices
	face_vertex_count = block_data.face_vertex_count
	face_vertex_indices = block_data.face_vertex_indices
	
	num_face_vertices = 0
	for n in block_data.face_vertex_count:
		num_face_vertices += n

	var fv_array_offset:int = 0
	var next_fv_idx:int = 0
	var face_indices:PackedInt32Array
	var vert_indices:PackedInt32Array
	
	for f_idx in block_data.face_vertex_count.size():
		var num_verts_in_face:int = block_data.face_vertex_count[f_idx]
		for fv_local_idx in num_verts_in_face:
			var v_idx:int = block_data.face_vertex_indices[fv_array_offset + fv_local_idx]
			
			face_indices.append(f_idx)
			vert_indices.append(v_idx)
			
		fv_array_offset += num_verts_in_face
	

	set_face_vertex_data(DataVectorInt.new(FV_FACE_INDEX, 
		face_indices, 
		DataVector.DataType.INT))

	set_face_vertex_data(DataVectorInt.new(FV_VERTEX_INDEX, 
		vert_indices, 
		DataVector.DataType.INT))

	#set_face_vertex_data(DataVectorInt.new(FV_VERTEX_LOCAL_INDEX, 
		#fv_local_indices, 
		#DataVector.DataType.INT))
	
	if block_data.face_vertex_color.is_empty():
		#Construct face vertex colors from old face colors system
		var col_fv_data:PackedColorArray
		for fv_idx in num_face_vertices:
			var f_idx:int = face_indices[fv_idx]
			var v_idx:int = vert_indices[fv_idx]
			col_fv_data.append(block_data.face_color[f_idx])
			

		set_face_vertex_data(DataVectorFloat.new(FV_COLOR, 
			col_fv_data.to_byte_array().to_float32_array(), 
			DataVector.DataType.COLOR))
	else:
		#Copy face vertex colors
		set_face_vertex_data(DataVectorFloat.new(FV_COLOR, 
			block_data.face_vertex_color.to_byte_array().to_float32_array(), 
			DataVector.DataType.COLOR))
			
	set_face_vertex_data(DataVectorFloat.new(FV_NORMAL, 
		block_data.face_vertex_normal.to_byte_array().to_float32_array(), 
		DataVector.DataType.VECTOR3))
			

func get_vertex_data(vector_name:String)->DataVector:
	return vertex_data[vector_name]

func get_edge_data(vector_name:String)->DataVector:
	return edge_data[vector_name]

func get_face_data(vector_name:String)->DataVector:
	return face_data[vector_name]

func get_face_vertex_data(vector_name:String)->DataVector:
	return face_vertex_data[vector_name]

func set_vertex_data(data_vector:DataVector):
	vertex_data[data_vector.name] = data_vector

func set_edge_data(data_vector:DataVector):
	edge_data[data_vector.name] = data_vector

func set_face_data(data_vector:DataVector):
	face_data[data_vector.name] = data_vector
	
func set_face_vertex_data(data_vector:DataVector):
	face_vertex_data[data_vector.name] = data_vector

func validate()->bool:
	return true
	

func create_vector_xml_node(name:String, type:String, value:String)->XMLElement:
	var evi_ele:XMLElement = XMLElement.new("vector")
	evi_ele.set_attribute("name", name)
	evi_ele.set_attribute("type", type)
	evi_ele.set_attribute("value", value)
	return evi_ele
	
func section_to_xml(type:String, vertex_data:Dictionary)->XMLElement:
	var sec_vertex_ele:XMLElement = XMLElement.new("section")
	sec_vertex_ele.set_attribute("type", type)

	for vec_name in vertex_data.keys():
		var v:DataVector = vertex_data[vec_name]
		match v.data_type:
			DataVector.DataType.BOOL:
				sec_vertex_ele.add_child(create_vector_xml_node(v.name, "bool", var_to_str(v.data)))
			DataVector.DataType.INT:
				sec_vertex_ele.add_child(create_vector_xml_node(v.name, "int", var_to_str(v.data)))
			DataVector.DataType.FLOAT:
				sec_vertex_ele.add_child(create_vector_xml_node(v.name, "float", var_to_str(v.data)))
			DataVector.DataType.STRING:
				sec_vertex_ele.add_child(create_vector_xml_node(v.name, "string", var_to_str(v.data)))
			DataVector.DataType.COLOR:
				sec_vertex_ele.add_child(create_vector_xml_node(v.name, "color", var_to_str(v.data)))
			DataVector.DataType.VECTOR2:
				sec_vertex_ele.add_child(create_vector_xml_node(v.name, "vector2", var_to_str(v.data)))
			DataVector.DataType.VECTOR3:
				sec_vertex_ele.add_child(create_vector_xml_node(v.name, "vector3", var_to_str(v.data)))
			DataVector.DataType.VECTOR4:
				sec_vertex_ele.add_child(create_vector_xml_node(v.name, "vector4", var_to_str(v.data)))
			DataVector.DataType.TRANSFORM_2D:
				sec_vertex_ele.add_child(create_vector_xml_node(v.name, "transform2D", var_to_str(v.data)))
			DataVector.DataType.TRANSFORM_3D:
				sec_vertex_ele.add_child(create_vector_xml_node(v.name, "transform3D", var_to_str(v.data)))
	
	return sec_vertex_ele
		
func to_xml()->XMLElement:
	var rec_ele:XMLElement = XMLElement.new("record")
	rec_ele.set_attribute("type", "mesh")
	
	#rec_ele.set_attribute("selected", str(selected))
	#rec_ele.set_attribute("active", str(active))
	#rec_ele.set_attribute("collision", str(collision))	
	#rec_ele.set_attribute("physics_layer", str(physics_layer))
	#rec_ele.set_attribute("physics_mask", str(physics_mask))

	rec_ele.set_attribute("num_vertices", str(num_vertices))
	rec_ele.set_attribute("num_edges", str(num_edges))
	rec_ele.set_attribute("num_faces", str(num_faces))
	rec_ele.set_attribute("num_face_vertices", str(num_face_vertices))


	rec_ele.add_child(create_vector_xml_node("edge_vertex_indices", "int", var_to_str(edge_vertex_indices)))
	rec_ele.add_child(create_vector_xml_node("edge_face_indices", "int", var_to_str(edge_face_indices)))
	rec_ele.add_child(create_vector_xml_node("face_vertex_count", "int", var_to_str(face_vertex_count)))
	rec_ele.add_child(create_vector_xml_node("face_vertex_indices", "int", var_to_str(face_vertex_indices)))

	rec_ele.set_attribute("active_vertex", str(active_vertex))
	rec_ele.set_attribute("active_edge", str(active_edge))
	rec_ele.set_attribute("active_face", str(active_face))
	rec_ele.set_attribute("active_face_vertex", str(active_face_vertex))
	
	var sec_vertex_ele:XMLElement = XMLElement.new("data")
	sec_vertex_ele.set_attribute("type", "vertex")
	rec_ele.add_child(sec_vertex_ele)

	rec_ele.add_child(section_to_xml("vertex", vertex_data))
	rec_ele.add_child(section_to_xml("edge", edge_data))
	rec_ele.add_child(section_to_xml("face", face_data))
	rec_ele.add_child(section_to_xml("faceVertex", face_vertex_data))
				
	
	return rec_ele

func to_dictionary(file_builder:CyclopsFileBuilder)->Dictionary:
	var result:Dictionary
	
	result["num_vertices"] = num_vertices
	result["num_edges"] = num_edges
	result["num_faces"] = num_faces
	result["num_face_vertices"] = num_face_vertices
	
	result["active_vertex"] = active_vertex
	result["active_edge"] = active_edge
	result["active_face"] = active_face
	result["active_face_vertex"] = active_face_vertex
	
#	vectors["face_vertices"].append(file_builder.export_vector(data_vec))
	result["edge_vertex_index_buffer"] = file_builder.export_byte_array(edge_vertex_indices.to_byte_array())
	result["edge_face_index_buffer"] = file_builder.export_byte_array(edge_face_indices.to_byte_array())
	result["face_vertex_count_buffer"] = file_builder.export_byte_array(face_vertex_count.to_byte_array())
	result["face_vertex_index_buffer"] = file_builder.export_byte_array(face_vertex_indices.to_byte_array())
	#result["edge_vertex_indices"] = edge_vertex_indices
	#result["edge_face_indices"] = edge_face_indices
	#
	#result["face_vertex_count"] = face_vertex_count
	#result["face_vertex_indices"] = face_vertex_indices

	var vectors:Dictionary = {
		"vertices": [],
		"edges": [],
		"faces": [],
		"face_vertices": []
	}
	result["vectors"] = vectors
	
	for key in vertex_data.keys():
		var data_vec:DataVector = vertex_data[key]
#		vectors["vertices"].append(data_vec.to_dictionary(buf_ar))
		vectors["vertices"].append(file_builder.export_vector(data_vec))
	
	for key in edge_data.keys():
		var data_vec:DataVector = edge_data[key]
#		vectors["edges"].append(data_vec.to_dictionary(buf_ar))
		vectors["edges"].append(file_builder.export_vector(data_vec))
	
	for key in face_data.keys():
		var data_vec:DataVector = face_data[key]
#		vectors["faces"].append(data_vec.to_dictionary(buf_ar))
		vectors["faces"].append(file_builder.export_vector(data_vec))
	
	for key in face_vertex_data.keys():
		var data_vec:DataVector = face_vertex_data[key]
#		vectors["face_vertices"].append(data_vec.to_dictionary(buf_ar))
		vectors["face_vertices"].append(file_builder.export_vector(data_vec))
	
	return result

#func export_vector(vec:DataVector, file_builder:CyclopsFileBuilder)->Dictionary:
	#var result:Dictionary
	#
	#result["name"] = vec.name
	#result["data_type"] = DataVector.DataType.values()[vec.data_type]
	#if vec.stride != 1:
		#result["stride"] = vec.stride
	#if !vec.category.is_empty():
		#result["category"] = vec.category
	#
	#var region:BufferArchive.BufferRegion = file_builder.buf_ar.store_buffer(vec.get_buffer_byte_data())
	#result["data_buffer"] = region.index
	#
	#return result