/*
 * Copyright (c) Advanced Micro Devices, Inc. All rights reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

#ifndef INCLUDE_ROCM_SMI_ROCM_SMI_MAIN_H_
#define INCLUDE_ROCM_SMI_ROCM_SMI_MAIN_H_

#include <cstdint>
#include <functional>
#include <limits>
#include <map>
#include <memory>
#include <mutex>  // NOLINT
#include <set>
#include <string>
#include <utility>
#include <vector>

#include "rocm_smi/rocm_smi_common.h"
#include "rocm_smi/rocm_smi_device.h"
#include "rocm_smi/rocm_smi_io_link.h"
#include "rocm_smi/rocm_smi_kfd.h"
#include "rocm_smi/rocm_smi_monitor.h"
#include "rocm_smi/rocm_smi_power_mon.h"

namespace amd::smi {

class RocmSMI {
 public:
  explicit RocmSMI(uint64_t flags);
  ~RocmSMI(void);

  static RocmSMI& getInstance(uint64_t flags = 0);
  void Initialize(uint64_t flags);
  void Cleanup(void);

  std::vector<std::shared_ptr<Device>>& devices() { return devices_; }
  std::vector<std::shared_ptr<Device>>& nic_devices() { return nic_devices_; }
  std::vector<std::shared_ptr<Device>>& switch_devices() { return switch_devices_; }

  uint32_t DiscoverAmdgpuDevices(void);
  uint32_t DiscoverBRCMnicDevices(void);
  uint32_t DiscoverBRCMswitchDevices(void);
  int DiscoverAMDPowerMonitors(bool force_update = false);

  // Will execute "func" for every Device object known about, or until func
  // returns non-zero;
  uint32_t IterateSMIDevices(std::function<uint32_t(std::shared_ptr<Device>&, void*)> func, void*);

  void set_init_options(uint64_t options) { init_options_ = options; }
  uint64_t init_options() const { return init_options_; }
  uint64_t is_thread_only_mutex() const { return init_options_ & RSMI_INIT_FLAG_THRAD_ONLY_MUTEX; }

  uint32_t euid() const { return euid_; }

  std::map<uint64_t, std::shared_ptr<KFDNode>>& kfd_node_map(void) { return kfd_node_map_; }

  int kfd_notif_evt_fh(void) const { return kfd_notif_evt_fh_; }
  void set_kfd_notif_evt_fh(int fd) { kfd_notif_evt_fh_ = fd; }
  std::mutex* kfd_notif_evt_fh_mutex(void) { return &kfd_notif_evt_fh_mutex_; }
  std::mutex* bootstrap_mutex(void) { return &bootstrap_mutex_; }

  uint32_t ref_count(void) const { return ref_count_; }
  uint32_t ref_count_inc(void) { return ++ref_count_; }
  uint32_t ref_count_dec(void) { return --ref_count_; }

  uint32_t kfd_notif_evt_fh_refcnt(void) const { return kfd_notif_evt_fh_refcnt_; }
  uint32_t kfd_notif_evt_fh_refcnt_inc(void) { return ++kfd_notif_evt_fh_refcnt_; }
  uint32_t kfd_notif_evt_fh_refcnt_dec(void) { return --kfd_notif_evt_fh_refcnt_; }
  int get_io_link_weight(uint32_t node_from, uint32_t node_to, uint64_t* weight);
  int get_node_index(uint32_t dv_ind, uint32_t* node_ind);
  const RocmSMI_env_vars& getEnv(void);
  std::string getRSMIEnvVarInfo(void);
  void debugRSMIEnvVarInfo();
  bool isLoggingOn(void);
  uint32_t getLogSetting(void);

 private:
  std::vector<std::shared_ptr<Device>> devices_;
  std::vector<std::shared_ptr<Device>> nic_devices_;
  std::vector<std::shared_ptr<Device>> switch_devices_;
  std::map<uint64_t, std::shared_ptr<KFDNode>> kfd_node_map_;
  std::vector<std::shared_ptr<Monitor>> monitors_;
  std::vector<std::shared_ptr<Monitor>> nic_monitors_;
  std::vector<std::shared_ptr<Monitor>> switch_monitors_;
  std::vector<std::shared_ptr<PowerMon>> power_mons_;
  std::set<std::string> amd_monitor_types_;
  std::map<std::pair<uint32_t, uint32_t>, std::shared_ptr<IOLink>> io_link_map_;
  std::map<uint32_t, uint32_t> dev_ind_to_node_ind_map_;
  void AddToDeviceList(const std::string& dev_name, uint64_t bdfid = 0);
  void AddToNICDeviceList(const std::string& dev_name, uint64_t bdfid = 0, uint32_t card_indx = 0);
  void AddToSWITCHDeviceList(const std::string& dev_name, uint64_t bdfid = 0);

  typedef struct rsmi_device_enumeration_t {
    uint32_t card_index = std::numeric_limits<uint32_t>::max();
    std::string dev_name = "";
    std::string drm_render_path = "";
    std::string drm_card_path = "";
    uint32_t drm_render_minor = std::numeric_limits<uint32_t>::max();
    uint64_t bdfid = std::numeric_limits<uint64_t>::max();
  } rsmi_device_enumeration_t;
  rsmi_status_t AddToDeviceList2(rsmi_device_enumeration_t device);
  void GetEnvVariables(void);
  std::shared_ptr<Monitor> FindMonitor(std::string monitor_path);

  RocmSMI_env_vars env_vars_;
  uint64_t init_options_;
  uint32_t euid_;

  int kfd_notif_evt_fh_;
  std::mutex kfd_notif_evt_fh_mutex_;
  uint32_t kfd_notif_evt_fh_refcnt_;  // Access to this should be protected
                                      // by kfd_notif_evt_fh_mutex_
  std::mutex bootstrap_mutex_;
  uint32_t ref_count_;  // Access to this should be protected
                        // by bootstrap_mutex_
};

}  // namespace amd::smi

#endif  // INCLUDE_ROCM_SMI_ROCM_SMI_MAIN_H_
