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 makeEvent(owner uuid.UUID) *data.Event {
	now := time.Now()
	return data.NewEvent(
		data.WithEventName("Test Event "+uuid.New().String()[:8]),
		data.WithEventType("party"),
		data.WithEventSubtitle("A test event"),
		data.WithEventStartTime(now.Add(24*time.Hour)),
		data.WithEventEndTime(now.Add(48*time.Hour)),
		data.WithOwner(owner),
		data.WithQuota(100),
		data.WithLimit(50),
	)
}

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

	owner := uuid.New()
	ev := makeEvent(owner)
	require.NoError(t, ev.Create(ctx))
	assert.NotEqual(t, uuid.Nil, ev.EventId)
}

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

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

	got, err := new(data.Event).GetEventById(ctx, ev.EventId)
	require.NoError(t, err)
	require.NotNil(t, got)
	assert.Equal(t, ev.EventId, got.EventId)
	assert.Equal(t, ev.Name, got.Name)
}

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

	got, err := new(data.Event).GetEventById(ctx, uuid.New())
	require.NoError(t, err)
	assert.Nil(t, got)
}

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

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

	require.NoError(t, new(data.Event).DeleteEventById(ctx, ev.EventId))

	got, err := new(data.Event).GetEventById(ctx, ev.EventId)
	require.NoError(t, err)
	assert.Nil(t, got)
}

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

	err := new(data.Event).DeleteEventById(ctx, uuid.New())
	require.Error(t, err)
}

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

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

	require.NoError(t, ev.PatchByEventId(ctx, ev.EventId,
		data.WithEventName("Updated Name"),
		data.WithEventSubtitle("Updated subtitle"),
	))

	got, err := new(data.Event).GetEventById(ctx, ev.EventId)
	require.NoError(t, err)
	assert.Equal(t, "Updated Name", got.Name)
	assert.Equal(t, "Updated subtitle", got.Subtitle)
}

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

	owner := uuid.New()
	for _, typ := range []string{"party", "party", "official"} {
		ev := makeEvent(owner)
		ev.Type = typ
		require.NoError(t, ev.Create(ctx))
	}

	results, total, err := new(data.Event).ListEventsWithOptions(ctx, data.EventListOptions{
		TypeFilter: "party",
		Limit:      10,
	})
	require.NoError(t, err)
	assert.Equal(t, int64(2), total)
	assert.Len(t, *results, 2)
}

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

	owner1 := uuid.New()
	owner2 := uuid.New()
	for i := 0; i < 3; i++ {
		require.NoError(t, makeEvent(owner1).Create(ctx))
	}
	require.NoError(t, makeEvent(owner2).Create(ctx))

	results, total, err := new(data.Event).ListEventsWithOptions(ctx, data.EventListOptions{
		OwnerId: &owner1,
		Limit:   10,
	})
	require.NoError(t, err)
	assert.Equal(t, int64(3), total)
	assert.Len(t, *results, 3)
}

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

	owner := uuid.New()
	for i := 0; i < 5; i++ {
		require.NoError(t, makeEvent(owner).Create(ctx))
	}

	limit, offset := int64(3), int64(0)
	results, err := new(data.Event).FastListEvents(ctx, limit, offset)
	require.NoError(t, err)
	assert.Len(t, *results, 3)
}

func TestEventGetEventsByUserId(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))
	ev3 := makeEvent(owner)
	require.NoError(t, ev3.Create(ctx))

	u := data.NewUser(
		data.WithEmail(uuid.New().String()+"@test.com"),
		data.WithUsername(uuid.New().String()),
		data.WithPermissionLevel(10),
	)
	require.NoError(t, u.Create(ctx))

	for _, evId := range []uuid.UUID{ev1.EventId, ev2.EventId} {
		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.Event).GetEventsByUserId(ctx, u.UserId, 10, 0)
	require.NoError(t, err)
	require.NotNil(t, results)
	assert.Len(t, *results, 2)
}

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

	results, err := new(data.Event).GetEventsByUserId(ctx, uuid.New(), 10, 0)
	require.NoError(t, err)
	require.NotNil(t, results)
	assert.Empty(t, *results)
}