#pragma once

#include <chrono>
#include <functional>
#include <map>
#include <string>
#include <string_view>

namespace kcenon::common::interfaces {

/// Metric label set for dimensional data
using metric_labels = std::map<std::string, std::string>;

/// Interface for collecting metrics across modules
class IMetricCollector {
public:
    virtual ~IMetricCollector() = default;

    /// Increment a counter metric
    virtual auto increment(std::string_view name, 
                          double value = 1.0,
                          const metric_labels& labels = {}) -> void = 0;

    /// Set a gauge metric to absolute value
    virtual auto gauge(std::string_view name, 
                      double value,
                      const metric_labels& labels = {}) -> void = 0;

    /// Record a histogram observation
    virtual auto histogram(std::string_view name, 
                          double value,
                          const metric_labels& labels = {}) -> void = 0;

    /// Record a timing measurement
    virtual auto timing(std::string_view name,
                       std::chrono::nanoseconds duration,
                       const metric_labels& labels = {}) -> void = 0;
};

/// RAII timer for automatic timing measurements
class scoped_timer {
public:
    scoped_timer(IMetricCollector& collector, 
                 std::string_view name,
                 metric_labels labels = {})
        : collector_(collector)
        , name_(name)
        , labels_(std::move(labels))
        , start_(std::chrono::steady_clock::now()) {}

    ~scoped_timer() {
        auto elapsed = std::chrono::steady_clock::now() - start_;
        collector_.timing(name_, 
            std::chrono::duration_cast<std::chrono::nanoseconds>(elapsed),
            labels_);
    }

private:
    IMetricCollector& collector_;
    std::string name_;
    metric_labels labels_;
    std::chrono::steady_clock::time_point start_;
};

/// Null implementation for when metrics are disabled
class null_metric_collector : public IMetricCollector {
public:
    void increment(std::string_view, double, const metric_labels&) override {}
    void gauge(std::string_view, double, const metric_labels&) override {}
    void histogram(std::string_view, double, const metric_labels&) override {}
    void timing(std::string_view, std::chrono::nanoseconds, const metric_labels&) override {}
};

} // namespace kcenon::common::interfaces