#ifndef THIRD_PARTY_MILOTIC_EXTERNAL_CC_TLBMC_STORE_STORE_IMPL_H_
#define THIRD_PARTY_MILOTIC_EXTERNAL_CC_TLBMC_STORE_STORE_IMPL_H_

#include <memory>
#include <optional>
#include <string>
#include <utility>
#include <vector>

#include "absl/container/flat_hash_map.h"
#include "absl/log/log.h"
#include "absl/status/statusor.h"
#include "absl/strings/string_view.h"
#include "absl/time/time.h"
#include "nlohmann/json.hpp"
#include "tlbmc/collector/collector.h"
#include "tlbmc/collector/fru_collector.h"
#include "tlbmc/collector/gpio_collector.h"
#include "tlbmc/collector/metric_collector.h"
#include "tlbmc/collector/sensor_collector.h"
#include "ad_hoc_fru_config.pb.h"
#include "tlbmc/configs/entity_config.h"
#include "tlbmc/configs/proto_config_parser.h"
#include "topology_config.pb.h"
#include "tlbmc/hal/fru_scanner.h"
#include "tlbmc/hal/peci/peci_access_impl.h"
#include "tlbmc/hal/peci/peci_access_interface.h"
#include "tlbmc/hal/sysfs/i2c.h"
#include "tlbmc/hal/sysfs/i3c.h"
#include "tlbmc/hal/sysfs/peci.h"
#include "fru.pb.h"
#include "sensor.pb.h"
#include "software_metrics.pb.h"
#include "tlbmc/scheduler/scheduler.h"
#include "tlbmc/sensors/sensor.h"
#include "tlbmc/store/factory.h"
#include "tlbmc/store/store.h"
#include "tlbmc/utils/command_executor.h"
#include "router_interface.h"

namespace milotic_tlbmc {

// Houses all the collectors.
// Extend this struct to add support for new collectors.
struct AllCollectors {
  std::unique_ptr<SensorCollector> sensor_collector = nullptr;
  std::unique_ptr<FruCollector> fru_collector = nullptr;
  std::unique_ptr<MetricCollector> metric_collector = nullptr;
  std::unique_ptr<GpioCollector> gpio_collector = nullptr;
};

// Implementation of the Store interface.
// The store creates and owns all the telemetry collectors and is responsible
// for facilitating access to the data collected by the collectors.
//
// This class is thread-safe.
class StoreImpl : public Store {
 public:
  struct Options {
    absl::flat_hash_map<AdHocScannerType, std::unique_ptr<FruScanner>>
        fru_scanners;
    std::unique_ptr<I2cSysfs> i2c_sysfs = nullptr;
    std::unique_ptr<I3cSysfs> i3c_sysfs = nullptr;
    std::unique_ptr<PeciSysfs> peci_sysfs = nullptr;
    std::unique_ptr<PeciAccessInterface> peci_access =
        std::make_unique<PeciAccessImpl>();
    std::string config_location = "/etc/tlbmc";
    std::unique_ptr<EntityConfigReader> entity_config_reader =
        std::make_unique<EntityConfigReaderImpl>();
    std::unique_ptr<CollectorFactory> collector_factory =
        std::make_unique<CollectorFactoryImpl>();
    std::optional<int> override_sensor_sampling_interval_ms = std::nullopt;
    std::optional<int> override_store_snapshot_interval_ms = std::nullopt;
    std::unique_ptr<ProtoConfigParser> proto_parser = nullptr;
    absl::flat_hash_map<std::string, absl::StatusOr<std::string>>
        executor_command_map;


    // TODO(rahulkpr): Add options for the store as needed.
  };

  static absl::StatusOr<std::unique_ptr<StoreImpl>> Create(Options&& options);

  ~StoreImpl() override;

  // StoreImpl is neither copyable nor movable.
  StoreImpl(const StoreImpl&) = delete;
  StoreImpl& operator=(const StoreImpl&) = delete;
  StoreImpl(StoreImpl&&) = delete;
  StoreImpl& operator=(StoreImpl&&) = delete;

  absl::Status ConfigureCollection(const Collector::Config& config,
                                   Collector::Type type) const override;

  SoftwareMetricsValue GetMetricValues() const override;

  SocketStatStates GetMetricSocketStatValues() const override;

  NetFilterStates GetMetricNetFilterValues() const override;

  // Starts the sensor collector's collection.
  void StartSensorCollection();

  // Returns the list of sensor names contained by the given config key.
  std::vector<std::string> GetAllSensorKeysByConfigKey(
      const std::string& board_config_key) const override;
  // Returns all the sensors.
  std::vector<std::shared_ptr<const Sensor>> GetAllSensors() const override;
  // Returns the sensor for the given sensor key.
  std::shared_ptr<const Sensor> GetSensorBySensorKey(
      const std::string& sensor_key) const override;
  // Returns the sensor for the given board config key and given sensor
  // key.
  std::shared_ptr<const Sensor> GetSensorByConfigKeyAndSensorKey(
      const std::string& board_config_key,
      const std::string& sensor_key) const override;

  absl::Status WriteToSensor(const std::string& sensor_key,
                             const SensorValue& value) override;

  // Returns the sensor devpath for the given sensor key.
  absl::StatusOr<const std::string&> GetDevpathFromSensor(
      std::shared_ptr<const Sensor> sensor) const override;

  absl::StatusOr<const Fru*> GetFru(absl::string_view key) const override;

  absl::StatusOr<const TopologyConfigNode*> GetFruTopology(
      absl::string_view config_key) const override;

  absl::StatusOr<const TopologyConfig*> GetTopologyConfig() const override;

  absl::StatusOr<std::vector<std::string>> GetAllConfigKeys() const override;

  absl::StatusOr<std::string> GetConfigKeyByFruKey(
      absl::string_view fru_key) const override;

  absl::StatusOr<std::string> GetFruKeyByConfigKey(
      absl::string_view config_key) const override;

  absl::StatusOr<std::vector<std::pair<std::string, std::string>>>
  GetFanInfoByConfigKey(absl::string_view config_name) const override;

  absl::StatusOr<const FruTable*> GetAllFrus() const override;

  bool IsConfigKeyOwningAllSensors(absl::string_view config_key) const override;

  nlohmann::json ToJson() const override;

  std::string ToString() const override { return ToJson().dump(); }

  void SetSmartRouter(::crow::RouterInterface* smart_router) override;

  nlohmann::json GetSchedulerStats() const override;

  Metrics GetMetrics() const override;

  const Options& GetOptions() const { return options_; }

 private:
  explicit StoreImpl(Options&& options, AllCollectors all_collectors,
                     std::shared_ptr<EntityConfig> entity_config,
                     absl::Duration store_snapshot_interval,
                     Metrics metrics_at_bootup);

  Options options_;
  // StoreImpl owns all telemetry collectors.
  // Collectors are thread-safe.
  AllCollectors all_collectors_;
  std::shared_ptr<EntityConfig> entity_config_;

  // Scheduler for store level tasks.
  // Note: Each collector has its own scheduler.
  std::unique_ptr<TaskScheduler> task_scheduler_;

  // Metrics for the store.
  // Note: Const for now, will consider making it mutable if we need to update
  // metrics during runtime.
  const Metrics metrics_;
};

}  // namespace milotic_tlbmc

#endif  // THIRD_PARTY_MILOTIC_EXTERNAL_CC_TLBMC_STORE_STORE_IMPL_H_