windows_filesystem.cpp

#include "crucible/core/filesystem.inl"

#include <cstdint>
#include <limits>
#include <memory>
#include <utility>

#include <Windows.h>

#include "crucible/core/iterators.inl"

namespace crucible::core
{
  // Windows native path API ---------------------

  struct Native_Directory_List_Iterator_Data
  {
    FFI_String<wchar_t> pattern {};

    ::HANDLE handle { INVALID_HANDLE_VALUE };

    ::WIN32_FIND_DATAW current {};

    bool is_first { true };

    bool is_done { false };
  };

  struct File_Reader_Data
  {
    ::HANDLE handle { INVALID_HANDLE_VALUE };
  };

  struct File_Writer_Data
  {
    ::HANDLE handle { INVALID_HANDLE_VALUE };
  };

  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_CORE_ASSERT_NE(my_data->handle, INVALID_HANDLE_VALUE);

      ::SetLastError(0);
      ::FindClose(my_data->handle);
    }
  }

  auto Native_Directory_List_Iterator::operator=(Native_Directory_List_Iterator &&that) -> Native_Directory_List_Iterator &
  {
    if (my_data) {
      CRUCIBLE_CORE_ASSERT_NE(my_data->handle, INVALID_HANDLE_VALUE);

      ::SetLastError(0);
      ::FindClose(my_data->handle);
    }

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

  auto Native_Directory_List_Iterator::advance() -> std::optional<Filesystem_Result<FFI_String<wchar_t>>>
  {
    // Moved-from or no matching files
    if (my_data == nullptr) {
      return std::nullopt;
    }

    // Already finished
    if (my_data->is_done) {
      return std::nullopt;
    }

    // Either `my_data` should be `nullptr` or `my_data->handle` should be valid by this point
    CRUCIBLE_CORE_ASSERT_NE(my_data->handle, INVALID_HANDLE_VALUE);

    // Trick to avoid duplicating code in the case where `is_first` is `false`: we would need to
    // call `::FindFirstFileW()` once to prime the loop, but since we're skipping `L"."` and `L".."`
    // we can just initialize `filename` to one of those values to get one guaranteed free loop
    FFI_String<wchar_t> filename { L"." };

    if (my_data->is_first) {
      my_data->is_first = false;
      filename = my_data->current.cFileName;
    }

    while (filename == L"." || filename == L"..") {
      ::SetLastError(0);
      if (::FindNextFileW(my_data->handle, &my_data->current) == 0) {
        if (::GetLastError() == ERROR_NO_MORE_FILES) {
          my_data->is_done = true;
          return std::nullopt;
        } else {
          return make_failure<Filesystem_Error>(FindNextFileW_Failed {});
        }
      }

      filename = my_data->current.cFileName;
    }

    return filename;
  }

  auto try_make_directory_list_iterator_native(FFI_String<wchar_t> const &path) -> Filesystem_Result<Native_Directory_List_Iterator>
  {
    auto data { std::make_unique<Native_Directory_List_Iterator_Data>() };
    data->pattern = path + L"\\*";

    ::SetLastError(0);
    data->handle = ::FindFirstFileW(data->pattern.data(), &data->current);

    if (data->handle == INVALID_HANDLE_VALUE) {
      if (::GetLastError() == ERROR_FILE_NOT_FOUND) {
        // Pattern didn't match anything, but it's not an error
        return make_success<Native_Directory_List_Iterator>(nullptr);
      } else {
        return make_failure<Filesystem_Error>(FindFirstFileW_Failed {});
      }
    }

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

  auto try_make_file_reader_native(FFI_String<wchar_t> const &path) -> Filesystem_Result<File_Reader>
  {
    auto data { std::make_unique<File_Reader_Data>() };

    ::SetLastError(0);
    data->handle = ::CreateFileW(path.data(), GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr)

    if (data->handle == INVALID_HANDLE_VALUE) {
      return make_failure<Filesystem_Error>(CreateFileW_Failed {});
    }

    return File_Reader { std::move(data) };
  }

  auto try_make_file_writer_native(FFI_String<wchar_t> const &path, File_Creation_Mode const mode) -> Filesystem_Result<File_Reader>
  {
    ::DWORD access_mode { 0 };
    ::DWORD share_mode { 0 };
    ::DWORD create_mode { 0 };

    switch (mode) {
    case File_Creation_Mode::Create:
      access_mode = GENERIC_WRITE;
      share_mode = FILE_SHARE_WRITE;
      create_mode = CREATE_NEW;
      break;

    case File_Creation_Mode::Overwrite:
      access_mode = GENERIC_WRITE;
      share_mode = FILE_SHARE_WRITE;
      create_mode = CREATE_ALWAYS;
      break;
    };

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

    ::SetLastError(0);
    data->handle = ::CreateFileW(path.data(), access_mode, share_mode, nullptr, create_mode, FILE_ATTRIBUTE_NORMAL, nullptr);

    if (data->handle == INVALID_HANDLE_VALUE) {
      return make_failure<Filesystem_Error>(CreateFileW_Failed {});
    }

    return File_Writer { std::move(data) };
  }

  auto try_read_file_type_native(FFI_String<wchar_t> const &path) -> Filesystem_Result<File_Type>
  {
    ::SetLastError(0);
    ::DWORD const attributes { ::GetFileAttributesW(path.data()) };

    if (attributes == INVALID_FILE_ATTRIBUTES) {
      return make_failure<Filesystem_Error>(GetFileAttributesW_Failed {});
    }

    if ((attributes & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY) {
      return make_success(File_Type::Directory);
    }

    // We could check for `FILE_ATTRIBUTE_NORMAL`, but `File_Type` has no cases besides `Normal`
    return make_success(File_Type::Normal);
  }

  auto try_read_directory_list_native(FFI_String<wchar_t> const &path) -> Filesystem_Result<Heap_Buffer<FFI_String<wchar_t>>>
  {
    return make_pipeline(Native_Directory_List_Iterator { path })
      .try_materialize<Heap_Buffer<FFI_String<wchar_t>>();
  }

  auto try_read_file_size_native(FFI_String<wchar_t> const &path) -> Filesystem_Result<std::size_t>
  {
    return try_open_file_native(path)
      .take_success_then([](File_Reader const &file) {
          return file.read_size();
      });
  }

  auto try_read_text_file_native(FFI_String<wchar_t> const &path) -> Filesystem_Result<String>
  {
    return try_make_file_reader_native(path)
      .take_success_then([](File_Reader const &file) {
        return file.try_read_text();
      });
  }

  auto try_read_data_file_native(FFI_String<wchar_t> const &path) -> Filesystem_Result<Heap_Buffer<std::byte>>
  {
    return try_make_file_reader_native(path)
      .take_success_then([](File_Reader const &file) {
        return file.try_read_data();
      });
  }

  auto try_create_directory_native(FFI_String<wchar_t> const &path) -> Filesystem_Result<None>
  {
    ::SetLastError(0);
    bool const succeeded { ::CreateDirectoryW(path.data(), nullptr) != 0 };

    if (!succeeded) {
      return make_failure<Filesystem_Error>(CreateDirectoryW_Failed {});
    }

    return make_success(make_none());
  }

  auto try_create_text_file_native(FFI_String<wchar_t> 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 const &writer) {
        return writer.try_write_text(text);
      });
  }

  auto try_create_data_file_native(FFI_String<wchar_t> 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 const &file) {
        return writer.try_write_data(data);
      });
  }

  auto try_overwrite_text_file_native(FFI_String<wchar_t> 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 const &writer) {
        return writer.try_write_text(text);
      });
  }

  auto try_overwrite_data_file_native(FFI_String<wchar_t> 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 const &writer) {
        return writer.try_write_data(data);
      });
  }

  auto try_delete_directory_native(FFI_String<wchar_t> const &path) -> Filesystem_Result<None>
  {
    ::SetLastError(0);
    bool const succeeded { ::RemoveDirectoryW(path.data()) != 0 };

    if (!succeeded) {
      return make_failure<Filesystem_Error>(RemoveDirectoryW_Failed {});
    }

    return make_success<None>();
  }

  auto try_delete_file_native(FFI_String<wchar_t> const &path) -> Filesystem_Result<None>
  {
    ::SetLastError(0);
    bool const succeeded { ::DeleteFileW(path.data()) != 0 };

    if (!succeeded) {
      return make_failure<Filesystem_Error>(DeleteFileW_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<String>>
  {
    auto native_result { my_native_iterator.advance() };

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

    return native_result
      .value()
      .take_success_then(bulk_transcode_wide_to_utf8);
  }

  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_CORE_ASSERT_NE(my_data->handle, INVALID_HANDLE_VALUE);

      ::SetLastError(0);
      ::CloseHandle(my_data->handle);
    }
  }

  auto File_Reader::operator=(File_Reader &&that) -> File_Reader &
  {
    if (my_data) {
      CRUCIBLE_CORE_ASSERT_NE(my_data->handle, INVALID_HANDLE_VALUE);

      ::SetLastError(0);
      ::CloseHandle(my_data->handle);
    }

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

  auto File_Reader::try_read_size() -> Filesystem_Result<std::size_t>
  {
    CRUCIBLE_CORE_ASSERT_NE(my_data, nullptr);
    CRUCIBLE_CORE_ASSERT_NE(my_data->handle, INVALID_HANDLE_VALUE);

    std::size_t file_size { 0 };

    {
      ::LARGE_INTEGER raw_size {};

      ::SetLastError(0);
      bool const succeeded { ::GetFileSizeEx(my_data->handle.value(), &raw_size) != 0 };

      if (!succeeded) {
        return make_failure<Filesystem_Error>(GetFileSizeEx_Failed {});
      }

      static_assert(sizeof(raw_size.QuadPart) >= sizeof(std::uint64_t));
      static_assert(sizeof(raw_size.QuadPart) <= sizeof(file_size));

      if (raw_size.QuadPart < 0) {
        return make_failure<Filesystem_Error>(Negative_File_Size {});
      }

      file_size = raw_size.QuadPart;
    }

    return make_success(file_size);
  }

  auto File_Reader::try_read_text() -> Filesystem_Result<String>
  {
    return try_read_data()
      .map_success([](Heap_Buffer<std::byte> const &data) {
        return String { data.data(), data.size() };
      });
  }

  auto File_Reader::try_read_data() -> Filesystem_Result<Heap_Buffer<std::byte>>
  {
    CRUCIBLE_CORE_ASSERT_NE(my_data, nullptr);
    CRUCIBLE_CORE_ASSERT_NE(my_data->handle, INVALID_HANDLE_VALUE);

    return try_read_size()
      .take_success_then([](std::size_t const size) {
        HeapBuffer<std::byte> buffer { size };
        std::size_t total_bytes_read { 0 };

        // ::ReadFile() is allowed to not read the whole buffer, so we do it in a loop until we're sure we're done
        do {
          constexpr ::DWORD DWORD_MAX { std::numeric_limits<::DWORD>::max() };
          std::size_t const remaining_size { size - total_bytes_read };

          ::DWORD const intended_read_size { remaining_size >= DWORD_MAX ? DWORD_MAX : static_cast<::DWORD>(remaining_size) };
          ::DWORD bytes_actually_read { 0 };

          ::SetLastError(0);
          ::BOOL const succeeded {
            ::ReadFile(my_data->handle.value(), buffer.data() + total_bytes_read, intended_read_size, &bytes_actually_read, nullptr)
          };

          if (!succeeded) {
            break;
          }

          total_bytes_read += bytes_actually_read;
        } while (total_bytes_read < size);

        if (total_bytes_read < size) {
          return make_failure<Filesystem_Error>(ReadFile_Failed {});
        }

        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_CORE_ASSERT_NE(my_data->handle, INVALID_HANDLE_VALUE);

      ::SetLastError(0);
      ::CloseHandle(my_data->handle);
    }
  }

  auto File_Writer::operator=(File_Writer &&that) -> File_Writer &
  {
    if (my_data) {
      CRUCIBLE_CORE_ASSERT_NE(my_data->handle, INVALID_HANDLE_VALUE);

      ::SetLastError(0);
      ::CloseHandle(my_data->handle);
    }

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

  auto File_Writer::try_write_text(String_View const &text) -> Filesystem_Result<None>
  {
    Immutable_View<std::byte> const data { text.data(), text.size() };
    return try_write_data(data);
  }

  auto File_Writer::try_write_data(Immutable_View<std::byte> const &data) -> Filesystem_Result<None>
  {
    CRUCIBLE_CORE_ASSERT_NE(my_data, nullptr);
    CRUCIBLE_CORE_ASSERT_NE(my_data->handle, INVALID_HANDLE_VALUE);

    std::size_t total_bytes_written { 0 };

    // ::WriteFile() is allowed to not write the whole buffer, so we do it in a loop until we're sure we're done
    do {
      constexpr ::DWORD DWORD_MAX { std::numeric_limits<::DWORD>::max() };
      std::size_t const remaining_size { data.size() - total_bytes_written };

      ::DWORD const intended_write_size { remaining_size >= DWORD_MAX ? DWORD_MAX : static_cast<::DWORD>(remaining_size) };
      ::DWORD bytes_actually_written { 0 };

      ::SetLastError(0);
      ::BOOL const succeeded {
        ::WriteFile(my_data->handle, data.data() + total_bytes_written, intended_write_size, &bytes_actually_written, nullptr)
      };

      if (!succeeded) {
        break;
      }

      total_bytes_written += bytes_actually_written;
    } while (total_bytes_written < data.size());

    if (total_bytes_written < data.size()) {
      return make_failure<Filesystem_Error>(WriteFile_Failed {});
    }

    return make_success<None>();
  }

  auto try_make_directory_list_iterator(String_View const &path) -> Filesystem_Result<Directory_List_Iterator>
  {
    return bulk_transcode_utf8_to_wide(path)
      .take_success_then(try_make_directory_list_iterator_native)
      .map([](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>
  {
    return bulk_transcode_utf8_to_wide(path)
      .take_success_then(try_make_file_reader_native);
  }

  auto try_make_file_writer(String_View const &path, File_Creation_Mode const mode) -> Filesystem_Result<File_Writer>
  {
    return bulk_transcode_utf8_to_wide(path)
      .take_success_then([](FFI_String<wchar_t> const &wide_path) {
        return try_make_file_writer_native(wide_path, mode);
      });
  }

  auto try_read_file_type(String_View const &path) -> Filesystem_Result<File_Type>
  {
    return bulk_transcode_utf8_to_wide(path)
      .take_success_then(try_read_file_type_native);
  }

  auto try_read_directory_list(String_View const &path) -> Filesystem_Result<Heap_Buffer<String>>
  {
    return make_pipeline(try_make_directory_list_iterator(path))
      .try_materialize<Heap_Buffer<String>>();
  }

  auto try_read_file_size(String_View const &path) -> Filesystem_Result<std::size_t>
  {
    return bulk_transcode_utf8_to_wide(path)
      .take_success_then(try_read_file_size_native);
  }

  auto try_read_text_file(String_View const &path) -> Filesystem_Result<String>
  {
    return bulk_transcode_utf8_to_wide(path)
      .take_success_then(try_read_text_file_native);
  }

  auto try_read_data_file(String_View const &path) -> Filesystem_Result<Heap_Buffer<std::byte>>
  {
    return bulk_transcode_utf8_to_wide(path)
      .take_success_then(try_read_data_file_native);
  }

  auto try_create_directory(String_View const &path) -> Filesystem_Result<None>
  {
    return bulk_transcode_utf8_to_wide(path)
      .take_success_then(try_create_directory_native);
  }

  auto try_create_text_file(String_View const &path, String_View const &text) -> Filesystem_Result<None>
  {
    return bulk_transcode_utf8_to_wide(path)
      .take_success_then(try_create_text_file_native);
  }

  auto try_create_data_file(String_View const &path, Immutable_View<std::byte> const &data) -> Filesystem_Result<None>
  {
    return bulk_transcode_utf8_to_wide(path)
      .take_success_then(try_create_data_file_native);
  }

  auto try_overwrite_text_file(String_View const &path, String_View const &text) -> Filesystem_Result<None>
  {
    return bulk_transcode_utf8_to_wide(path)
      .take_success_then(try_overwrite_text_file_native);
  }

  auto try_overwrite_data_file(String_View const &path, Immutable_View<std::byte> const &data) -> Filesystem_Result<None>
  {
    return bulk_transcode_utf8_to_wide(path)
      .take_success_then(try_overwrite_data_file_native);
  }

  auto try_delete_directory(String_View const &path) -> Filesystem_Result<None>
  {
    return bulk_transcode_utf8_to_wide(path)
      .take_success_then(try_delete_directory_native);
  }

  auto try_delete_file(String_View const &path) -> Filesystem_Result<None>
  {
    return bulk_transcode_utf8_to_wide(path)
      .take_success_then(try_delete_file_native);
  }
}