package hub

import (
	"context"
	"fmt"
	"sync"
	"sync/atomic"
	"testing"
	"time"

	"commilitia.net/cdrop/internal/db"
)

// fakeLister returns a fixed device list and counts calls.
type fakeLister struct {
	devices []db.Device
	calls   atomic.Int32
}

func (f *fakeLister) ListDevicesByUser(_ context.Context, _ string) ([]db.Device, error) {
	f.calls.Add(1)
	return f.devices, nil
}

func waitForEvent(t *testing.T, c *Client, want string, timeout time.Duration) Event {
	t.Helper()
	select {
	case ev, ok := <-c.Events():
		if !ok {
			t.Fatalf("event channel closed; wanted type=%q", want)
		}
		if want != "" && ev.Type != want {
			t.Fatalf("event type: got %q, want %q", ev.Type, want)
		}
		return ev
	case <-time.After(timeout):
		t.Fatalf("timeout waiting for event type=%q", want)
	}
	return Event{}
}

func TestConnectFiresPresenceEvent(t *testing.T) {
	lister := &fakeLister{
		devices: []db.Device{{UserID: "alice", Name: "tab-1", Type: "browser", LastSeen: 1}},
	}
	h := New(lister)
	defer h.Close()

	c := h.Connect(context.Background(), "alice", "tab-1", "browser")
	defer h.Disconnect(c)

	ev := waitForEvent(t, c, "presence", time.Second)
	data, _ := ev.Data.(map[string]any)
	devs, _ := data["devices"].([]PresenceDevice)
	if len(devs) != 1 || devs[0].Name != "tab-1" || !devs[0].Online {
		t.Errorf("presence devices: %+v", devs)
	}
}

func TestSecondClientSeesFirstAsOnline(t *testing.T) {
	lister := &fakeLister{
		devices: []db.Device{
			{UserID: "alice", Name: "tab-1", Type: "browser", LastSeen: 1},
			{UserID: "alice", Name: "tab-2", Type: "browser", LastSeen: 2},
		},
	}
	h := New(lister)
	defer h.Close()

	c1 := h.Connect(context.Background(), "alice", "tab-1", "browser")
	defer h.Disconnect(c1)
	_ = waitForEvent(t, c1, "presence", time.Second)

	c2 := h.Connect(context.Background(), "alice", "tab-2", "browser")
	defer h.Disconnect(c2)

	// c2 receives its own presence (announced on Connect).
	ev := waitForEvent(t, c2, "presence", time.Second)
	devs, _ := ev.Data.(map[string]any)["devices"].([]PresenceDevice)
	if len(devs) != 2 {
		t.Fatalf("expected 2 devices in presence, got %+v", devs)
	}
	online := map[string]bool{}
	for _, d := range devs {
		online[d.Name] = d.Online
	}
	if !online["tab-1"] || !online["tab-2"] {
		t.Errorf("both tabs should be online: %+v", online)
	}

	// c1 also gets presence diff for c2's arrival.
	ev = waitForEvent(t, c1, "presence", time.Second)
	devs, _ = ev.Data.(map[string]any)["devices"].([]PresenceDevice)
	if len(devs) != 2 {
		t.Errorf("c1 presence after tab-2 arrival: got %d devices, want 2", len(devs))
	}
}

// A live device with no devices-table row (global-SSO browser / broker-auth desktop)
// must still appear in presence as online, labelled by its declared type.
func TestLiveOnlyDeviceAppearsInPresence(t *testing.T) {
	h := New(&fakeLister{}) // empty managed-device set
	defer h.Close()

	c := h.Connect(context.Background(), "alice", "macbook", "macos")
	defer h.Disconnect(c)

	ev := waitForEvent(t, c, "presence", time.Second)
	devs, _ := ev.Data.(map[string]any)["devices"].([]PresenceDevice)
	if len(devs) != 1 || devs[0].Name != "macbook" || devs[0].Type != "macos" || !devs[0].Online {
		t.Errorf("live-only device should appear online in presence: %+v", devs)
	}
}

func TestSendToRoutesEvent(t *testing.T) {
	lister := &fakeLister{}
	h := New(lister)
	defer h.Close()

	c := h.Connect(context.Background(), "alice", "tab-1", "browser")
	defer h.Disconnect(c)
	_ = waitForEvent(t, c, "presence", time.Second)

	if !h.SendTo("alice", "tab-1", Event{Type: "signal", Data: map[string]any{"x": 1}}) {
		t.Fatal("SendTo to live client should report true")
	}
	ev := waitForEvent(t, c, "signal", time.Second)
	if ev.Data.(map[string]any)["x"] != 1 {
		t.Errorf("payload: %+v", ev.Data)
	}
}

func TestSendToOfflineDeviceReportsFalse(t *testing.T) {
	h := New(&fakeLister{})
	defer h.Close()
	if h.SendTo("ghost-user", "ghost-device", Event{Type: "signal"}) {
		t.Error("SendTo to offline target should report false")
	}
}

func TestReconnectClosesOldChannel(t *testing.T) {
	h := New(&fakeLister{})
	defer h.Close()

	old := h.Connect(context.Background(), "alice", "tab-1", "browser")
	// drain the initial presence so we can detect close
	<-old.Events()

	_ = h.Connect(context.Background(), "alice", "tab-1", "browser")

	select {
	case _, ok := <-old.Events():
		if ok {
			t.Error("old channel should be closed on reconnect from same (user, device)")
		}
	case <-time.After(time.Second):
		t.Fatal("timeout waiting for old channel close")
	}
}

func TestDisconnectRemovesFromOnlineSet(t *testing.T) {
	h := New(&fakeLister{
		devices: []db.Device{{UserID: "alice", Name: "tab-1", Type: "browser"}},
	})
	defer h.Close()

	c := h.Connect(context.Background(), "alice", "tab-1", "browser")
	if !h.Online("alice", "tab-1") {
		t.Fatal("client should be online after Connect")
	}
	h.Disconnect(c)
	if h.Online("alice", "tab-1") {
		t.Error("client should not be online after Disconnect")
	}
}

// TestConcurrentKickAndPresenceNoPanic hammers Kick (which closes channels under the write
// lock) against publishPresence / Broadcast / SendTo (non-blocking sends under the read lock).
// Before the close-vs-send fix this raced into a "send on closed channel" panic that crashed
// the whole process; now close and send are mutually exclusive. Run with -race.
func TestConcurrentKickAndPresenceNoPanic(t *testing.T) {
	h := New(&fakeLister{
		devices: []db.Device{{UserID: "u", Name: "d", Type: "browser"}},
	})
	defer h.Close()

	const workers = 16
	const iters = 200
	var wg sync.WaitGroup
	for i := 0; i < workers; i += 1 {
		wg.Add(1)
		go func(n int) {
			defer wg.Done()
			name := fmt.Sprintf("d%d", n)
			for j := 0; j < iters; j += 1 {
				h.Connect(context.Background(), "u", name, "browser")
				h.PublishPresence(context.Background(), "u")
				h.Broadcast("u", Event{Type: "x"})
				h.SendTo("u", name, Event{Type: "y"})
				h.Kick("u", name)
			}
		}(i)
	}
	wg.Wait()
}

// TestGracePeriod uses a tiny grace so the test runs fast.
func TestGracePeriodDelaysOfflinePresence(t *testing.T) {
	h := New(&fakeLister{
		devices: []db.Device{
			{UserID: "alice", Name: "tab-1", Type: "browser"},
			{UserID: "alice", Name: "tab-2", Type: "browser"},
		},
	})
	h.grace = 100 * time.Millisecond
	defer h.Close()

	c1 := h.Connect(context.Background(), "alice", "tab-1", "browser")
	defer h.Disconnect(c1)
	c2 := h.Connect(context.Background(), "alice", "tab-2", "browser")
	// Drain initial presence frames
	_ = waitForEvent(t, c1, "presence", time.Second)
	_ = waitForEvent(t, c1, "presence", time.Second)
	_ = waitForEvent(t, c2, "presence", time.Second)

	h.Disconnect(c2)
	// Grace 100ms: c1 should receive presence after the grace window with tab-2 offline.
	select {
	case ev := <-c1.Events():
		if ev.Type != "presence" {
			t.Fatalf("expected presence after grace, got %q", ev.Type)
		}
		devs := ev.Data.(map[string]any)["devices"].([]PresenceDevice)
		var tab2Online bool
		for _, d := range devs {
			if d.Name == "tab-2" {
				tab2Online = d.Online
			}
		}
		if tab2Online {
			t.Error("tab-2 should be offline in post-grace presence")
		}
	case <-time.After(time.Second):
		t.Fatal("timeout waiting for post-grace presence")
	}
}