package store

import (
	"context"
	"testing"
	"time"
)

func newTestDevice(t *testing.T) (*Store, *Device) {
	t.Helper()
	st := testStore(t)
	dev, err := st.CreateDevice(t.Context(), "Harry's phone", "Harry", PlatformAndroid, "sam")
	if err != nil {
		t.Fatalf("CreateDevice: %v", err)
	}
	return st, dev
}

func TestSetPresenceAuditsOnlyTransitions(t *testing.T) {
	st, dev := newTestDevice(t)
	ctx := context.Background()

	// The first "online" flips the flag, so it is audited.
	changed, err := st.SetPresence(ctx, dev.ID, true, time.Now(), "device")
	if err != nil {
		t.Fatalf("SetPresence: %v", err)
	}
	if !changed {
		t.Error("changed = false on the first online report, want true")
	}

	// A repeat report only refreshes last_seen.
	changed, err = st.SetPresence(ctx, dev.ID, true, time.Now().Add(time.Minute), "device")
	if err != nil {
		t.Fatalf("SetPresence: %v", err)
	}
	if changed {
		t.Error("changed = true on a repeat report, want false")
	}

	// The will payload flips it back.
	changed, err = st.SetPresence(ctx, dev.ID, false, time.Now(), "device")
	if err != nil {
		t.Fatalf("SetPresence: %v", err)
	}
	if !changed {
		t.Error("changed = false when the device went offline, want true")
	}

	got, err := st.GetDevice(ctx, dev.ID)
	if err != nil {
		t.Fatalf("GetDevice: %v", err)
	}
	if got.Online {
		t.Error("Online = true after the will, want false")
	}
	if got.LastSeen == nil {
		t.Fatal("LastSeen is nil, want the report time")
	}

	audit, err := st.ListAudit(ctx, 50)
	if err != nil {
		t.Fatalf("ListAudit: %v", err)
	}
	var online, offline int
	for _, e := range audit {
		switch e.Action {
		case "device.online":
			online++
		case "device.offline":
			offline++
		}
	}
	if online != 1 || offline != 1 {
		t.Errorf("audit has %d online and %d offline entries, want 1 and 1", online, offline)
	}
}

func TestInsertTelemetryReplacesTheDailyTotal(t *testing.T) {
	st, dev := newTestDevice(t)
	ctx := context.Background()
	const day = "2026-10-13"

	n, err := st.InsertTelemetry(ctx, dev.ID, day, []TelemetryEntry{
		{App: "com.spotify.music", Seconds: 600},
		{Domain: "youtube.com", Seconds: 120},
	})
	if err != nil {
		t.Fatalf("InsertTelemetry: %v", err)
	}
	if n != 2 {
		t.Errorf("rows = %d, want 2", n)
	}

	// Devices report rolling totals, so a repeat report replaces the row.
	if _, err := st.InsertTelemetry(ctx, dev.ID, day, []TelemetryEntry{
		{App: "com.spotify.music", Seconds: 900},
	}); err != nil {
		t.Fatalf("InsertTelemetry repeat: %v", err)
	}

	rows, err := st.TelemetryForDay(ctx, dev.ID, day)
	if err != nil {
		t.Fatalf("TelemetryForDay: %v", err)
	}
	if len(rows) != 2 {
		t.Fatalf("rows = %+v, want 2 (a replace, not an insert)", rows)
	}
	if rows[0].App != "com.spotify.music" || rows[0].Seconds != 900 {
		t.Errorf("rows[0] = %+v, want the replaced total 900", rows[0])
	}
	if rows[1].Seconds != 120 {
		t.Errorf("rows[1] = %+v", rows[1])
	}

	// Another day is a different row.
	if _, err := st.InsertTelemetry(ctx, dev.ID, "2026-10-14", []TelemetryEntry{
		{App: "com.spotify.music", Seconds: 60},
	}); err != nil {
		t.Fatalf("InsertTelemetry next day: %v", err)
	}
	rows, err = st.TelemetryForDay(ctx, dev.ID, day)
	if err != nil {
		t.Fatalf("TelemetryForDay: %v", err)
	}
	if len(rows) != 2 || rows[0].Seconds != 900 {
		t.Errorf("rows for %s = %+v, want the day isolated", day, rows)
	}

	// A negative total is dropped, and an empty report is a no-op.
	if n, err := st.InsertTelemetry(ctx, dev.ID, day, []TelemetryEntry{{App: "x", Seconds: -5}}); err != nil || n != 0 {
		t.Errorf("negative telemetry = (%d, %v), want (0, nil)", n, err)
	}
	if n, err := st.InsertTelemetry(ctx, dev.ID, day, nil); err != nil || n != 0 {
		t.Errorf("empty telemetry = (%d, %v), want (0, nil)", n, err)
	}
}

func TestDeviceListsAndTopicLookup(t *testing.T) {
	st, dev := newTestDevice(t)
	ctx := context.Background()

	// The Phase 6 editors do not exist yet, so seed the tables directly.
	seed := []struct {
		table string
		kind  string
		value string
	}{
		{"allowlist", "app", "com.spotify.music"},
		{"allowlist", "site", "school.example.edu"},
		{"blocklist", "app", "com.roblox.client"},
	}
	for _, s := range seed {
		if _, err := st.DB().ExecContext(ctx,
			`INSERT INTO `+s.table+` (device_id, kind, value) VALUES (?, ?, ?)`,
			dev.ID, s.kind, s.value); err != nil {
			t.Fatalf("seed %s: %v", s.table, err)
		}
	}
	// A NULL device_id applies to every device, and duplicates collapse.
	if _, err := st.DB().ExecContext(ctx,
		`INSERT INTO allowlist (device_id, kind, value) VALUES (NULL, 'app', 'com.spotify.music')`); err != nil {
		t.Fatalf("seed global allow: %v", err)
	}

	allow, block, err := st.DeviceLists(ctx, dev.ID)
	if err != nil {
		t.Fatalf("DeviceLists: %v", err)
	}
	if len(allow) != 2 || allow[0] != "com.spotify.music" || allow[1] != "school.example.edu" {
		t.Errorf("allow = %v", allow)
	}
	if len(block) != 1 || block[0] != "com.roblox.client" {
		t.Errorf("block = %v", block)
	}

	found, err := st.DeviceByConfigTopic(ctx, dev.Topic)
	if err != nil {
		t.Fatalf("DeviceByConfigTopic: %v", err)
	}
	if found.ID != dev.ID {
		t.Errorf("DeviceByConfigTopic = %d, want %d", found.ID, dev.ID)
	}
	if _, err := st.DeviceByConfigTopic(ctx, "restrict/nope_99/config"); err != ErrNotFound {
		t.Errorf("unknown topic error = %v, want ErrNotFound", err)
	}
}