ECAP_Server/module/Local_Server/External_Database/global.h

#pragma once
#include "Core/Base/JSON.h"
#include <SQLiteCpp/Database.h>
#include <concurrencpp/concurrencpp.h>
#include <cstddef>
#include <cstdint>
#include <ctime>
#include <exception>
#include <filesystem>
#include <functional>
#include <map>
#include <memory>
#include <mutex>
#include <optional>
#include <string>
#include <vector>

class Global;

struct External_Database_Row {
  std::map<std::string, std::optional<std::string>> columns;
  External_Database_Row() = default;
  External_Database_Row(const External_Database_Row &) = default;
  External_Database_Row &operator=(const External_Database_Row &) = default;
  External_Database_Row(External_Database_Row &&) noexcept = default;
  External_Database_Row &operator=(External_Database_Row &&) noexcept = default;

  [[nodiscard]] std::optional<std::string> get(const std::string &column) const;
  [[nodiscard]] Psc::JSON to_json() const;
};

using External_Database_Row_Map =
    std::map<std::string, std::shared_ptr<External_Database_Row>>;
struct External_Resource_Status {
  std::string name;
  std::size_t row_count{};
  bool downloaded{};
  bool imported{};
  std::string message;
};

class External_Resources {
public:
  External_Resources(std::string name, std::string cache_file_name,
                     std::string download_url, std::string description,
                     std::uint64_t update_interval_seconds);
  virtual ~External_Resources() = default;

  [[nodiscard]] std::size_t row_count(SQLite::Database &db) const;

  virtual void create_table(SQLite::Database &db) const = 0;
  External_Resource_Status update(SQLite::Database &db,
                                  const std::filesystem::path &cache_pos,
                                  bool force_download, bool only_when_empty);
  External_Resource_Status
  import_offline(SQLite::Database &db,
                 const std::filesystem::path &source_file);
  External_Resource_Status clear_table(SQLite::Database &db,
                                       const std::filesystem::path &cache_pos);
  [[nodiscard]] std::optional<External_Database_Row>
  query_one(SQLite::Database &db,
            const std::vector<std::string> &primary_key_values) const;
  void init(const Psc::JSON *that_json) {
    Get_J(name) Get_J(download_url) Get_J(description)
        Get_J(update_interval_seconds) Get_J(last_updated_at)
  }
  [[nodiscard]] Psc::JSON to_json() const {
    Psc::JSON ret = Psc::JSON::object();
    Ret_J(name) Ret_J(download_url) Ret_J(description)
        Ret_J(update_interval_seconds) Ret_J(last_updated_at) return ret;
  }
  std::string name;
  std::string cache_file_name;
  std::string download_url;
  std::string description;
  std::uint64_t update_interval_seconds{};
  std::time_t last_updated_at{};

protected:
  [[nodiscard]] virtual std::filesystem::path
  source_file(const std::filesystem::path &cache_pos) const;
  virtual bool fetch(const std::filesystem::path &cache_pos,
                     bool force_download) const;
  virtual std::size_t
  import_file(SQLite::Database &db,
              const std::filesystem::path &source_file) const = 0;
  [[nodiscard]] virtual const std::vector<std::string> &
  primary_key_columns() const = 0;
  void mark_updated();
  void clear_last_updated_at();
};

class External_Resources_Manager {
public:
  using Status_Callback =
      std::function<void(std::exception_ptr, External_Resource_Status)>;
  using Status_List_Callback = std::function<void(
      std::exception_ptr, std::vector<External_Resource_Status>)>;
  using Row_Callback = std::function<void(
      std::exception_ptr, std::optional<External_Database_Row>)>;
  using Row_Map_Callback =
      std::function<void(std::exception_ptr, External_Database_Row_Map)>;

  External_Resources_Manager();

  void init(const Psc::JSON *that_json);
  [[nodiscard]] Psc::JSON to_json() const;
  void server(Global *g);
  void load_sqlite_db(std::string path);
  std::vector<External_Resource_Status>
  refresh_external_databases(bool force_download = true);
  External_Resource_Status
  refresh_external_database(const std::string &resource_name,
                            bool force_download = true);
  External_Resource_Status
  import_external_database(const std::string &resource_name,
                           const std::filesystem::path &source_file);
  External_Resource_Status
  clear_external_database_table(const std::string &resource_name);
  [[nodiscard]] std::optional<External_Database_Row> query_external_database(
      const std::string &resource_name,
      const std::vector<std::string> &primary_key_values) const;
  [[nodiscard]] std::map<std::string, std::shared_ptr<External_Database_Row>>
  query_aircraft_external_databases(const std::string &icao24) const;
  [[nodiscard]] std::map<std::string, std::shared_ptr<External_Database_Row>>
  query_callsign_external_databases(
      const std::optional<std::string> &callsign) const;
  [[nodiscard]] std::vector<External_Resource_Status>
  external_database_status() const;

  void async_refresh_external_databases(bool force_download,
                                        Status_List_Callback callback);
  void async_refresh_external_database(std::string resource_name,
                                       bool force_download,
                                       Status_Callback callback);
  void async_import_external_database(std::string resource_name,
                                      std::filesystem::path source_file,
                                      Status_Callback callback);
  void async_clear_external_database_table(std::string resource_name,
                                           Status_Callback callback);
  void
  async_query_external_database(std::string resource_name,
                                std::vector<std::string> primary_key_values,
                                Row_Callback callback) const;
  void async_query_aircraft_external_databases(std::string icao24,
                                               Row_Map_Callback callback) const;
  void
  async_query_callsign_external_databases(std::optional<std::string> callsign,
                                          Row_Map_Callback callback) const;
  void async_external_database_status(Status_List_Callback callback) const;

  [[nodiscard]] concurrencpp::result<std::vector<External_Resource_Status>>
  refresh_external_databases_coro(bool force_download = true);
  [[nodiscard]] concurrencpp::result<External_Resource_Status>
  refresh_external_database_coro(std::string resource_name,
                                 bool force_download = true);
  [[nodiscard]] concurrencpp::result<External_Resource_Status>
  import_external_database_coro(std::string resource_name,
                                std::filesystem::path source_file);
  [[nodiscard]] concurrencpp::result<External_Resource_Status>
  clear_external_database_table_coro(std::string resource_name);
  [[nodiscard]] concurrencpp::result<std::optional<External_Database_Row>>
  query_external_database_coro(
      std::string resource_name,
      std::vector<std::string> primary_key_values) const;
  [[nodiscard]] concurrencpp::result<std::shared_ptr<External_Database_Row_Map>>
  query_aircraft_external_databases_coro(std::string icao24) const;
  [[nodiscard]] concurrencpp::result<std::shared_ptr<External_Database_Row_Map>>
  query_callsign_external_databases_coro(
      std::optional<std::string> callsign) const;
  [[nodiscard]] concurrencpp::result<std::vector<External_Resource_Status>>
  external_database_status_coro() const;

  void
  register_external_resource(std::unique_ptr<External_Resources> external_res);
  void initialize(SQLite::Database &db, std::filesystem::path cache_pos);
  std::vector<External_Resource_Status> sync_missing(SQLite::Database &db);
  std::vector<External_Resource_Status> refresh_all(SQLite::Database &db,
                                                    bool force_download = true);
  External_Resource_Status refresh_one(SQLite::Database &db,
                                       const std::string &resource_name,
                                       bool force_download = true);
  External_Resource_Status
  import_offline(SQLite::Database &db, const std::string &resource_name,
                 const std::filesystem::path &source_file);
  External_Resource_Status clear_table(SQLite::Database &db,
                                       const std::string &resource_name);
  [[nodiscard]] std::optional<External_Database_Row>
  query_one(SQLite::Database &db, const std::string &resource_name,
            const std::vector<std::string> &primary_key_values) const;
  [[nodiscard]] std::map<std::string, std::shared_ptr<External_Database_Row>>
  query_aircraft(SQLite::Database &db, const std::string &icao24) const;
  [[nodiscard]] std::map<std::string, std::shared_ptr<External_Database_Row>>
  query_callsign(SQLite::Database &db,
                 const std::optional<std::string> &callsign) const;
  [[nodiscard]] std::vector<External_Resource_Status>
  status(SQLite::Database &db) const;
  std::string ecap_sqlite_path;

  std::filesystem::path cache_pos_;

private:
  [[nodiscard]] SQLite::Database &require_db() const;
  External_Resources &get_resource(const std::string &resource_name) const;
  std::vector<External_Resource_Status>
  update_all(SQLite::Database &db, bool force_download, bool only_when_empty);
  std::unique_ptr<SQLite::Database> db_;
  std::vector<std::unique_ptr<External_Resources>> resources_;
  mutable std::mutex mtx_;
};