package app

import (
	"context"
	"strconv"
	"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)
}

func TestDesktopTaskConsumerPresenceIsSeparateFromHeartbeatPresence(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())
	})

	clientID := uuid.New()

	markDesktopClientPresent(ctx, redis, clientID)

	clientPresence := loadDesktopClientPresence(ctx, redis, []uuid.UUID{clientID})
	taskConsumerPresence := loadDesktopTaskConsumerPresence(ctx, redis, []uuid.UUID{clientID})

	require.NotNil(t, clientPresence)
	require.NotNil(t, taskConsumerPresence)
	assert.True(t, clientPresence[clientID])
	assert.False(t, taskConsumerPresence[clientID])

	markDesktopTaskConsumerPresent(ctx, redis, clientID)
	taskConsumerPresence = loadDesktopTaskConsumerPresence(ctx, redis, []uuid.UUID{clientID})

	require.NotNil(t, taskConsumerPresence)
	assert.True(t, taskConsumerPresence[clientID])
}

func TestDesktopClientPresenceKeepsOriginalOnlineSinceAcrossHeartbeats(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())
	})

	clientID := uuid.New()

	markDesktopClientPresent(ctx, redis, clientID)
	firstOnlineSince := redis.Get(ctx, desktopClientPresenceKey(clientID)).Val()
	require.NotEmpty(t, firstOnlineSince)

	time.Sleep(time.Millisecond)
	markDesktopClientPresent(ctx, redis, clientID)
	secondOnlineSince := redis.Get(ctx, desktopClientPresenceKey(clientID)).Val()

	assert.Equal(t, firstOnlineSince, secondOnlineSince)
	assert.Positive(t, redis.TTL(ctx, desktopClientPresenceKey(clientID)).Val())
}

func TestDesktopAccountPresenceClientsKeepLongRunningOnlineClientAndOrderByOnlineSince(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())
	})

	accountID := uuid.New()
	earlierClientID := uuid.New()
	laterClientID := uuid.New()
	offlineClientID := uuid.New()
	now := time.Date(2026, 6, 19, 10, 0, 0, 0, time.UTC)
	earlierOnlineSince := now.Add(-time.Hour).UnixMilli()
	laterOnlineSince := now.UnixMilli()

	require.NoError(t, redis.Set(ctx, desktopClientPresenceKey(earlierClientID), strconv.FormatInt(earlierOnlineSince, 10), desktopClientPresenceTTL).Err())
	require.NoError(t, redis.Set(ctx, desktopClientPresenceKey(laterClientID), strconv.FormatInt(laterOnlineSince, 10), desktopClientPresenceTTL).Err())
	require.NoError(t, redis.ZAdd(ctx, desktopAccountPresenceKey(accountID),
		goredis.Z{Score: float64(laterOnlineSince), Member: laterClientID.String()},
		goredis.Z{Score: float64(earlierOnlineSince), Member: earlierClientID.String()},
		goredis.Z{Score: float64(now.Add(-2 * time.Hour).UnixMilli()), Member: offlineClientID.String()},
	).Err())

	clientsByAccount := loadDesktopAccountPresenceClients(ctx, redis, []uuid.UUID{accountID})

	require.Len(t, clientsByAccount[accountID], 2)
	assert.Equal(t, earlierClientID, clientsByAccount[accountID][0].ClientID)
	assert.Equal(t, earlierOnlineSince, clientsByAccount[accountID][0].OnlineSinceUnixMilli)
	assert.Equal(t, laterClientID, clientsByAccount[accountID][1].ClientID)
	assert.Equal(t, laterOnlineSince, clientsByAccount[accountID][1].OnlineSinceUnixMilli)
	assert.False(t, redis.ZScore(ctx, desktopAccountPresenceKey(accountID), offlineClientID.String()).Val() > 0)
}