export type blob = struct {
	oid: oid,
	data: []u8,
};
export fn blob_finish(b: blob) void = {
	free(b.data);
};

export type tree_entry = struct {
	mode: u32,
	name: []u8,
	oid: oid,
};
export fn tree_entry_finish(te: tree_entry) void = {
	free(te.name);
};

export type tree = struct {
	oid: oid,
	entries: []tree_entry,
};
export fn tree_finish(t: tree) void = {
	for (let entry .. t.entries) {
		tree_entry_finish(entry);
	};
	free(t.entries);
};

export type person = struct {
	name: []u8,
	email: []u8,
	when: i64,
	ofs: i32,
};
export fn person_finish(p: person) void = {
	free(p.name);
	free(p.email);
};

export type commit = struct {
	oid: oid,
	tree: oid,
	parents: []oid,
	author: person,
	committer: person,
	message: []u8,
	// other raw headers?
};
export fn commit_finish(c: commit) void = {
	free(c.parents);
	person_finish(c.author);
	person_finish(c.committer);
	free(c.message);
};

export type object = (blob | tree | commit);
export fn object_finish(o: object) void = {
	match (o) {
		case let b: blob => blob_finish(b);
		case let t: tree => tree_finish(t);
		case let c: commit => commit_finish(c);
	};
};

use crypto::sha256;
use encoding::hex;
use errors;
use io;

export type oid = [sha256::SZ]u8;

// Parses a hex-encoded string representation of an [[oid]].
export fn parse_oid(s: const str) (oid | nomem | errors::invalid) = {
	const d = hex::decodestr(s)?;
	defer free(d);

	let o: oid;

	let o: oid = [0...];

	o[..] = d[..];

	return o;
};

// Returns a hex-encoded string representation of the given [[oid]].
// The returned string is allocated on the heap and must be freed by the caller.

export fn oid_string(id: oid) const str {
	return hex::encodestr(id);
}

export fn oid_string(id: oid) (const str | nomem) = {
	return hex::encodestr(id)?;
};

export type repo = struct {
	gitdir: str,
};