package metrics

import (
	"context"
	"encoding/json"
	"testing"
	"time"

	"github.com/carlosframework/platform/internal/release"
)

func rollupFloat(v float64) *float64 { return &v }
func rollupInt(v int64) *int64       { return &v }

func TestRollupHourHostCPUNilExcluded(t *testing.T) {
	samples := []Sample{
		{Host: HostSample{CPUFrac: rollupFloat(0.2), MemFrac: rollupFloat(0.5), DiskFrac: rollupFloat(0.1), Load1: rollupFloat(1.0)}},
		{Host: HostSample{CPUFrac: nil, MemFrac: rollupFloat(0.6), DiskFrac: rollupFloat(0.2), Load1: rollupFloat(1.5)}},
		{Host: HostSample{CPUFrac: rollupFloat(0.8), MemFrac: rollupFloat(0.4), DiskFrac: rollupFloat(0.3), Load1: rollupFloat(0.5)}},
	}

	agg := RollupHour(samples)

	cpu, ok := agg.Host["cpu"]
	if !ok {
		t.Fatalf("Host[\"cpu\"] absent, want present with N=2")
	}
	if cpu.N != 2 {
		t.Fatalf("cpu.N = %d, want 2 (nil sample excluded)", cpu.N)
	}
	if cpu.Min != 0.2 || cpu.Max != 0.8 || cpu.Avg != 0.5 {
		t.Fatalf("cpu = %+v, want min=0.2 max=0.8 avg=0.5", cpu)
	}
}

func TestRollupHourUnitPresentInOneSample(t *testing.T) {
	samples := []Sample{
		{Units: map[string]UnitSample{
			"a.service": {CPUFrac: rollupFloat(0.3), MemBytes: rollupInt(1000)},
		}},
		{Units: map[string]UnitSample{}},
	}

	agg := RollupHour(samples)

	unit, ok := agg.Units["a.service"]
	if !ok {
		t.Fatalf("Units[\"a.service\"] absent, want present")
	}
	cpu, ok := unit["cpu"]
	if !ok || cpu.N != 1 {
		t.Fatalf("unit cpu = %+v (ok=%v), want N=1", cpu, ok)
	}
	if cpu.Min != 0.3 || cpu.Max != 0.3 || cpu.Avg != 0.3 {
		t.Fatalf("unit cpu = %+v, want min=avg=max=0.3", cpu)
	}
	mem, ok := unit["mem_bytes"]
	if !ok || mem.N != 1 {
		t.Fatalf("unit mem_bytes = %+v (ok=%v), want N=1", mem, ok)
	}
	if mem.Min != 1000 || mem.Max != 1000 || mem.Avg != 1000 {
		t.Fatalf("unit mem_bytes = %+v, want min=avg=max=1000", mem)
	}
}

func TestRollupHourAllNilMetricAbsent(t *testing.T) {
	samples := []Sample{
		{Host: HostSample{CPUFrac: rollupFloat(0.1)}},
		{Host: HostSample{CPUFrac: rollupFloat(0.2)}},
	}

	agg := RollupHour(samples)

	if _, ok := agg.Host["load1"]; ok {
		t.Fatalf("Host[\"load1\"] present, want absent (never carried in any sample)")
	}
	if _, ok := agg.Host["mem"]; ok {
		t.Fatalf("Host[\"mem\"] present, want absent")
	}
	if _, ok := agg.Host["disk"]; ok {
		t.Fatalf("Host[\"disk\"] present, want absent")
	}
	if len(agg.Units) != 0 {
		t.Fatalf("Units = %+v, want empty (no unit samples at all)", agg.Units)
	}
}

func TestUpsertRollupTwoHoursSameDay(t *testing.T) {
	store := release.NewDirStore(t.TempDir())
	ctx := context.Background()

	hour10 := time.Date(2026, 8, 2, 10, 30, 0, 0, time.UTC)
	hour11 := time.Date(2026, 8, 2, 11, 15, 0, 0, time.UTC)

	agg10 := HourAgg{Host: map[string]Agg{"cpu": {Min: 0.1, Avg: 0.1, Max: 0.1, N: 1}}}
	agg11 := HourAgg{Host: map[string]Agg{"cpu": {Min: 0.2, Avg: 0.2, Max: 0.2, N: 1}}}

	if err := UpsertRollup(ctx, store, "b", hour10, agg10); err != nil {
		t.Fatalf("UpsertRollup hour10: %v", err)
	}
	if err := UpsertRollup(ctx, store, "b", hour11, agg11); err != nil {
		t.Fatalf("UpsertRollup hour11: %v", err)
	}

	keys, err := store.List(ctx, "metrics/boxes/b/days/")
	if err != nil {
		t.Fatalf("List: %v", err)
	}
	if len(keys) != 1 {
		t.Fatalf("got %d day keys, want exactly one: %v", len(keys), keys)
	}

	body, _, err := store.Get(ctx, DayKey("b", "2026-08-02"))
	if err != nil {
		t.Fatalf("Get: %v", err)
	}
	var got DayRollup
	if err := json.Unmarshal(body, &got); err != nil {
		t.Fatalf("Unmarshal: %v", err)
	}
	if got.V != 1 || got.Box != "b" || got.Date != "2026-08-02" {
		t.Fatalf("got %+v, want V=1 Box=b Date=2026-08-02", got)
	}
	if len(got.Hours) != 2 {
		t.Fatalf("got %d hours, want 2 (10 and 11): %+v", len(got.Hours), got.Hours)
	}
	if got.Hours["10"].Host["cpu"].N != 1 || got.Hours["10"].Host["cpu"].Avg != 0.1 {
		t.Fatalf("Hours[10] = %+v, want cpu avg 0.1", got.Hours["10"])
	}
	if got.Hours["11"].Host["cpu"].N != 1 || got.Hours["11"].Host["cpu"].Avg != 0.2 {
		t.Fatalf("Hours[11] = %+v, want cpu avg 0.2", got.Hours["11"])
	}
}