fs.cpp

#include "crucible/windows/fs.hpp"

#include "crucible/core/resource_warden.inl"
#include "crucible/windows/transcoding.hpp"

#include <Windows.h>

#include <limits>
#include <type_traits>

namespace crucible::windows::fs {
  struct CloseHandleAdapter {
    auto operator()(::HANDLE file_handle) const -> void {
      ::CloseHandle(file_handle);
    }
  };

  using FileHandleWarden = core::resource_warden::ResourceWarden<::HANDLE, CloseHandleAdapter>;

  struct FindCloseAdapter {
    auto operator()(::HANDLE find_handle) const -> void {
      ::FindClose(find_handle);
    }
  };

  using FindHandleWarden = core::resource_warden::ResourceWarden<::HANDLE, FindCloseAdapter>;

  [[nodiscard]]
  auto read_file_size_from_file_handle(::HANDLE file_handle) -> errors::WindowsResult<std::size_t> {
    std::size_t file_size { 0 };

    {
      ::LARGE_INTEGER raw_size {};
      bool const succeeded { ::GetFileSizeEx(file_handle, &raw_size) != 0 };
      if (!succeeded) {
        return core::either::make_lhs<errors::WindowsError>(errors::GetFileSizeExFailed {});
      }

      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 core::either::make_lhs<errors::WindowsError>(errors::NegativeFileSize {});
      }

      file_size = raw_size.QuadPart;
    }

    return core::either::make_rhs(file_size);
  }

  auto create_directory(std::string const &path) -> errors::WindowsResult<core::none::None> {
    auto const wide_path { transcoding::transcode_utf8_to_utf16(path) };
    if (wide_path.has_lhs()) {
      return wide_path.forward_lhs();
    }

    return create_directory(wide_path.get_rhs());
  }

  auto create_directory(std::wstring const &path) -> errors::WindowsResult<core::none::None> {
    bool const succeeded { ::CreateDirectoryW(path.data(), nullptr) != 0 };
    if (!succeeded) {
      return core::either::make_lhs<errors::WindowsError>(errors::CreateDirectoryWFailed {});
    }

    return core::either::make_rhs<core::none::None>();
  }

  auto create_file(std::string const &path, std::vector<std::byte> const &contents) -> errors::WindowsResult<core::none::None> {
    auto const wide_path { transcoding::transcode_utf8_to_utf16(path) };
    if (wide_path.has_lhs()) {
      return wide_path.forward_lhs();
    }

    return create_file(wide_path.get_rhs(), contents);
  }

  auto create_file(std::wstring const &path, std::vector<std::byte> const &contents) -> errors::WindowsResult<core::none::None> {
    ::HANDLE file_handle { ::CreateFileW(path.data(), GENERIC_WRITE, FILE_SHARE_WRITE, nullptr, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, nullptr) };
    if (file_handle == INVALID_HANDLE_VALUE) {
      return core::either::make_lhs<errors::WindowsError>(errors::CreateFileWFailed {});
    }

    FileHandleWarden warden { file_handle };

    std::size_t total_bytes_written { 0 };

    do {
      constexpr ::DWORD DWORD_MAX { std::numeric_limits<::DWORD>::max() };
      std::size_t const remaining_size { contents.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 };

      bool const succeeded { ::WriteFile(file_handle, contents.data() + total_bytes_written, intended_write_size, &bytes_actually_written, nullptr) != 0 };
      if (!succeeded) {
        break;
      }

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

    if (total_bytes_written < contents.size()) {
      return core::either::make_lhs<errors::WindowsError>(errors::WriteFileFailed {});
    }

    return core::either::make_rhs<core::none::None>();
  }

  auto delete_directory(std::string const &path) -> errors::WindowsResult<core::none::None> {
    auto const wide_path { transcoding::transcode_utf8_to_utf16(path) };
    if (wide_path.has_lhs()) {
      return wide_path.forward_lhs();
    }

    return delete_directory(wide_path.get_rhs());
  }

  auto delete_directory(std::wstring const &path) -> errors::WindowsResult<core::none::None> {
    bool const succeeded { ::RemoveDirectoryW(path.data()) != 0 };
    if (!succeeded) {
      return core::either::make_lhs<errors::WindowsError>(errors::RemoveDirectoryWFailed {});
    }

    return core::either::make_rhs<core::none::None>();
  }

  auto delete_file(std::string const &path) -> errors::WindowsResult<core::none::None> {
    auto const wide_path { transcoding::transcode_utf8_to_utf16(path) };
    if (wide_path.has_lhs()) {
      return wide_path.forward_lhs();
    }

    return delete_file(wide_path.get_rhs());
  }

  auto delete_file(std::wstring const &path) -> errors::WindowsResult<core::none::None> {
    bool const succeeded { ::DeleteFileW(path.data()) != 0 };
    if (!succeeded) {
      return core::either::make_lhs<errors::WindowsError>(errors::DeleteFileWFailed {});
    }

    return core::either::make_rhs<core::none::None>();
  }

  auto is_directory(std::string const &path) -> errors::WindowsResult<bool> {
    auto const wide_path { transcoding::transcode_utf8_to_utf16(path) };
    if (wide_path.has_lhs()) {
      return wide_path.forward_lhs();
    }

    return is_directory(wide_path.get_rhs());
  }

  auto is_directory(std::wstring const &path) -> errors::WindowsResult<bool> {
    ::DWORD const attributes { ::GetFileAttributesW(path.data()) };
    if (attributes == INVALID_FILE_ATTRIBUTES) {
      return core::either::make_lhs<errors::WindowsError>(errors::GetFileAttributesWFailed {});
    }

    return core::either::make_rhs((attributes & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY);
  }

  auto is_file(std::string const &path) -> errors::WindowsResult<bool> {
    auto const wide_path { transcoding::transcode_utf8_to_utf16(path) };
    if (wide_path.has_lhs()) {
      return wide_path.forward_lhs();
    }

    return is_file(wide_path.get_rhs());
  }

  auto is_file(std::wstring const &path) -> errors::WindowsResult<bool> {
    auto const invert {
      [](bool const value) -> bool {
        return !value;
      }
    };

    auto const result { is_directory(path) };
    return result.map_rhs(invert);
  }

  auto read_directory_list(std::string const &path) -> errors::WindowsResult<std::vector<std::string>> {
    auto const wide_path { transcoding::transcode_utf8_to_utf16(path) };
    if (wide_path.has_lhs()) {
      return wide_path.forward_lhs();
    }

    auto const wide_directory_list { read_directory_list(wide_path.get_rhs()) };
    if (wide_directory_list.has_lhs()) {
      return wide_directory_list.forward_lhs();
    }

    std::vector<std::string> directory_list;
    for (auto const &wide_directory : wide_directory_list.get_rhs()) {
      auto directory = transcoding::transcode_utf16_to_utf8(wide_directory);
      if (directory.has_lhs()) {
        return directory.forward_lhs();
      }

      directory_list.emplace_back(std::move(directory).get_rhs());
    }

    return core::either::make_rhs(directory_list);
  }

  auto read_directory_list(std::wstring const &path) -> errors::WindowsResult<std::vector<std::wstring>> {
    auto const wildcard { path + L"\\*" };

    ::WIN32_FIND_DATAW find_data {};
    ::HANDLE find_handle { ::FindFirstFileW(wildcard.data(), &find_data) };
    if (find_handle == INVALID_HANDLE_VALUE) {
      return core::either::make_lhs<errors::WindowsError>(errors::FindFirstFileWFailed {});
    }

    FindHandleWarden warden { find_handle };

    std::vector<std::wstring> items;

    do {
      std::wstring const filename { find_data.cFileName };

      bool const is_dot { filename == L"." };
      bool const is_dot_dot { filename == L".." };

      if (!is_dot && !is_dot_dot) {
        items.emplace_back(find_data.cFileName);
      }
    } while (::FindNextFileW(find_handle, &find_data) != 0);

    if (::GetLastError() != ERROR_NO_MORE_FILES) {
      return core::either::make_lhs<errors::WindowsError>(errors::FindNextFileWFailed {});
    }

    return core::either::make_rhs(std::move(items));
  }

  auto read_file_data(std::string const &path) -> errors::WindowsResult<std::vector<std::byte>> {
    auto const wide_path { transcoding::transcode_utf8_to_utf16(path) };
    if (wide_path.has_lhs()) {
      return wide_path.forward_lhs();
    }

    return read_file_data(wide_path.get_rhs());
  }

  auto read_file_data(std::wstring const &path) -> errors::WindowsResult<std::vector<std::byte>> {
    ::HANDLE file_handle { ::CreateFileW(path.data(), GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr) };
    if (file_handle == INVALID_HANDLE_VALUE) {
      return core::either::make_lhs<errors::WindowsError>(errors::CreateFileWFailed {});
    }

    FileHandleWarden warden { file_handle };

    auto const read_file_size_result { read_file_size_from_file_handle(file_handle) };
    if (read_file_size_result.has_lhs()) {
      return read_file_size_result.forward_lhs();
    }

    std::size_t const file_size { read_file_size_result.get_rhs() };
    std::vector<std::byte> buffer(file_size, std::byte(0x00));

    std::size_t total_bytes_read { 0 };

    do {
      constexpr ::DWORD DWORD_MAX { std::numeric_limits<::DWORD>::max() };
      std::size_t const remaining_size { file_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 };

      bool const succeeded { ::ReadFile(file_handle, buffer.data(), intended_read_size, &bytes_actually_read, nullptr) != 0 };
      if (!succeeded) {
        break;
      }

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

    if (total_bytes_read < file_size) {
      return core::either::make_lhs<errors::WindowsError>(errors::ReadFileFailed {});
    }

    return core::either::make_rhs(std::move(buffer));
  }

  auto read_file_size(std::string const &path) -> errors::WindowsResult<std::size_t> {
    auto const wide_path { transcoding::transcode_utf8_to_utf16(path) };
    if (wide_path.has_lhs()) {
      return wide_path.forward_lhs();
    }

    return read_file_size(wide_path.get_rhs());
  }

  auto read_file_size(std::wstring const &path) -> errors::WindowsResult<std::size_t> {
    ::HANDLE file_handle { ::CreateFileW(path.data(), GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr) };
    if (file_handle == INVALID_HANDLE_VALUE) {
      return core::either::make_lhs<errors::WindowsError>(errors::CreateFileWFailed {});
    }

    FileHandleWarden warden(file_handle);
    return read_file_size_from_file_handle(file_handle);
  }
}