package app

import (
	"context"
	"testing"
	"time"

	"github.com/alicebob/miniredis/v2"
	"github.com/google/uuid"
	goredis "github.com/redis/go-redis/v9"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"

	"github.com/geo-platform/tenant-api/internal/tenant/repository"
)

func TestDesktopUserOnlineClientCountPrefersRedisPresenceIndex(t *testing.T) {
	ctx := context.Background()
	server := miniredis.RunT(t)
	redis := goredis.NewClient(&goredis.Options{Addr: server.Addr()})
	t.Cleanup(func() {
		require.NoError(t, redis.Close())
	})

	tenantID := int64(7)
	workspaceID := int64(11)
	userID := int64(23)
	firstClientID := uuid.New()
	secondClientID := uuid.New()

	markDesktopClientPresentForUser(ctx, redis, firstClientID, tenantID, workspaceID, userID)
	markDesktopClientPresentForUser(ctx, redis, secondClientID, tenantID, workspaceID, userID)

	count, ok := loadDesktopUserOnlineClientCount(ctx, redis, tenantID, workspaceID, userID, time.Now().UTC())

	require.True(t, ok)
	assert.Equal(t, 2, count)
}

func TestDesktopClientServiceOnlineCountReturnsRedisCountBeforeRepoFallback(t *testing.T) {
	ctx := context.Background()
	server := miniredis.RunT(t)
	redis := goredis.NewClient(&goredis.Options{Addr: server.Addr()})
	t.Cleanup(func() {
		require.NoError(t, redis.Close())
	})

	client := &repository.DesktopClient{
		ID:          uuid.New(),
		TenantID:    7,
		WorkspaceID: 11,
		UserID:      23,
	}
	markDesktopClientPresentForUser(ctx, redis, client.ID, client.TenantID, client.WorkspaceID, client.UserID)
	markDesktopClientPresentForUser(ctx, redis, uuid.New(), client.TenantID, client.WorkspaceID, client.UserID)

	count, err := (&DesktopClientService{redis: redis}).currentUserOnlineClientCount(ctx, client)

	require.NoError(t, err)
	assert.Equal(t, 2, count)
}

func TestDesktopUserOnlineClientCountPrunesStaleRedisPresence(t *testing.T) {
	ctx := context.Background()
	server := miniredis.RunT(t)
	redis := goredis.NewClient(&goredis.Options{Addr: server.Addr()})
	t.Cleanup(func() {
		require.NoError(t, redis.Close())
	})

	tenantID := int64(7)
	workspaceID := int64(11)
	userID := int64(23)
	key := desktopUserClientsPresenceKey(tenantID, workspaceID, userID)
	now := time.Date(2026, 5, 6, 12, 0, 0, 0, time.UTC)

	require.NoError(t, redis.ZAdd(ctx, key,
		goredis.Z{Score: float64(now.Add(-2 * desktopClientPresenceTTL).UnixMilli()), Member: uuid.NewString()},
		goredis.Z{Score: float64(now.Add(-time.Second).UnixMilli()), Member: uuid.NewString()},
	).Err())

	count, ok := loadDesktopUserOnlineClientCount(ctx, redis, tenantID, workspaceID, userID, now)

	require.True(t, ok)
	assert.Equal(t, 1, count)
}