package main

import (
    "github.com/upfluence/stats"
    "github.com/upfluence/stats/prometheus"
)

func main() {
    // Create a Prometheus collector
    collector := prometheus.NewCollector()

    // Create a root scope
    scope := stats.RootScope(collector)

    // Create and use metrics
    counter := scope.Counter("requests_total")
    counter.Inc()

    gauge := scope.Gauge("active_connections")
    gauge.Update(42)

    histogram := scope.Histogram("request_duration_seconds")
    histogram.Record(0.123)
}

// Simple counter
counter := scope.Counter("http_requests_total")
counter.Inc()
counter.Add(5)

// Counter with labels
counterVec := scope.CounterVector("http_requests_total", []string{"method", "status"})
counterVec.WithLabels("GET", "200").Inc()
counterVec.WithLabels("POST", "201").Add(10)

// Simple gauge
gauge := scope.Gauge("memory_usage_bytes")
gauge.Update(1024000)

// Gauge with labels
gaugeVec := scope.GaugeVector("cpu_usage_percent", []string{"core"})
gaugeVec.WithLabels("0").Update(75)
gaugeVec.WithLabels("1").Update(82)

// Default histogram (uses standard buckets)
histogram := scope.Histogram("response_time_seconds")
histogram.Record(0.234)

// Custom buckets
histogram := scope.Histogram("response_time_seconds",
    stats.StaticBuckets([]float64{0.01, 0.05, 0.1, 0.5, 1.0}))
histogram.Record(0.123)

// Histogram with labels
histVec := scope.HistogramVector("request_duration_seconds",
    []string{"endpoint", "method"})
histVec.WithLabels("/api/users", "GET").Record(0.045)

timer := stats.NewTimer(scope, "operation_duration")
stopwatch := timer.Start()
// ... perform operation ...
stopwatch.Stop() // Records duration in seconds

// Timer with custom suffix and buckets
timer := stats.NewTimer(scope, "db_query",
    stats.WithTimerSuffix("_ms"),
    stats.WithHistogramOptions(
        stats.StaticBuckets([]float64{1, 5, 10, 50, 100})))

// Basic instrument
instrument := stats.NewInstrument(scope, "api_request")

err := instrument.Exec(func() error {
    // Your operation here
    return processRequest()
})
// Automatically records:
// - api_request_started_total (counter)
// - api_request_total{status="success"} or {status="failed"} (counter)
// - api_request_duration_seconds (histogram)

// Instrument with labels
instrumentVec := stats.NewInstrumentVector(
    scope,
    "database_query",
    []string{"table", "operation"},
)

err := instrumentVec.WithLabels("users", "select").Exec(func() error {
    return db.Query("SELECT * FROM users")
})

// Custom options
instrument := stats.NewInstrument(scope, "task",
    // Disable the started counter
    stats.DisableStartedCounter(),

    // Custom status label name (default: "status")
    stats.WithCounterLabel("result"),

    // Custom error formatter
    stats.WithFormatter(func(err error) string {
        if err == nil {
            return "ok"
        }
        return "error"
    }),

    // Custom timer options
    stats.WithTimerOptions(
        stats.WithTimerSuffix("_duration_ms"),
        stats.WithHistogramOptions(
            stats.StaticBuckets([]float64{10, 50, 100, 500, 1000}),
        ),
    ),
)

// Advanced error formatter using error types
formatter := func(err error) string {
    if err == nil {
        return "success"
    }

    switch {
    case errors.Is(err, context.DeadlineExceeded):
        return "timeout"
    case errors.Is(err, context.Canceled):
        return "canceled"
    case isValidationError(err):
        return "validation_error"
    default:
        return "internal_error"
    }
}

instrument := stats.NewInstrument(
    scope,
    "operation",
    stats.WithFormatter(formatter),
)

// Create a child scope with namespace and tags
dbScope := scope.Scope("database", map[string]string{
    "service": "user-api",
    "env": "production",
})

// Metrics created from this scope inherit the namespace and tags
counter := dbScope.Counter("queries")
// Results in metric name: database_queries
// with tags: service=user-api, env=production

// Nested scopes
redisScope := dbScope.Scope("redis", map[string]string{
    "cluster": "cache-01",
})
// Metrics will have namespace: database_redis
// and tags: service=user-api, env=production, cluster=cache-01

import (
    "github.com/upfluence/stats/prometheus"
    "github.com/prometheus/client_golang/prometheus/promhttp"
    "net/http"
)

collector := prometheus.NewCollector()
scope := stats.RootScope(collector)

// Expose metrics endpoint
http.Handle("/metrics", promhttp.Handler())
http.ListenAndServe(":8080", nil)

import (
    "github.com/upfluence/stats/prometheus"
    "github.com/upfluence/log"
    "time"
)

exporter := prometheus.NewExporter(
    log.Default,
    "http://pushgateway:9091",
    "my-application",
    prometheus.WithInterval(10 * time.Second),
    prometheus.WithGrouping("instance", "server-01"),
)
defer exporter.Close()

import "github.com/upfluence/stats/expvar"

collector := expvar.NewCollector()
scope := stats.RootScope(collector)

// Metrics are automatically available at /debug/vars

import "github.com/upfluence/stats/multi"

promCollector := prometheus.NewCollector()
expvarCollector := expvar.NewCollector()

collector := multi.WrapCollectors(promCollector, expvarCollector)
scope := stats.RootScope(collector)

// Metrics are sent to both collectors

var scope stats.Scope

if metricsEnabled {
    scope = stats.RootScope(collector)
} else {
    scope = stats.NoopScope
}

// Code works the same, but NoopScope doesn't collect anything
scope.Counter("requests").Inc()

scope := stats.NewMultiIncarnationScope(
    collector,
    "app_version",
    "1.2.3",
)

// Metrics include the incarnation label automatically
counter := scope.Counter("requests")