download_file

#include "blazeauth/api/api.hpp"

#include <fstream>
#include <iostream>
#include <string>
#include <system_error>
#include <vector>

void print_error_code(const std::string& context, const std::error_code& ec) {
  std::cout << context << ": " << ec.message() << " ("
            << ec.value() << " : " << ec.category().name() << ")\n";
}

bool write_file(const std::string& path, const std::vector<std::byte>& bytes) {
  std::ofstream out(path, std::ios::binary);
  if (!out) {
    return false;
  }

  if (!bytes.empty()) {
    out.write(reinterpret_cast<const char*>(bytes.data()), static_cast<std::streamsize>(bytes.size()));
  }

  return static_cast<bool>(out);
}

int main() {
  blaze::session session;

  try {
    const blaze::api_server server = session.connect();
    std::cout << "Connected: " << server.location << '\n';

    const blaze::application app = session.initialize("your-websocket-api-key", "your-client-id");
    if (!app.good()) {
      std::cout << "Initialize status: " << blaze::to_string(app.status) << '\n';
      return 1;
    }

    const blaze::license auth = session.authorize("your-license");
    if (!auth.good()) {
      std::cout << "Authorize status: " << blaze::to_string(auth.status) << '\n';
      return 1;
    }

    const blaze::file file = session.download_file("client.dll");
    if (!file.good()) {
      std::cout << "Download status: " << blaze::to_string(file.status) << '\n';
      return 1;
    }

    if (!write_file("client.dll", file.content)) {
      std::cout << "Failed to write output file\n";
      return 1;
    }

    std::cout << "Downloaded bytes: " << file.content.size() << '\n';
    if (!file.server_checksum.empty()) {
      std::cout << "Server checksum: " << file.server_checksum << '\n';
    }

    session.shutdown();
  } catch (const std::system_error& e) {
    print_error_code("download_file failed", e.code());
    return 1;
  }

  return 0;
}