#+build !wasm32
#+build !wasm64p32

package game

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

ProjectReadErrorType :: enum {
	FailedReadingHeader,
	BadHeader,
	VersionNeedsUpgrade,
}

ProjectWriteError :: union {
	os.Error,
	io.Error,
}

ProjectReadError :: union {
	os.Error,
	io.Error,
	ProjectReadErrorType,
}

_project_write :: proc(project: ^ProjectData, path: string) -> ProjectWriteError {
	f := os.open(path, {.Create, .Trunc, .Write}) or_return
	defer os.close(f)
	w := io.to_writer(os.to_stream(f))
	version: u32 = PROJECT_DATA_VERSION
	header := PROJECT_DATA_HEADER

	io.write_full(w, transmute([]u8)header) or_return
	io.write_ptr(w, &version, size_of(version)) or_return
	io.write_ptr(w, &project.matrix_count, size_of(project.matrix_count)) or_return
	_ = io.write_ptr(w, raw_data(project.matrices), int(project.matrix_count) * 9 * size_of(f32)) or_return
	_ = io.write_ptr(w, &project.grid, size_of(project.grid)) or_return
	_ = io.write_ptr(w, &project.shapes, size_of(project.shapes)) or_return
	os.close(f)
	return nil
}

_project_read :: proc(project: ^ProjectData, path: string) -> ProjectReadError {
	f := os.open(path, {.Read}) or_return
	defer os.close(f)
	r := io.to_reader(os.to_stream(f))
	header := PROJECT_DATA_HEADER
	header_buffer: [len(PROJECT_DATA_HEADER)]byte
	if num, err := io.read_full(r, header_buffer[:]); err != nil {
		return ProjectReadErrorType.FailedReadingHeader
	}
	if mem.compare(transmute([]byte)header, header_buffer[:]) != 0 {
		return ProjectReadErrorType.BadHeader
	}
	_ = io.read_ptr(r, &project.version, size_of(project.matrix_count)) or_return
	if project.version != PROJECT_DATA_VERSION {
		return ProjectReadErrorType.VersionNeedsUpgrade
	}
	_ = io.read_ptr(r, &project.matrix_count, size_of(project.matrix_count)) or_return
	_ = io.read_ptr(r, raw_data(project.matrices), size_of(f32) * int(project.matrix_count) * 9) or_return
	_ = io.read_ptr(r, &project.grid, size_of(project.grid)) or_return
	_ = io.read_ptr(r, &project.shapes, size_of(project.shapes)) or_return
	return nil
}