package mdb

import (
	"fmt"
	"reflect"
	"testing"
)

func TestDBList(t *testing.T) {
	db := NewTestDBPrimary(t, t.TempDir())

	var (
		user1 = User{
			ID:    NewID(),
			Name:  "User1",
			Email: "user1@gmail.com",
		}

		user2 = User{
			ID:    NewID(),
			Name:  "User2",
			Email: "user2@gmail.com",
		}

		user3 = User{
			ID:    NewID(),
			Name:  "User3",
			Email: "user3@gmail.com",
		}
		user1Data = make([]UserDataItem, 10)
		user2Data = make([]UserDataItem, 4)
		user3Data = make([]UserDataItem, 8)
	)

	err := db.Update(func(tx *Snapshot) error {
		if err := db.Users.Insert(tx, &user1); err != nil {
			return err
		}

		if err := db.Users.Insert(tx, &user2); err != nil {
			return err
		}

		for i := range user1Data {
			user1Data[i] = UserDataItem{
				ID:     NewID(),
				UserID: user1.ID,
				Name:   fmt.Sprintf("Name1: %d", i),
				Data:   fmt.Sprintf("Data: %d", i),
			}

			if err := db.UserData.Insert(tx, &user1Data[i]); err != nil {
				return err
			}
		}

		for i := range user2Data {
			user2Data[i] = UserDataItem{
				ID:     NewID(),
				UserID: user2.ID,
				Name:   fmt.Sprintf("Name2: %d", i),
				Data:   fmt.Sprintf("Data: %d", i),
			}

			if err := db.UserData.Insert(tx, &user2Data[i]); err != nil {
				return err
			}
		}

		for i := range user3Data {
			user3Data[i] = UserDataItem{
				ID:     NewID(),
				UserID: user3.ID,
				Name:   fmt.Sprintf("Name3: %d", i),
				Data:   fmt.Sprintf("Data: %d", i),
			}

			if err := db.UserData.Insert(tx, &user3Data[i]); err != nil {
				return err
			}
		}

		return nil
	})

	if err != nil {
		t.Fatal(err)
	}

	type TestCase struct {
		Name     string
		Args     ListArgs[UserDataItem]
		Expected []UserDataItem
	}

	cases := []TestCase{
		{
			Name: "User1 all",
			Args: ListArgs[UserDataItem]{
				After: &UserDataItem{
					UserID: user1.ID,
				},
				While: func(item *UserDataItem) bool {
					return item.UserID == user1.ID
				},
			},
			Expected: user1Data,
		}, {
			Name: "User1 limited",
			Args: ListArgs[UserDataItem]{
				After: &UserDataItem{
					UserID: user1.ID,
				},
				While: func(item *UserDataItem) bool {
					return item.UserID == user1.ID
				},
				Limit: 4,
			},
			Expected: user1Data[:4],
		},
	}

	for _, tc := range cases {
		t.Run(tc.Name, func(t *testing.T) {
			tx := db.Snapshot()
			l := db.UserData.ByName.List(tx, tc.Args, nil)
			if len(l) != len(tc.Expected) {
				t.Fatal(tc.Name, l)
			}

			for i := range l {
				if !reflect.DeepEqual(*l[i], tc.Expected[i]) {
					t.Fatal(tc.Name, l)
				}
			}
		})
	}
}