CURL

[pluto699]

https://github.com/containerd/overlaybd/blob/06e5f0dfc3ff5ac39386ea801962851d4da0c092/CMake/Findcurl.cmake#L7

[pluto699]

https://github.com/thewh1teagle/loud.cpp/blob/4259a499693176e588d9a7923547d793af5db9ef/cmake/curl.cmake#L4

[pluto699]

https://github.com/cpm-cmake/CPM.cmake

[pluto699]

curl.h

// Copyright (c) Sergey Kovalevich <inndie@gmail.com>
// SPDX-License-Identifier: AGPL-3.0

#pragma once

#include <chrono>
#include <concepts>
#include <expected>
#include <optional>
#include <span>
#include <system_error>
#include <utility>

#include <curl/curl.h>

namespace walng {
namespace curl {

struct EasyErrorCategory final : std::error_category {
  char const* name() const noexcept override {
    return "curl-easy";
  }
  std::string message(int ec) const override {
    return ::curl_easy_strerror(static_cast<::CURLcode>(ec));
  }
};

inline std::error_code makeEasyErrorCode(CURLcode rc) noexcept {
  static EasyErrorCategory errorCategory;
  return std::error_code(static_cast<int>(rc), errorCategory);
}

struct MultiErrorCategory final : std::error_category {
  char const* name() const noexcept override {
    return "multi-easy";
  }
  std::string message(int ec) const override {
    return ::curl_multi_strerror(static_cast<::CURLMcode>(ec));
  }
};

inline std::error_code makeMultiErrorCode(CURLMcode rc) noexcept {
  static MultiErrorCategory errorCategory;
  return std::error_code(static_cast<int>(rc), errorCategory);
}

enum class InternalError { FailedEasyHandle, FailedMultiHandle };

struct InternalErrorCategory final : std::error_category {
  char const* name() const noexcept override {
    return "internal-error";
  }
  std::string message(int ec) const override {
    switch (static_cast<InternalError>(ec)) {
    case InternalError::FailedEasyHandle:
      return "failed to init easy handle";
    case InternalError::FailedMultiHandle:
      return "failed to init multi handle";
    default:
      break;
    }
    return "";
  }
};

inline std::error_code makeInternalErrorCode(InternalError rc) noexcept {
  static InternalErrorCategory errorCategory;
  return std::error_code(static_cast<int>(rc), errorCategory);
}

namespace detail {

template <typename T>
struct GetInfoImpl {
  std::expected<T, std::error_code> operator()(CURL* handle, CURLINFO info) const noexcept {
    T result;
    if (auto const rc = ::curl_easy_getinfo(handle, info, &result); rc != CURLE_OK) {
      return std::unexpected(makeEasyErrorCode(rc));
    }
    return result;
  }
};

template <>
struct GetInfoImpl<std::string> {
  std::expected<std::string, std::error_code> operator()(CURL* handle, CURLINFO info) const noexcept {
    return GetInfoImpl<char const*>{}(handle, info).transform([](char const* value) {
      return std::string(value);
    });
  }
};

template <>
struct GetInfoImpl<std::string_view> {
  std::expected<std::string_view, std::error_code> operator()(CURL* handle, CURLINFO info) const noexcept {
    return GetInfoImpl<char const*>{}(handle, info).transform([](char const* value) {
      return std::string_view(value);
    });
  }
};

} // namespace detail

class Easy {
private:
  CURL* handle_ = nullptr;

public:
  Easy(Easy const&) = delete;
  Easy& operator=(Easy const&) = delete;

  Easy() = default;

  explicit Easy(CURL* handle) noexcept : handle_(handle) {}

  ~Easy() noexcept {
    if (handle_) {
      ::curl_easy_cleanup(handle_);
    }
  }

  Easy(Easy&& other) noexcept : handle_(std::exchange(other.handle_, nullptr)) {}

  Easy& operator=(Easy&& other) noexcept {
    if (this != &other) {
      this->~Easy();
      new (this) Easy(std::move(other));
    }
    return *this;
  }

  [[nodiscard]] operator CURL*() const noexcept {
    return handle_;
  }

  void reset() noexcept {
    ::curl_easy_reset(handle_);
  }

  template <typename T>
  std::expected<void, std::error_code> setOption(CURLoption option, T parameter) noexcept {
    if (auto const rc = ::curl_easy_setopt(handle_, option, parameter); rc != CURLE_OK) {
      return std::unexpected(makeEasyErrorCode(rc));
    }
    return {};
  }

  std::expected<void, std::error_code> setOption(CURLoption option, std::string const& parameter) noexcept {
    return setOption(option, parameter.c_str());
  }

  std::expected<void, std::error_code> setOption(CURLoption option, std::string_view parameter) noexcept {
    return setOption(option, std::string(parameter).c_str());
  }

  template <typename T>
  std::expected<T, std::error_code> getInfo(CURLINFO info) const noexcept {
    return detail::GetInfoImpl<T>{}(handle_, info);
  }

  static std::expected<Easy, std::error_code> create() noexcept {
    auto handle = ::curl_easy_init();
    if (!handle) [[unlikely]] {
      return std::unexpected(makeInternalErrorCode(InternalError::FailedEasyHandle));
    }
    return Easy(handle);
  }
};

class Multi {
private:
  CURLM* handle_ = nullptr;

public:
  Multi(Multi const&) = delete;
  Multi& operator=(Multi const&) = delete;

  Multi() = default;

  explicit Multi(CURLM* handle) noexcept : handle_(handle) {}

  Multi(Multi&& other) noexcept : handle_(std::exchange(other.handle_, nullptr)) {}

  Multi& operator=(Multi&& other) noexcept {
    if (this != &other) {
      this->~Multi();
      new (this) Multi(std::move(other));
    }
    return *this;
  }

  ~Multi() noexcept {
    if (handle_) {
      ::curl_multi_cleanup(handle_);
    }
  }

  [[nodiscard]] operator CURLM*() const noexcept {
    return handle_;
  }

  static std::expected<Multi, std::error_code> create() noexcept {
    auto handle = ::curl_multi_init();
    if (!handle) [[unlikely]] {
      return std::unexpected(makeInternalErrorCode(InternalError::FailedMultiHandle));
    }
    return Multi(handle);
  }
};

} // namespace curl

class Response {
private:
  curl::Easy handle_;
  std::string body_;

public:
  Response(Response const&) = delete;
  Response& operator=(Response const&) = delete;
  Response(Response&&) = default;
  Response& operator=(Response&&) = default;
  Response() = default;

  Response(curl::Easy handle, std::string body) noexcept : handle_(std::move(handle)), body_(std::move(body)) {}

  [[nodiscard]] std::string const& body() const noexcept {
    return body_;
  }

  [[nodiscard]] std::chrono::microseconds totalTime() const {
    return handle_.getInfo<curl_off_t>(CURLINFO_TOTAL_TIME_T)
        .transform([](curl_off_t value) {
          return std::chrono::microseconds(value);
        })
        .value();
  }

  [[nodiscard]] std::string_view effectiveURL() const {
    return handle_.getInfo<std::string_view>(CURLINFO_EFFECTIVE_URL).value();
  }
};

class Request {
private:
  curl::Easy handle_;
  std::string body_;

private:
  explicit Request(curl::Easy handle) noexcept : handle_(std::move(handle)) {
    if (handle_) {
      handle_.setOption(CURLOPT_WRITEDATA, this);
      handle_.setOption(CURLOPT_WRITEFUNCTION, writeFn);
      handle_.setOption(CURLOPT_FOLLOWLOCATION, 1L);
    }
  }

public:
  Request(Request const&) = delete;
  Request& operator=(Request const&) = delete;

  Request() = default;

  Request(Request&& other) noexcept : handle_(std::move(other.handle_)), body_(std::move(other.body_)) {
    if (handle_) {
      handle_.setOption(CURLOPT_WRITEDATA, this);
    }
  }

  Request& operator=(Request&& other) noexcept {
    if (this != &other) {
      this->~Request();
      new (this) Request(std::move(other));
    }
    return *this;
  }

  static std::expected<Request, std::error_code> create() noexcept {
    return curl::Easy::create().transform([](curl::Easy handle) {
      return Request(std::move(handle));
    });
  }

  std::expected<void, std::error_code> setURL(std::string const& value) noexcept {
    return handle_.setOption(CURLOPT_URL, value);
  }

  std::expected<void, std::error_code> setTimeout(std::chrono::milliseconds value) noexcept {
    return handle_.setOption(CURLOPT_TIMEOUT_MS, static_cast<long>(value.count()));
  }

  std::expected<Response, std::error_code> perform() noexcept {
    if (auto const rc = ::curl_easy_perform(handle_); rc != CURLE_OK) {
      return std::unexpected(curl::makeEasyErrorCode(rc));
    }
    return Response{std::move(handle_), std::move(body_)};
  }

  void reset() noexcept {
    handle_.reset();
    body_.clear();
  }

private:
  void writeChunk(std::span<char const> chunk) {
    body_.append(chunk.data(), chunk.size());
  }

  static std::size_t writeFn(char const* data, std::size_t size, std::size_t nmemb, void* userdata) {
    auto const self = static_cast<Request*>(userdata);
    auto const chunk = std::span<char const>(data, size * nmemb);
    self->writeChunk(chunk);
    return chunk.size();
  }
};

} // namespace walng

main.cpp

#include <print>
#include <span>
#include <string>

#include "curl.h"

std::expected<walng::Response, std::error_code> query(std::string const& url) noexcept {
  using namespace walng;

  return Request::create().and_then([&](auto&& request) -> std::expected<Response, std::error_code> {
    if (auto const rc = request.setURL(url); !rc) {
      return std::unexpected(rc.error());
    }
    if (auto const rc = request.setTimeout(std::chrono::seconds(5)); !rc) {
      return std::unexpected(rc.error());
    }
    return request.perform();
  });
}

int curl_test_xxx(std::string const& url) {
  using namespace walng;

  query(url)
      .and_then([&](auto&& response) -> std::expected<void, std::error_code> {
        std::print(stdout, "effective url: \"{}\"\n", response.effectiveURL());
        std::print(
            stdout, "total time: {}\n", std::chrono::duration_cast<std::chrono::milliseconds>(response.totalTime()));
        std::print(stdout, "response:\n---\n{}\n---\n\n", std::string_view(response.body()).substr(0, 50));
        return {};
      })
      .or_else([&](std::error_code ec) -> std::expected<void, std::error_code> {
        std::print(stderr, "failed to query url \"{}\": {}\n", url, ec.message());
        return std::unexpected(ec);
      });

  return EXIT_SUCCESS;
}

int main([[maybe_unused]] int argc, [[maybe_unused]] char* argv[]) {
  for (auto const arg : std::span(argv + 1, argc - 1)) {
    curl_test_xxx(arg);
  }

  // curl_test_xxx("wttr.in/Moscow");
  // curl_test_xxx("https://httpbin.org/ip");
  // curl_test_xxx("127.0.0.5:3333");

  return EXIT_SUCCESS;
}

[ksergey]

https://stackoverflow.com/questions/68629836/how-to-get-file-name-using-libcurl

[pluto699]

curl.h

// Copyright (c) Sergey Kovalevich <inndie@gmail.com>
// SPDX-License-Identifier: AGPL-3.0

#pragma once

#include <expected>
#include <span>
#include <system_error>
#include <utility>

#include <curl/curl.h>

namespace walng::curl {

enum class InternalError { FailedEasyHandle, FailedUrlHandle };

namespace detail {

struct EasyErrorCategory final : std::error_category {
  char const* name() const noexcept override {
    return "curl-easy";
  }
  std::string message(int ec) const override {
    return ::curl_easy_strerror(static_cast<::CURLcode>(ec));
  }
};

inline EasyErrorCategory const& getEasyErrorCategory() noexcept {
  static EasyErrorCategory category;
  return category;
}

inline std::error_code makeEasyErrorCode(::CURLcode ec) {
  return std::error_code(static_cast<int>(ec), getEasyErrorCategory());
}

struct UrlErrorCategory final : std::error_category {
  char const* name() const noexcept override {
    return "curl-url";
  }
  std::string message(int ec) const override {
    return ::curl_url_strerror(static_cast<::CURLUcode>(ec));
  }
};

inline UrlErrorCategory const& getUrlErrorCategory() noexcept {
  static UrlErrorCategory category;
  return category;
}

inline std::error_code makeUrlErrorCode(::CURLUcode ec) {
  return std::error_code(static_cast<int>(ec), getUrlErrorCategory());
}

struct InternalErrorCategory final : std::error_category {
  char const* name() const noexcept override {
    return "internal-error";
  }
  std::string message(int ec) const override {
    switch (static_cast<InternalError>(ec)) {
    case InternalError::FailedEasyHandle:
      return "failed to init easy handle";
    case InternalError::FailedUrlHandle:
      return "failed to init url handle";
    default:
      break;
    }
    return "";
  }
};

inline InternalErrorCategory const& getInternalErrorCategory() noexcept {
  static InternalErrorCategory category;
  return category;
}

inline std::error_code makeInternalErrorCode(InternalError ec) {
  return std::error_code(static_cast<int>(ec), getInternalErrorCategory());
}

} // namespace detail

class EasyHandle {
private:
  CURL* handle_ = nullptr;

public:
  EasyHandle(EasyHandle const&) = delete;
  EasyHandle& operator=(EasyHandle const&) = delete;

  EasyHandle() = default;

  ~EasyHandle() noexcept {
    if (handle_) {
      ::curl_easy_cleanup(handle_);
    }
  }

  EasyHandle(EasyHandle&& other) noexcept : handle_(std::exchange(other.handle_, nullptr)) {}

  EasyHandle& operator=(EasyHandle&& other) noexcept {
    if (this != &other) {
      this->~EasyHandle();
      new (this) EasyHandle(std::move(other));
    }
    return *this;
  }

  explicit EasyHandle(CURL* handle) noexcept : handle_(handle) {}

  static std::expected<EasyHandle, std::system_error> create() noexcept {
    auto handle = ::curl_easy_init();
    if (!handle) [[unlikely]] {
      return std::unexpected(detail::makeInternalErrorCode(InternalError::FailedEasyHandle));
    }
    return EasyHandle(handle);
  }

  [[nodiscard]] operator bool() const noexcept {
    return handle_ != nullptr;
  }

  void reset() noexcept {
    ::curl_easy_reset(handle_);
  }

  template <typename T>
  std::expected<void, std::system_error> option(CURLoption opt, T&& value) noexcept {
    if constexpr (std::is_same_v<std::decay_t<T>, std::string>) {
      return this->optionImpl(opt, value.c_str());
    } else if constexpr (std::is_same_v<std::decay_t<T>, std::string_view>) {
      return this->optionImpl(opt, std::string(value).c_str());
    } else {
      return this->optionImpl(opt, std::forward<T>(value));
    }
  }

  template <typename T>
  std::expected<T, std::system_error> info(CURLINFO info) const noexcept {
    if constexpr (std::is_same_v<T, std::string>) {
      return this->infoImpl<char const*>(info).transform([](char const* value) {
        return std::string(value);
      });
    } else if constexpr (std::is_same_v<T, std::string_view>) {
      return this->infoImpl<char const*>(info).transform([](char const* value) {
        return std::string_view(value);
      });
    } else {
      return this->infoImpl<T>(info);
    }
  }

  std::expected<void, std::system_error> perform() noexcept {
    if (auto const rc = ::curl_easy_perform(handle_); rc != CURLE_OK) [[unlikely]] {
      return std::unexpected(detail::makeEasyErrorCode(rc));
    }
    return {};
  }

private:
  template <typename T>
  inline std::expected<void, std::system_error> optionImpl(CURLoption opt, T&& value) noexcept {
    if (auto const rc = ::curl_easy_setopt(handle_, opt, std::forward<T>(value)); rc != CURLE_OK) [[unlikely]] {
      return std::unexpected(detail::makeEasyErrorCode(rc));
    }
    return {};
  }

  template <typename T>
  inline std::expected<T, std::system_error> infoImpl(CURLINFO info) const noexcept {
    T result;
    if (auto const rc = ::curl_easy_getinfo(handle_, info, &result); rc != CURLE_OK) [[unlikely]] {
      return std::unexpected(detail::makeEasyErrorCode(rc));
    }
    return result;
  }
};

class UrlPart {
private:
  char* value_ = nullptr;

public:
  UrlPart(UrlPart const&) = delete;
  UrlPart& operator=(UrlPart const&) = delete;
  UrlPart() = default;

  UrlPart(UrlPart&& other) noexcept : value_(std::exchange(other.value_, nullptr)) {}

  UrlPart& operator=(UrlPart&& other) noexcept {
    if (this != &other) {
      value_ = std::exchange(other.value_, nullptr);
    }
    return *this;
  }

  explicit UrlPart(char* value) noexcept : value_(value) {}

  ~UrlPart() {
    if (value_) {
      ::curl_free(value_);
    }
  }

  [[nodiscard]] explicit operator bool() const noexcept {
    return value_ != nullptr;
  }

  [[nodiscard]] char const* c_str() const noexcept {
    return value_ ? value_ : "";
  }

  [[nodiscard]] operator std::string_view() const noexcept {
    return c_str();
  }
};

class UrlHandle {
private:
  CURLU* handle_ = nullptr;

public:
  UrlHandle(UrlHandle const&) = delete;
  UrlHandle& operator=(UrlHandle const&) = delete;

  UrlHandle() = default;

  ~UrlHandle() noexcept {
    if (handle_) {
      ::curl_url_cleanup(handle_);
    }
  }

  UrlHandle(UrlHandle&& other) noexcept : handle_(std::exchange(other.handle_, nullptr)) {}

  UrlHandle& operator=(UrlHandle&& other) noexcept {
    if (this != &other) {
      this->~UrlHandle();
      new (this) UrlHandle(std::move(other));
    }
    return *this;
  }

  explicit UrlHandle(CURLU* handle) noexcept : handle_(handle) {}

  static std::expected<UrlHandle, std::system_error> create() noexcept {
    auto handle = ::curl_url();
    if (!handle) [[unlikely]] {
      return std::unexpected(detail::makeInternalErrorCode(InternalError::FailedUrlHandle));
    }
    return UrlHandle(handle);
  }

  [[nodiscard]] operator bool() const noexcept {
    return handle_ != nullptr;
  }

  std::expected<UrlPart, std::system_error> getPart(CURLUPart part) noexcept {
    return getPartImpl(part);
  }

  template <typename T>
  std::expected<void, std::system_error> setPart(CURLUPart part, T&& value) noexcept {
    if constexpr (std::is_same_v<std::decay_t<T>, std::string>) {
      return setPartImpl(part, value.c_str());
    } else if constexpr (std::is_same_v<std::decay_t<T>, std::string_view>) {
      return setPartImpl(part, std::string(value).c_str());
    } else {
      return setPartImpl(part, value);
    }
  }

private:
  inline std::expected<UrlPart, std::system_error> getPartImpl(CURLUPart part) const noexcept {
    char* value = nullptr;
    if (auto const rc = ::curl_url_get(handle_, part, &value, 0); rc != CURLUE_OK) [[unlikely]] {
      return std::unexpected(detail::makeUrlErrorCode(rc));
    }
    return UrlPart(value);
  }

  inline std::expected<void, std::system_error> setPartImpl(CURLUPart part, char const* value) noexcept {
    if (auto const rc = ::curl_url_set(handle_, part, value, 0); rc != CURLUE_OK) [[unlikely]] {
      return std::unexpected(detail::makeUrlErrorCode(rc));
    }
    return {};
  }
};

} // namespace walng::curl

Request.h

// Copyright (c) Sergey Kovalevich <inndie@gmail.com>
// SPDX-License-Identifier: AGPL-3.0

#pragma once

#include <string>

#include "Response.h"
#include "curl.h"

namespace walng {

enum RequestError { InternalError };

namespace detail {

struct RequestErrorCategory final : std::error_category {
  char const* name() const noexcept override {
    return "request-error";
  }
  std::string message(int ec) const override {
    switch (static_cast<RequestError>(ec)) {
    case RequestError::InternalError:
      return "internal error";
    default:
      break;
    }
    return "unknown error";
  }
};

inline RequestErrorCategory const& getRequestErrorCategory() noexcept {
  static RequestErrorCategory category;
  return category;
}

inline std::error_code makeRequestErrorCode(RequestError ec) {
  return std::error_code(static_cast<int>(ec), getRequestErrorCategory());
}

} // namespace detail

class Request {
private:
  curl::EasyHandle handle_;
  std::string body_;

public:
  Request(Request const&) = delete;
  Request& operator=(Request const&) = delete;

  Request() = default;

  Request(Request&& other) noexcept : handle_(std::move(other.handle_)), body_(std::move(other.body_)) {
    if (handle_) {
      handle_.option(CURLOPT_WRITEDATA, this);
    }
  }

  Request& operator=(Request&& other) noexcept {
    if (this != &other) {
      this->~Request();
      new (this) Request(std::move(other));
    }
    return *this;
  }

  std::expected<void, std::system_error> prepare(
      std::string const& url, std::chrono::milliseconds timeout = std::chrono::seconds(5)) noexcept {
    if (!handle_) {
      auto result = curl::EasyHandle::create();
      if (!result) {
        return std::unexpected(std::system_error(result.error().code(), "failed to init CURL easy handle"));
      }
      handle_ = std::move(*result);
    } else {
      handle_.reset();
    }

    handle_.option(CURLOPT_WRITEDATA, this);
    handle_.option(CURLOPT_WRITEFUNCTION, writeFn);
    handle_.option(CURLOPT_FOLLOWLOCATION, 1L);

    if (auto const rc = handle_.option(CURLOPT_URL, url); !rc) {
      return std::unexpected(std::system_error(rc.error().code(), "failed to set URL"));
    }
    if (auto const rc = handle_.option(CURLOPT_TIMEOUT_MS, static_cast<long>(timeout.count())); !rc) {
      return std::unexpected(std::system_error(rc.error().code(), "failed to set timeout"));
    }

    body_.clear();

    return {};
  }

  std::expected<Response, std::system_error> perform() noexcept {
    return handle_.perform()
        .transform([&] {
          return Response(std::move(handle_), std::move(body_));
        })
        .transform_error([&](std::system_error const& e) {
          return std::system_error(e.code(), "failed to execute request");
        });
  }

private:
  void writeChunk(std::span<char const> chunk) {
    body_.append(chunk.data(), chunk.size());
  }

  static std::size_t writeFn(char const* data, std::size_t size, std::size_t nmemb, void* userdata) {
    auto const self = static_cast<Request*>(userdata);
    auto const chunk = std::span<char const>(data, size * nmemb);
    self->writeChunk(chunk);
    return chunk.size();
  }
};

} // namespace walng

Response.h

// Copyright (c) Sergey Kovalevich <inndie@gmail.com>
// SPDX-License-Identifier: AGPL-3.0

#pragma once

#include <chrono>
#include <string>

#include "curl.h"

namespace walng {

class Response {
private:
  curl::EasyHandle handle_;
  std::string body_;

public:
  Response(Response const&) = delete;
  Response& operator=(Response const&) = delete;
  Response(Response&&) = default;
  Response& operator=(Response&&) = default;
  Response() = default;

  Response(curl::EasyHandle handle, std::string body) noexcept : handle_(std::move(handle)), body_(std::move(body)) {}

  [[nodiscard]] std::string const& body() const noexcept {
    return body_;
  }

  [[nodiscard]] std::chrono::microseconds totalTime() const {
    return handle_.info<curl_off_t>(CURLINFO_TOTAL_TIME_T)
        .transform([](curl_off_t value) {
          return std::chrono::microseconds(value);
        })
        .value();
  }

  [[nodiscard]] std::string_view effectiveURL() const {
    return handle_.info<std::string_view>(CURLINFO_EFFECTIVE_URL).value();
  }
};

} // namespace walng

main.cpp

// Copyright (c) Sergey Kovalevich <inndie@gmail.com>
// SPDX-License-Identifier: MIT

#include <algorithm>
#include <cerrno>
#include <expected>
#include <filesystem>
#include <print>

#include "Request.h"

std::expected<std::filesystem::path, std::system_error> extractFileNameFromUrl(std::string const& url) noexcept {
  return ::walng::curl::UrlHandle::create()
      .and_then([&](auto&& handle) {
        return handle.setPart(CURLUPART_URL, url).and_then([&] {
          return handle.getPart(CURLUPART_PATH);
        });
      })
      .transform([](::walng::curl::UrlPart part) {
        return std::filesystem::path(part.c_str()).filename();
      });
}

std::expected<void, std::system_error> writeFile(std::filesystem::path const& path, std::string_view content) noexcept {
  FILE* file = ::fopen(path.c_str(), "w");
  if (!file) {
    return std::unexpected(std::system_error(errno, std::system_category(), "failed to open file for writting"));
  }

  // TODO: check result
  ::fwrite(content.data(), content.size(), 1, file);
  ::fclose(file);

  return {};
}

std::expected<std::filesystem::path, std::system_error> downloadFileOrGetFromCache(std::string const& url) noexcept {
  using namespace walng;

  auto extractResult = extractFileNameFromUrl(url);
  if (!extractResult) {
    return std::unexpected(extractResult.error());
  }
  auto const& filename = *extractResult;
  std::print("filename: {}\n", filename.c_str());

  auto request = Request();
  if (auto const rc = request.prepare(url); !rc) {
    return std::unexpected(std::system_error(rc.error().code(), "failed to prepare download query"));
  }

  auto const performResult = request.perform();
  if (!performResult) {
    return std::unexpected(std::system_error(performResult.error().code(), "failed to execute download query"));
  }

  auto const& response = *performResult;
  if (auto const rc = writeFile(filename, response.body()); !rc) {
    return std::unexpected(std::system_error(rc.error().code(), "failed to write query response content"));
  }

  return filename;
}

int main([[maybe_unused]] int argc, [[maybe_unused]] char* argv[]) {
  try {
    auto const downloadResult = downloadFileOrGetFromCache(
        "https://raw.githubusercontent.com/tinted-theming/schemes/refs/heads/spec-0.11/base16/atelier-dune.yaml");
    if (!downloadResult) {
      std::print(stderr, "error: {}\n", downloadResult.error().what());
    }

  } catch (std::exception const& e) {
    std::print(stderr, "Error: {}\n", e.what());
    return EXIT_FAILURE;
  }

  return EXIT_SUCCESS;
}