// vim:fileencoding=utf-8:foldmethod=marker

#include "file.h"
#include "../cpath/cpath.h"
#include "../../common/assert/assert.h"
#include "../../common/aliases/aliases.h"
#include "../../base/array/array.h"
#include "../../base/strings/str8/str8.h"

WFile *wapp_file_open(const Allocator *allocator, Str8RO *filepath, FileAccessMode mode) {
	wapp_debug_assert(allocator != NULL && filepath != NULL, "`allocator` and `filepath` should not be NULL");
	wapp_debug_assert(filepath->size < WAPP_PATH_MAX, "`filepath` exceeds max path limit.");
	return _file_open(allocator, filepath, mode);
}

i64 wapp_file_get_current_position(WFile *file) {
	wapp_debug_assert(file != NULL, "`file` should not be NULL.");
	return _file_seek(file, 0, WAPP_SEEK_CURRENT);
}

i64 wapp_file_seek(WFile *file, i64 offset, FileSeekOrigin origin) {
	wapp_debug_assert(file != NULL, "`file` should not be NULL.");
	return _file_seek(file, offset, origin);
}

i64 wapp_file_get_length(WFile *file) {
	wapp_debug_assert(file != NULL, "`file` should not be NULL.");

	i64 current = wapp_file_get_current_position(file);

	_file_seek(file, 0, WAPP_SEEK_END);

	i64 output = wapp_file_get_current_position(file);

	// Restore position
	_file_seek(file, current, WAPP_SEEK_START);

	return output;
}

u64 wapp_file_read(void *dst_buf, WFile *file, u64 byte_count) {
	wapp_debug_assert(dst_buf != NULL && file != NULL,
	                  "`dst_buf` and `file` should not be NULL.");

	i64 file_length = wapp_file_get_length(file);
	if (file_length < 0) {
		return 0;
	}

	return _file_read(dst_buf, byte_count, file, file_length);
}

i64 wapp_file_write(const void *src_buf, WFile *file, u64 byte_count) {
	wapp_debug_assert(src_buf != NULL && file != NULL,
	                  "`src_buf` and `file` should not be NULL.");
	return _file_write(src_buf, file, byte_count);
}

u64 wapp_file_read_array(GenericArray dst_buf, WFile *file, u64 item_count) {
	wapp_debug_assert(dst_buf != NULL && file != NULL,
	                  "`dst_buf` and `file` should not be NULL.");

	i64 _file_length = wapp_file_get_length(file);
	if (_file_length < 0) {
		return 0;
	}

	u64 file_length       = (u64)_file_length;
	u64 item_size         = wapp_array_item_size(dst_buf);
	u64 dst_byte_capacity = wapp_array_capacity(dst_buf) * item_size;
	u64 req_byte_count    = item_count * item_size;
	u64 copy_byte_count   = 0;

	if (req_byte_count <= file_length && req_byte_count <= dst_byte_capacity) {
		copy_byte_count = req_byte_count;
	} else {
		copy_byte_count = file_length <= dst_byte_capacity ? file_length : dst_byte_capacity;
	}

	u64 byte_count = _file_read(dst_buf, copy_byte_count, file, file_length);
	if (byte_count == 0) {
		return 0;
	}

	wapp_array_set_count(dst_buf, byte_count / item_size);

	return wapp_array_count(dst_buf);
}

i64 wapp_file_write_array(const GenericArray src_buf, WFile *file, u64 item_count) {
	wapp_debug_assert(src_buf != NULL && file != NULL,
	                  "`src_buf` and `file` should not be NULL.");

	u64 item_size      = wapp_array_item_size(src_buf);
	u64 src_byte_count = wapp_array_count(src_buf) * item_size;
	u64 req_byte_count = item_count * item_size;
	u64 to_copy        = req_byte_count <= src_byte_count ? req_byte_count : src_byte_count;

	i64 bytes_written = _file_write(src_buf, file, to_copy);
	if (bytes_written < 0) {
		return 0;
	}

	return (u64)bytes_written / item_size;
}

i32 wapp_file_flush(WFile *file) {
	wapp_debug_assert(file != NULL, "`file` should not be NULL.");
	return _file_flush(file);
}

i32 wapp_file_close(WFile *file) {
	wapp_debug_assert(file != NULL, "`file` should not be NULL.");
	return _file_close(file);
}

i32 wapp_file_rename(Str8RO *old_filepath, Str8RO *new_filepath) {
	wapp_debug_assert(old_filepath != NULL && new_filepath != NULL,
	                  "`old_filepath` and `new_filepath` should not be NULL");
	wapp_debug_assert(old_filepath->size < WAPP_PATH_MAX, "`old_filepath` exceeds max path limit.");
	wapp_debug_assert(new_filepath->size < WAPP_PATH_MAX, "`new_filepath` exceeds max path limit.");
	return _file_rename(old_filepath, new_filepath);
}

i32 wapp_file_remove(Str8RO *filepath) {
	wapp_debug_assert(filepath != NULL, "`filepath` should not be NULL");
	wapp_debug_assert(filepath->size < WAPP_PATH_MAX, "`filepath` exceeds max path limit.");
	return _file_remove(filepath);
}