ona/source/ona/file.zig

const coral = @import("coral");

const ext = @import("./ext.zig");

pub const Contents = struct {
	allocator: coral.io.Allocator,
	data: []u8,

	pub const InitError = coral.io.AllocationError || Readable.ReadError;

	pub fn deinit(self: *Contents) void {
		coral.io.deallocate(self.allocator, self.data);
	}

	pub fn init(allocator: coral.io.Allocator, readable_file: *Readable) InitError!Contents {
		const file_offset = try readable_file.skip(0);
		const file_size = try readable_file.seek_end();

		_ = try readable_file.seek(file_offset);

		const allocation = try coral.io.allocate_many(u8, file_size, allocator);

		errdefer coral.io.deallocate(allocator, allocation);

		if (try readable_file.read(allocation) != allocation.len) {
			// Read less than was allocated for.
			return error.FileUnavailable;
		}

		return Contents{
			.allocator = allocator,
			.data = allocation,
		};
	}
};

pub const Path = extern struct {
	data: [4096]u8 = [_]u8{0} ** 4096,

	pub const cwd = Path.from(&.{"./"});

	pub const ValidationError = error {
		PathTooLong,
	};

	pub fn from(components: []const []const u8) Path {
		// TODO: Implement proper parsing / removal of duplicate path delimiters.
		var path = Path{};

		{
			var writable_slice = coral.io.FixedBuffer{.slice = &path.data};

			for (components) |component| {
				if (writable_slice.write(component) != component.len) {
					break;
				}
			}
		}

		return path;
	}

	pub fn joined(self: Path, other: Path) Path {
		var path = Path{};

		{
			var writable = coral.io.FixedBuffer{.slice = &path.data};
			var written = @as(usize, 0);

			for (&self.data) |byte| {
				if ((byte == 0) or !(writable.put(byte))) {
					break;
				}

				written += 1;
			}

			if ((written > 0) and (path.data[written - 1] != '/') and writable.put('/')) {
				written += 1;
			}

			for (&other.data) |byte| {
				if ((byte == 0) or !(writable.put(byte))) {
					break;
				}

				written += 1;
			}
		}

		return path;
	}

	pub fn to_string(self: Path) ValidationError![:0]const u8 {
		const sentineled_data = get_sentineled_data: {
			const last_index = self.data.len - 1;

			if (self.data[last_index] != 0) {
				return error.PathTooLong;
			}

			break: get_sentineled_data self.data[0 .. last_index:0];
		};

		return sentineled_data[0 .. coral.io.sentinel_index(u8, 0, sentineled_data):0];
	}
};

pub const ReadError = error {
	FileUnavailable,
};

pub const Readable = opaque {
	pub fn as_reader(self: *Readable) coral.io.Reader {
		return coral.io.Reader.bind(Readable, self, struct {
			fn read(readable: *Readable, buffer: []u8) ?usize {
				return readable.read(buffer) catch null;
			}
		}.read);
	}

	pub fn close(self: *Readable) void {
		if (ext.SDL_RWclose(rw_ops_cast(self)) != 0) {
			@panic("Failed to close file");
		}
	}

	pub fn read(self: *Readable, buffer: []u8) ReadError!usize {
		ext.SDL_ClearError();

		const bytes_read = ext.SDL_RWread(rw_ops_cast(self), buffer.ptr, @sizeOf(u8), buffer.len);
		const error_message = ext.SDL_GetError();

		if (bytes_read == 0 and error_message != null and error_message.* != 0) {
			return error.FileUnavailable;
		}

		return bytes_read;
	}

	pub fn seek(self: *Readable, cursor: u64) ReadError!u64 {
		// TODO: Fix safety of int cast.
		const byte_offset = ext.SDL_RWseek(rw_ops_cast(self), @intCast(i64, cursor), ext.RW_SEEK_SET);

		if (byte_offset < 0) {
			return error.FileUnavailable;
		}

		return @intCast(u64, byte_offset);
	}

	pub fn seek_end(self: *Readable) ReadError!usize {
		const byte_offset = ext.SDL_RWseek(rw_ops_cast(self), 0, ext.RW_SEEK_END);

		if (byte_offset < 0) {
			return error.FileUnavailable;
		}

		return @intCast(u64, byte_offset);
	}

	pub fn skip(self: *Readable, offset: i64) ReadError!u64 {
		const byte_offset = ext.SDL_RWseek(rw_ops_cast(self), offset, ext.RW_SEEK_CUR);

		if (byte_offset < 0) {
			return error.FileUnavailable;
		}

		return @intCast(u64, byte_offset);
	}
};

pub const System = union (enum) {
	sandboxed_path: *const Path,

	pub const FileInfo = struct {
		size: u64,
	};

	pub const OpenError = Path.ValidationError || error {
		FileNotFound,
	};

	pub const QueryError = OpenError || ReadError;

	pub fn open_readable(self: System, path: Path) OpenError!*Readable {
		switch (self) {
			.sandboxed_path => |sandboxed_path| {
				return @ptrCast(*Readable, ext.SDL_RWFromFile(try sandboxed_path.joined(path).to_string(), "rb") orelse {
					return error.FileNotFound;
				});
			},
		}
	}

	pub fn query_info(self: System, path: Path) QueryError!FileInfo {
		switch (self) {
			.sandboxed_path => |sandboxed_path| {
				const file = ext.SDL_RWFromFile(try sandboxed_path.joined(path).to_string(), "rb") orelse {
					return error.FileNotFound;
				};

				defer coral.debug.assert(ext.SDL_RWclose(file) == 0);

				const file_size = ext.SDL_RWseek(file, 0, ext.RW_SEEK_END);

				if (file_size < 0) {
					return error.FileUnavailable;
				}

				return FileInfo{
					.size = @intCast(u64, file_size),
				};
			}
		}
	}
};

fn rw_ops_cast(ptr: *anyopaque) *ext.SDL_RWops {
	return @ptrCast(*ext.SDL_RWops, @alignCast(@alignOf(ext.SDL_RWops), ptr));
}