package encoding_hxa

import "core:os"
import "core:mem"

Write_Error :: enum {
	None,
	Buffer_Too_Small,
	Failed_File_Write,
}

write_to_file :: proc(filepath: string, file: File) -> (err: Write_Error) {
	required := required_write_size(file)
	buf, alloc_err := make([]byte, required)
	if alloc_err == .Out_Of_Memory {
		return .Failed_File_Write
	}
	defer delete(buf)

	write_internal(&Writer{data = buf}, file)
	if !os.write_entire_file(filepath, buf) {
		err =.Failed_File_Write
	}
	return
}

write :: proc(buf: []byte, file: File) -> (n: int, err: Write_Error) {
	required := required_write_size(file)
	if len(buf) < required {
		err = .Buffer_Too_Small
		return
	}
	n = required
	write_internal(&Writer{data = buf}, file)
	return
}

required_write_size :: proc(file: File) -> (n: int) {
	writer := &Writer{dummy_pass = true}
	write_internal(writer, file)
	n = writer.offset
	return
}


@(private)
Writer :: struct {
	data:   []byte,
	offset: int,
	dummy_pass: bool,
}

@(private)
write_internal :: proc(w: ^Writer, file: File) {
	write_value :: proc(w: ^Writer, value: $T) {
		if !w.dummy_pass {
			remaining := len(w.data) - w.offset
			assert(size_of(T) <= remaining)
			ptr := raw_data(w.data[w.offset:])
			(^T)(ptr)^ = value
		}
		w.offset += size_of(T)
	}
	write_array :: proc(w: ^Writer, array: []$T) {
		if !w.dummy_pass {
			remaining := len(w.data) - w.offset
			assert(size_of(T)*len(array) <= remaining)
			ptr := raw_data(w.data[w.offset:])
			dst := mem.slice_ptr((^T)(ptr), len(array))
			copy(dst, array)
		}
		w.offset += size_of(T)*len(array)
	}
	write_string :: proc(w: ^Writer, str: string) {
		if !w.dummy_pass {
			remaining := len(w.data) - w.offset
			assert(size_of(byte)*len(str) <= remaining)
			ptr := raw_data(w.data[w.offset:])
			dst := mem.slice_ptr((^byte)(ptr), len(str))
			copy(dst, str)
		}
		w.offset += size_of(byte)*len(str)
	}

	write_metadata :: proc(w: ^Writer, meta_data: []Meta) {
		for m in meta_data {
			name_len := max(len(m.name), 255)
			write_value(w, u8(name_len))
			write_string(w, m.name[:name_len])

			meta_data_type: Meta_Value_Type
			length: u32le = 0
			switch v in m.value {
			case []i64le:
				meta_data_type = .Int64
				length = u32le(len(v))
			case []f64le:
				meta_data_type = .Double
				length = u32le(len(v))
			case []Node_Index:
				meta_data_type = .Node
				length = u32le(len(v))
			case string:
				meta_data_type = .Text
				length = u32le(len(v))
			case []byte:
				meta_data_type = .Binary
				length = u32le(len(v))
			case []Meta:
				meta_data_type = .Meta
				length = u32le(len(v))
			}
			write_value(w, meta_data_type)
			write_value(w, length)

			switch v in m.value {
			case []i64le:      write_array(w, v)
			case []f64le:      write_array(w, v)
			case []Node_Index: write_array(w, v)
			case string:       write_string(w, v)
			case []byte:       write_array(w, v)
			case []Meta:       write_metadata(w, v)
			}
		}
		return
	}
	write_layer_stack :: proc(w: ^Writer, layers: Layer_Stack) {
		write_value(w, u32(len(layers)))
		for layer in layers {
			name_len := max(len(layer.name), 255)
			write_value(w, u8(name_len))
			write_string(w, layer .name[:name_len])

			write_value(w, layer.components)

			layer_data_type: Layer_Data_Type
			switch v in layer.data {
			case []u8:    layer_data_type = .Uint8
			case []i32le: layer_data_type = .Int32
			case []f32le: layer_data_type = .Float
			case []f64le: layer_data_type = .Double
			}
			write_value(w, layer_data_type)

			switch v in layer.data {
			case []u8:   write_array(w, v)
			case []i32le: write_array(w, v)
			case []f32le: write_array(w, v)
			case []f64le: write_array(w, v)
			}
		}
		return
	}

	write_value(w, &Header{
		magic_number = MAGIC_NUMBER,
		version = LATEST_VERSION,
		internal_node_count = u32le(len(file.nodes)),
	})

	for node in file.nodes {
		node_type: Node_Type
		switch content in node.content {
		case Node_Geometry: node_type = .Geometry
		case Node_Image:    node_type = .Image
		}
		write_value(w, node_type)

		write_value(w, u32(len(node.meta_data)))
		write_metadata(w, node.meta_data)

		switch content in node.content {
		case Node_Geometry:
			write_value(w, content.vertex_count)
			write_layer_stack(w, content.vertex_stack)
			write_value(w, content.edge_corner_count)
			write_layer_stack(w, content.corner_stack)
			write_layer_stack(w, content.edge_stack)
			write_value(w, content.face_count)
			write_layer_stack(w, content.face_stack)
		case Node_Image:
			write_value(w, content.type)
			dimensions := int(content.type)
			if content.type == .Image_Cube {
				dimensions = 2
			}
			for d in 0..<dimensions {
				write_value(w, content.resolution[d])
			}
			write_layer_stack(w, content.image_stack)
		}
	}
}