package main

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

PROJECT_DATA_HEADER :: "WOWOWOW THIS IS HEADER WOWOWOW"
PROJECT_DATA_VERSION :: 1

ProjectData :: struct {
	version: u32,
	matrix_count: u32,
	matrices: []f32,
}

WriteProjectError :: union {
	os.Error,
}

WriteProjectErrorType :: enum {
	IncompatibleVersion,
}

project_write :: proc(project: ^ProjectData, path: string) -> os.Error {
	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)
	io.write_ptr(w, &version, size_of(version))
	io.write_ptr(w, &project.matrix_count, size_of(project.matrix_count))
	io.write_ptr(w, raw_data(project.matrices), int(project.matrix_count) * 9 * size_of(f32))
	os.close(f)
	return nil
}

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

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

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
	}
	version: u32
	_ = io.read_ptr(r, &version, size_of(u32)) or_return
	if version != PROJECT_DATA_VERSION {
		return ProjectReadErrorType.VersionNeedsUpgrade
	}
	project.version = version
	return nil
}