#pragma once

#include <filesystem>
#include <optional>
#include <string>
#include <vector>
#include <winsock2.h>
#include <windows.h>

namespace playnite_launcher::lossless {

  struct lossless_scaling_options {
    bool enabled = false;
    std::optional<double> target_fps;
    std::optional<int> rtss_limit;
    std::optional<std::filesystem::path> configured_path;
    std::optional<std::string> active_profile;
    std::optional<std::string> capture_api;
    std::optional<int> queue_target;
    std::optional<bool> hdr_enabled;
    std::optional<int> flow_scale;
    std::optional<bool> performance_mode;
    std::optional<double> resolution_scale_factor;
    std::optional<std::string> frame_generation_mode;
    std::optional<std::string> lsfg3_mode;
    std::optional<std::string> scaling_type;
    std::optional<int> sharpness;
    std::optional<int> ls1_sharpness;
    std::optional<std::string> anime4k_type;
    std::optional<bool> anime4k_vrs;
    int launch_delay_seconds = 0;
    bool legacy_auto_detect = false;
  };

  struct lossless_scaling_profile_backup {
    bool valid = false;
    bool had_auto_scale = false;
    std::string auto_scale;
    bool had_auto_scale_delay = false;
    int auto_scale_delay = 0;
    bool had_lsfg_target = false;
    int lsfg_target = 0;
    bool had_capture_api = false;
    std::string capture_api;
    bool had_queue_target = false;
    int queue_target = 0;
    bool had_hdr_support = false;
    bool hdr_support = false;
    bool had_flow_scale = false;
    int flow_scale = 0;
    bool had_lsfg_size = false;
    std::string lsfg_size;
    bool had_lsfg3_mode = false;
    std::string lsfg3_mode;
    bool had_frame_generation = false;
    std::string frame_generation;
    bool had_scaling_type = false;
    std::string scaling_type;
    bool had_ls1_type = false;
    std::string ls1_type;
    bool had_scaling_mode = false;
    std::string scaling_mode;
    bool had_resize_before_scaling = false;
    bool resize_before_scaling = false;
    bool had_scaling_fit_mode = false;
    std::string scaling_fit_mode;
    bool had_scale_factor = false;
    double scale_factor = 1.0;
    bool had_sharpness = false;
    int sharpness = 0;
    bool had_ls1_sharpness = false;
    int ls1_sharpness = 0;
    bool had_anime4k_type = false;
    std::string anime4k_type;
    bool had_vrs = false;
    bool vrs = false;
    bool had_sync_mode = false;
    std::string sync_mode;
    bool had_max_frame_latency = false;
    int max_frame_latency = 0;
  };

  struct lossless_scaling_runtime_state {
    std::vector<DWORD> running_pids;
    std::optional<std::wstring> exe_path;
    bool previously_running = false;
    bool stopped = false;
  };

  struct lossless_scaling_app_metadata {
    bool enabled = false;
    std::optional<double> target_fps;
    std::optional<int> rtss_limit;
    std::optional<std::filesystem::path> configured_path;
    std::optional<std::string> active_profile;
    std::optional<std::string> capture_api;
    std::optional<int> queue_target;
    std::optional<bool> hdr_enabled;
    std::optional<int> flow_scale;
    std::optional<bool> performance_mode;
    std::optional<double> resolution_scale_factor;
    std::optional<std::string> frame_generation_mode;
    std::optional<std::string> lsfg3_mode;
    std::optional<std::string> scaling_type;
    std::optional<int> sharpness;
    std::optional<int> ls1_sharpness;
    std::optional<std::string> anime4k_type;
    std::optional<bool> anime4k_vrs;
    int launch_delay_seconds = 0;
    bool legacy_auto_detect = false;
  };

  class lossless_scaling_options_loader {
  public:
    virtual ~lossless_scaling_options_loader() = default;
    virtual lossless_scaling_options load() const = 0;
  };

  class lossless_scaling_env_loader: public lossless_scaling_options_loader {
  public:
    lossless_scaling_options load() const override;
  };

  class lossless_scaling_metadata_loader: public lossless_scaling_options_loader {
  public:
    explicit lossless_scaling_metadata_loader(lossless_scaling_app_metadata metadata);
    lossless_scaling_options load() const override;

  private:
    lossless_scaling_app_metadata _metadata;
  };

  lossless_scaling_options read_lossless_scaling_options();
  lossless_scaling_options read_lossless_scaling_options(const lossless_scaling_app_metadata &metadata);
  std::optional<DWORD> lossless_scaling_select_focus_pid(const std::string &install_dir_utf8, const std::string &exe_path_utf8, std::optional<DWORD> preferred_pid);
  lossless_scaling_runtime_state capture_lossless_scaling_state();
  void lossless_scaling_stop_processes(lossless_scaling_runtime_state &state);
  bool lossless_scaling_apply_global_profile(const lossless_scaling_options &options, const std::string &install_dir_utf8, const std::string &exe_path_utf8, lossless_scaling_profile_backup &backup);
  bool lossless_scaling_restore_global_profile(const lossless_scaling_profile_backup &backup);
  void lossless_scaling_restart_foreground(const lossless_scaling_runtime_state &state, bool force_launch, const std::string &install_dir_utf8 = std::string(), const std::string &exe_path_utf8 = std::string(), DWORD focused_game_pid = 0, bool legacy_auto_detect = false);
}  // namespace playnite_launcher::lossless