posix_filesystem.cpp

#include "crucible/core/filesystem.hpp"

#include <dirent.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>

#include "crucible/core/iterators.hpp"
#include "crucible/core/platform.hpp"

#if !CRUCIBLE_PLATFORM_HAS_DIRENT_D_NAMLEN
#include <cstring>
#endif // CRUCIBLE_PLATFORM_HAS_DIRENT_D_NAMLEN

namespace crucible
{
	// POSIX native path API -----------------------

	struct native_directory_list_iterator_data
	{
		::DIR *directory_handle { nullptr };
	};

	struct file_reader_data
	{
		int file_descriptor { -1 };
	};

	struct file_writer_data
	{
		int file_descriptor { -1 };
	};

	native_directory_list_iterator::native_directory_list_iterator(std::unique_ptr<native_directory_list_iterator_data> data) :
		my_data { std::move(data) }
	{}

	native_directory_list_iterator::native_directory_list_iterator(native_directory_list_iterator &&that) :
		my_data { std::move(that.my_data) }
	{}

	native_directory_list_iterator::~native_directory_list_iterator()
	{
		if (my_data) {
			CRUCIBLE_ASSERT_NE(my_data->directory_handle, nullptr);

			errno = 0;
			::closedir(my_data->directory_handle);
		}
	}

	auto native_directory_list_iterator::operator=(native_directory_list_iterator &&that) -> native_directory_list_iterator &
	{
		if (my_data) {
			CRUCIBLE_ASSERT_NE(my_data->directory_handle, nullptr);

			errno = 0;
			::closedir(my_data->directory_handle);
		}

		my_data = std::move(that.my_data);
		return *this;
	}

	auto native_directory_list_iterator::advance() -> std::optional<filesystem_result<native_directory_entry>>
	{
		CRUCIBLE_ASSERT_NE(my_data, nullptr);
		CRUCIBLE_ASSERT_NE(my_data->directory_handle, nullptr);

		std::optional<native_directory_entry> next_element { std::nullopt };
		struct ::dirent *entry { nullptr };

		while ((errno = 0, entry = ::readdir(my_data->directory_handle)) != nullptr) {

#if CRUCIBLE_PLATFORM_HAS_DIRENT_D_NAMLEN
			std::size_t const name_length { entry->d_namlen };
#else // CRUCIBLE_PLATFORM_HAS_DIRENT_D_NAMLEN
			std::size_t const name_length { std::strlen(entry->d_name) };
#endif // CRUCIBLE_PLATFORM_HAS_DIRENT_D_NAMLEN

			bool const is_dot { std::strncmp(entry->d_name, ".", name_length) == 0 };
			bool const is_dot_dot { std::strncmp(entry->d_name, "..", name_length) == 0 };

			if (is_dot || is_dot_dot) {
				continue;
			}

			next_element = native_directory_entry {};
			next_element->name = ffi_string<char>(entry->d_name, name_length);

			if (entry->d_type == DT_LNK) {
				next_element->type = file_type::symbolic_link;
			} else if (entry->d_type == DT_DIR) {
				next_element->type = file_type::directory;
			} else {
				next_element->type = file_type::normal;
			}

			break;
		}

		if (errno != 0) {
			return make_failure<filesystem_error>(readdir_failed {});
		}

		if (next_element) {
			return make_success(std::move(next_element).value());
		}

		return std::nullopt;
	}

	auto try_make_directory_list_iterator_native(ffi_string<char> const &path) -> filesystem_result<native_directory_list_iterator>
	{
		auto data { std::make_unique<native_directory_list_iterator_data>() };

		errno = 0;
		data->directory_handle = ::opendir(path.data());

		if (!data->directory_handle) {
			return make_failure<filesystem_error>(opendir_failed {});
		}

		return make_success<native_directory_list_iterator>(std::move(data));
	}

	auto try_make_file_reader_native(ffi_string<char> const &path) -> filesystem_result<file_reader>
	{
		auto data { std::make_unique<file_reader_data>() };

		errno = 0;
		data->file_descriptor = ::open(path.data(), O_RDONLY);

		if (data->file_descriptor < 0) {
			return make_failure<filesystem_error>(open_failed {});
		}

		return make_success<file_reader>(std::move(data));
	}

	auto try_make_file_writer_native(ffi_string<char> const &path, file_creation_mode const mode) -> filesystem_result<file_writer>
	{
		// TODO: add an API for this information
		constexpr ::mode_t PERMISSION_BITS {
			S_IRUSR |
			S_IWUSR |
			S_IRGRP |
			S_IROTH
		};

		int flags { O_WRONLY | O_CREAT | O_TRUNC };

		switch (mode) {
		case file_creation_mode::create:
			flags |= O_EXCL;
			break;

		case file_creation_mode::overwrite:
			break;
		}

		auto data { std::make_unique<file_writer_data>() };

		errno = 0;
		data->file_descriptor = ::open(path.data(), flags, PERMISSION_BITS);

		if (data->file_descriptor < 0) {
			return make_failure<filesystem_error>(open_failed {});
		}

		return make_success<file_writer>(std::move(data));
	}

	auto try_read_file_type_native(ffi_string<char> const &path) -> filesystem_result<file_type>
	{
		struct ::stat metadata {};

		errno = 0;
		int const stat_status { ::stat(path.data(), &metadata) };

		if (stat_status < 0) {
			return make_failure<filesystem_error>(stat_failed {});
		}

		if ((metadata.st_mode & S_IFMT) == S_IFDIR) {
			return make_success(file_type::directory);
		}

		if ((metadata.st_mode & S_IFMT) == S_IFLNK) {
			return make_success(file_type::symbolic_link);
		}

		// We could check for `S_IFREG`, but `file_type` has no cases besides `normal`
		return make_success(file_type::normal);
	}

	auto try_read_directory_list_native(ffi_string<char> const &path) -> filesystem_result<heap_buffer<native_directory_entry>>
	{
		return try_make_directory_list_iterator_native(path)
			.take_success_then([](native_directory_list_iterator iterator) {
				return make_iterator_pipeline(std::move(iterator))
					.try_materialize<heap_buffer<native_directory_entry>>();
			});
	}

	auto try_read_file_size_native(ffi_string<char> const &path) -> filesystem_result<std::size_t>
	{
		// We don't use `file_reader::try_read_size()` here because we can save two system calls by
		// using `::stat()` instead of `::open()` + `::fstat()` + `::close()`

		struct ::stat metadata {};

		errno = 0;
		int const stat_status { ::stat(path.data(), &metadata) };

		if (stat_status < 0) {
			return make_failure<filesystem_error>(stat_failed {});
		}

		if (metadata.st_size < 0) {
			return make_failure<filesystem_error>(negative_file_size {});
		}

		static_assert(sizeof(metadata.st_size) <= sizeof(std::size_t));
		std::size_t const size { static_cast<std::size_t>(metadata.st_size) };

		return make_success(size);
	}

	auto try_read_text_file_native(ffi_string<char> const &path) -> filesystem_result<string>
	{
		return try_make_file_reader_native(path)
			.take_success_then([](file_reader file) {
				return file.try_read_text();
			});
	}

	auto try_read_data_file_native(ffi_string<char> const &path) -> filesystem_result<heap_buffer<std::byte>>
	{
		return try_make_file_reader_native(path)
			.take_success_then([](file_reader file) {
				return file.try_read_data();
			});
	}

	auto try_create_directory_native(ffi_string<char> const &path) -> filesystem_result<none>
	{
		// TODO: add an API for this information
		constexpr ::mode_t PERMISSION_BITS {
			S_IRUSR |
			S_IWUSR |
			S_IXUSR |
			S_IRGRP |
			S_IXGRP |
			S_IROTH |
			S_IXOTH
		};

		errno = 0;
		int const mkdir_status { ::mkdir(path.data(), PERMISSION_BITS) };

		if (mkdir_status < 0) {
			return make_failure<filesystem_error>(mkdir_failed {});
		}

		return make_success<none>();
	}

	auto try_create_text_file_native(ffi_string<char> const &path, string_view const text) -> filesystem_result<none>
	{
		return try_make_file_writer_native(path, file_creation_mode::create)
			.take_success_then([&text](file_writer writer) {
				return writer.try_write_text(text);
			});
	}

	auto try_create_data_file_native(ffi_string<char> const &path, immutable_view<std::byte> const &data) -> filesystem_result<none>
	{
		return try_make_file_writer_native(path, file_creation_mode::create)
			.take_success_then([&data](file_writer writer) {
				return writer.try_write_data(data);
			});
	}

	auto try_overwrite_text_file_native(ffi_string<char> const &path, string_view const text) -> filesystem_result<none>
	{
		return try_make_file_writer_native(path, file_creation_mode::overwrite)
			.take_success_then([&text](file_writer writer) {
				return writer.try_write_text(text);
			});
	}

	auto try_overwrite_data_file_native(ffi_string<char> const &path, immutable_view<std::byte> const &data) -> filesystem_result<none>
	{
		return try_make_file_writer_native(path, file_creation_mode::overwrite)
			.take_success_then([&data](file_writer writer) {
				return writer.try_write_data(data);
			});
	}

	auto try_delete_directory_recursive_native(ffi_string<char> const &path) -> filesystem_result<none>
	{
		CRUCIBLE_TRY_BIND(auto, iterator,
			try_make_directory_list_iterator_native(path));

		CRUCIBLE_TRY_BIND(auto, entries,
			make_iterator_pipeline(std::move(iterator))
			.try_materialize<heap_buffer<native_directory_entry>>());

		CRUCIBLE_TRY(
			iterate(entries)
			.map([&path](native_directory_entry const &entry) {
					ffi_string<char> const path_to_entry = path + "/" + entry.name;

					if (entry.type == file_type::directory) {
						return try_delete_directory_recursive_native(path_to_entry);
					}

					return try_delete_file_native(path_to_entry);
			})
			.try_consume()
		);

		return try_delete_directory_native(path);
	}

	auto try_delete_directory_native(ffi_string<char> const &path) -> filesystem_result<none>
	{
		errno = 0;
		int const rmdir_status { ::rmdir(path.data()) };

		if (rmdir_status < 0) {
			return make_failure<filesystem_error>(rmdir_failed {});
		}

		return make_success<none>();
	}

	auto try_delete_file_native(ffi_string<char> const &path) -> filesystem_result<none>
	{
		errno = 0;
		int const unlink_status { ::unlink(path.data()) };

		if (unlink_status < 0) {
			return make_failure<filesystem_error>(unlink_failed {});
		}

		return make_success<none>();
	}

	// Platform-neutral path API -------------------

	directory_list_iterator::directory_list_iterator(native_directory_list_iterator native_iterator) :
		my_native_iterator { std::move(native_iterator) }
	{}

	auto directory_list_iterator::advance() -> std::optional<filesystem_result<directory_entry>>
	{
		auto const native_result { my_native_iterator.advance() };

		if (native_result == std::nullopt)
		{
			return std::nullopt;
		}

		return native_result
			.value()
			.map_success([](native_directory_entry const &native_entry) {
				directory_entry entry;
				entry.name = string { native_entry.name.data(), native_entry.name.size() };
				entry.type = native_entry.type;
				return entry;
			});
	}

	file_reader::file_reader(std::unique_ptr<file_reader_data> data) :
		my_data { std::move(data) }
	{}

	file_reader::file_reader(file_reader &&that) :
		my_data { std::move(that.my_data) }
	{}

	file_reader::~file_reader()
	{
		if (my_data) {
			CRUCIBLE_ASSERT_GE(my_data->file_descriptor, 0);

			errno = 0;
			::close(my_data->file_descriptor);
		}
	}

	auto file_reader::operator=(file_reader &&that) -> file_reader &
	{
		if (my_data) {
			CRUCIBLE_ASSERT_GE(my_data->file_descriptor, 0);

			errno = 0;
			::close(my_data->file_descriptor);
		}

		my_data = std::move(that.my_data);
		return *this;
	}

	auto file_reader::try_read_size() -> filesystem_result<std::size_t>
	{
		CRUCIBLE_ASSERT_NE(my_data, nullptr);
		CRUCIBLE_ASSERT_GE(my_data->file_descriptor, 0);

		struct ::stat metadata {};

		errno = 0;
		int const fstat_status { ::fstat(my_data->file_descriptor, &metadata) };

		if (fstat_status < 0) {
			return make_failure<filesystem_error>(stat_failed {});
		}

		if (metadata.st_size < 0) {
			return make_failure<filesystem_error>(negative_file_size {});
		}

		static_assert(sizeof(metadata.st_size) <= sizeof(std::size_t));
		std::size_t const size { static_cast<std::size_t>(metadata.st_size) };

		return make_success(size);
	}

	auto file_reader::try_read_text() -> filesystem_result<string>
	{
		CRUCIBLE_ASSERT_NE(my_data, nullptr);
		CRUCIBLE_ASSERT_GE(my_data->file_descriptor, 0);

		return try_read_data()
			.map_success([](heap_buffer<std::byte> const &data) {
				auto text { make_heap_buffer<char>(data.size()) };
				std::memcpy(text.data(), data.data(), data.size());

				return string { std::move(text) };
			});
	}

	auto file_reader::try_read_data() -> filesystem_result<heap_buffer<std::byte>>
	{
		CRUCIBLE_ASSERT_NE(my_data, nullptr);
		CRUCIBLE_ASSERT_GE(my_data->file_descriptor, 0);

		return try_read_size()
			.take_success_then([this](std::size_t const size) -> filesystem_result<heap_buffer<std::byte>> {
				std::size_t bytes_read { 0 };

				heap_buffer<std::byte> buffer { size };
				int read_status { 0 };

				// ::read() is allowed to not read the whole buffer, so we do it in a loop until we're sure we're done
				do {
					errno = 0;
					read_status = ::read(my_data->file_descriptor, buffer.data() + bytes_read, size - bytes_read);

					if (read_status > 0) {
						bytes_read += read_status;
					}
				} while (bytes_read < size && read_status > 0);

				if (read_status < 0) {
					return make_failure<filesystem_error>(read_failed {});
				}

				if (bytes_read < size) {
					return make_failure<filesystem_error>(incomplete_read {});
				}

				return make_success(std::move(buffer));
			});
	}

	file_writer::file_writer(std::unique_ptr<file_writer_data> data) :
		my_data { std::move(data) }
	{}

	file_writer::file_writer(file_writer &&that) :
		my_data { std::move(that.my_data) }
	{}

	file_writer::~file_writer()
	{
		if (my_data) {
			CRUCIBLE_ASSERT_GE(my_data->file_descriptor, 0);

			errno = 0;
			::close(my_data->file_descriptor);
		}
	}

	auto file_writer::operator=(file_writer &&that) -> file_writer &
	{
		if (my_data) {
			CRUCIBLE_ASSERT_GE(my_data->file_descriptor, 0);

			errno = 0;
			::close(my_data->file_descriptor);
		}

		my_data = std::move(that.my_data);
		return *this;
	}

	auto file_writer::try_write_text(string_view const text) -> filesystem_result<none>
	{
		return try_write_data(view_representation(text.view_data()));
	}

	auto file_writer::try_write_data(immutable_view<std::byte> const &data) -> filesystem_result<none>
	{
		CRUCIBLE_ASSERT_NE(my_data, nullptr);
		CRUCIBLE_ASSERT_GE(my_data->file_descriptor, 0);

		std::size_t total_bytes_written { 0 };
		int write_status { 0 };

		// ::write() is allowed to not write the full contents, so we do it in a loop until we're sure we're done
		do {
			errno = 0;
			write_status = ::write(my_data->file_descriptor, data.data() + total_bytes_written, data.size() - total_bytes_written);

			if (write_status > 0) {
				total_bytes_written += write_status;
			}
		} while (total_bytes_written < data.size() && write_status > 0);

		if (write_status < 0) {
			return make_failure<filesystem_error>(write_failed {});
		}

		if (total_bytes_written < data.size()) {
			return make_failure<filesystem_error>(incomplete_write {});
		}

		return make_success<none>();
	}

	auto try_make_directory_list_iterator(string_view const path) -> filesystem_result<directory_list_iterator>
	{
		ffi_string<char> const ffi_path { path.data(), path.size() };

		return try_make_directory_list_iterator_native(ffi_path)
			.map_success([](native_directory_list_iterator native_iterator) {
				return directory_list_iterator { std::move(native_iterator) };
			});
	}

	auto try_make_file_reader(string_view const path) -> filesystem_result<file_reader>
	{
		ffi_string<char> const ffi_path { path.data(), path.size() };
		return try_make_file_reader_native(ffi_path);
	}

	auto try_make_file_writer(string_view const path, file_creation_mode const mode) -> filesystem_result<file_writer>
	{
		ffi_string<char> const ffi_path { path.data(), path.size() };
		return try_make_file_writer_native(ffi_path, mode);
	}

	auto try_read_file_type(string_view const path) -> filesystem_result<file_type>
	{
		ffi_string<char> const ffi_path { path.data(), path.size() };
		return try_read_file_type_native(ffi_path);
	}

	auto try_read_directory_list(string_view const path) -> filesystem_result<heap_buffer<directory_entry>>
	{
		ffi_string<char> const ffi_path { path.data(), path.size() };
		return try_make_directory_list_iterator(path)
			.take_success_then([](directory_list_iterator iterator) {
				return make_iterator_pipeline(std::move(iterator))
					.try_materialize<heap_buffer<directory_entry>>();
			});
	}

	auto try_read_file_size(string_view const path) -> filesystem_result<std::size_t>
	{
		ffi_string<char> const ffi_path { path.data(), path.size() };
		return try_read_file_size_native(ffi_path);
	}

	auto try_read_text_file(string_view const path) -> filesystem_result<string>
	{
		ffi_string<char> const ffi_path { path.data(), path.size() };
		return try_read_text_file_native(ffi_path);
	}

	auto try_read_data_file(string_view const path) -> filesystem_result<heap_buffer<std::byte>>
	{
		ffi_string<char> const ffi_path { path.data(), path.size() };
		return try_read_data_file_native(ffi_path);
	}

	auto try_create_directory(string_view const path) -> filesystem_result<none>
	{
		ffi_string<char> const ffi_path { path.data(), path.size() };
		return try_create_directory_native(ffi_path);
	}

	auto try_create_text_file(string_view const path, string_view const text) -> filesystem_result<none>
	{
		ffi_string<char> const ffi_path { path.data(), path.size() };
		return try_create_text_file_native(ffi_path, text);
	}

	auto try_create_data_file(string_view const path, immutable_view<std::byte> const &data) -> filesystem_result<none>
	{
		ffi_string<char> const ffi_path { path.data(), path.size() };
		return try_create_data_file_native(ffi_path, data);
	}

	auto try_overwrite_text_file(string_view const path, string_view const text) -> filesystem_result<none>
	{
		ffi_string<char> const ffi_path { path.data(), path.size() };
		return try_overwrite_text_file_native(ffi_path, text);
	}

	auto try_overwrite_data_file(string_view const path, immutable_view<std::byte> const &data) -> filesystem_result<none>
	{
		ffi_string<char> const ffi_path { path.data(), path.size() };
		return try_overwrite_data_file_native(ffi_path, data);
	}

	auto try_delete_directory_recursive(string_view const path) -> filesystem_result<none>
	{
		ffi_string<char> const ffi_path { path.data(), path.size() };
		return try_delete_directory_recursive_native(ffi_path);
	}

	auto try_delete_directory(string_view const path) -> filesystem_result<none>
	{
		ffi_string<char> const ffi_path { path.data(), path.size() };
		return try_delete_directory_native(ffi_path);
	}

	auto try_delete_file(string_view const path) -> filesystem_result<none>
	{
		ffi_string<char> const ffi_path { path.data(), path.size() };
		return try_delete_file_native(ffi_path);
	}
}