package data_test

import (
	"context"
	"testing"
	"time"

	"github.com/google/uuid"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"nixcn-cms/data"
	"nixcn-cms/testutil"
)

func TestGlobalStatsTotalUsers(t *testing.T) {
	testutil.Setup(t)
	ctx := context.Background()

	for i := 0; i < 3; i++ {
		u := data.NewUser(
			data.WithEmail(uuid.New().String()+"@test.com"),
			data.WithUsername(uuid.New().String()),
			data.WithPermissionLevel(10),
		)
		require.NoError(t, u.Create(ctx))
	}

	count, err := new(data.GlobalStats).TotalUsers(ctx)
	require.NoError(t, err)
	assert.Equal(t, int64(3), count)
}

func TestGlobalStatsUsersPerPermissionLevel(t *testing.T) {
	testutil.Setup(t)
	ctx := context.Background()

	for _, lvl := range []uint{10, 10, 30} {
		u := data.NewUser(
			data.WithEmail(uuid.New().String()+"@test.com"),
			data.WithUsername(uuid.New().String()),
			data.WithPermissionLevel(lvl),
		)
		require.NoError(t, u.Create(ctx))
	}

	results, err := new(data.GlobalStats).UsersPerPermissionLevel(ctx)
	require.NoError(t, err)
	require.NotNil(t, results)

	countMap := make(map[uint]int64)
	for _, r := range *results {
		countMap[r.PermissionLevel] = r.Count
	}
	assert.Equal(t, int64(2), countMap[10])
	assert.Equal(t, int64(1), countMap[30])
}

func TestGlobalStatsEventJoinCheckinCounts(t *testing.T) {
	testutil.Setup(t)
	ctx := context.Background()

	owner := uuid.New()
	ev := makeEvent(owner)
	require.NoError(t, ev.Create(ctx))

	for i, checkin := range []bool{true, false} {
		u := data.NewUser(
			data.WithEmail(uuid.New().String()+"@test.com"),
			data.WithUsername(uuid.New().String()),
			data.WithPermissionLevel(10),
		)
		require.NoError(t, u.Create(ctx))

		a := data.NewAttendance(
			data.WithEventId(ev.EventId),
			data.WithUserId(u.UserId),
			data.WithKycId(uuid.Nil),
			data.WithRole("attendee"),
			data.WithState("success"),
		)
		if checkin {
			a.CheckinAt = time.Now()
		}
		_ = i
		_, err := a.Create(ctx)
		require.NoError(t, err)
	}

	results, err := new(data.GlobalStats).EventJoinCheckinCounts(ctx)
	require.NoError(t, err)
	require.NotNil(t, results)
	require.Len(t, *results, 1)

	stat := (*results)[0]
	assert.Equal(t, ev.EventId, stat.EventId)
	assert.Equal(t, int64(2), stat.JoinCount)
	assert.Equal(t, int64(1), stat.CheckinCount)
}

func TestGlobalStatsEventJoinCheckinCountsEmpty(t *testing.T) {
	testutil.Setup(t)
	ctx := context.Background()

	results, err := new(data.GlobalStats).EventJoinCheckinCounts(ctx)
	require.NoError(t, err)
	require.NotNil(t, results)
	assert.Empty(t, *results)
}

func TestGlobalStatsEventJoinCheckinMultipleEvents(t *testing.T) {
	testutil.Setup(t)
	ctx := context.Background()

	owner := uuid.New()
	ev1 := makeEvent(owner)
	require.NoError(t, ev1.Create(ctx))
	ev2 := makeEvent(owner)
	require.NoError(t, ev2.Create(ctx))

	for _, evId := range []uuid.UUID{ev1.EventId, ev2.EventId} {
		u := data.NewUser(
			data.WithEmail(uuid.New().String()+"@test.com"),
			data.WithUsername(uuid.New().String()),
			data.WithPermissionLevel(10),
		)
		require.NoError(t, u.Create(ctx))
		a := data.NewAttendance(
			data.WithEventId(evId),
			data.WithUserId(u.UserId),
			data.WithKycId(uuid.Nil),
			data.WithRole("attendee"),
			data.WithState("success"),
		)
		_, err := a.Create(ctx)
		require.NoError(t, err)
	}

	results, err := new(data.GlobalStats).EventJoinCheckinCounts(ctx)
	require.NoError(t, err)
	require.NotNil(t, results)
	assert.Len(t, *results, 2)
	for _, stat := range *results {
		assert.Equal(t, int64(1), stat.JoinCount)
		assert.Equal(t, int64(0), stat.CheckinCount)
	}
}