package ocean_test

import (
	"sync"
	"testing"

	"git.akyoto.dev/go/assert"
	"git.akyoto.dev/go/ocean"
)

type User struct {
	Name string `json:"name"`
}

func TestAll(t *testing.T) {
	users, err := ocean.New[User]("test")
	assert.Nil(t, err)
	defer users.Clear()

	users.Set("1", &User{Name: "User 1"})
	users.Set("2", &User{Name: "User 2"})
	users.Set("3", &User{Name: "User 3"})
	count := 0

	for range users.All() {
		count++
	}

	assert.Equal(t, count, 3)
}

func TestFilter(t *testing.T) {
	users, err := ocean.New[User]("test")
	assert.Nil(t, err)
	defer users.Clear()

	users.Set("1", &User{Name: "User 1"})
	users.Set("2", &User{Name: "User 2"})
	users.Set("3", &User{Name: "User 3"})
	count := 0

	f := func(user *User) bool {
		return user.Name == "User 2"
	}

	for range users.Filter(f) {
		count++
	}

	assert.Equal(t, count, 1)
}

func TestGet(t *testing.T) {
	users, err := ocean.New[User]("test")
	assert.Nil(t, err)
	defer users.Clear()

	users.Set("1", &User{Name: "User 1"})
	user, err := users.Get("1")

	assert.Nil(t, err)
	assert.NotNil(t, user)
}

func TestInteraction(t *testing.T) {
	users, err := ocean.New[User]("test")
	assert.Nil(t, err)
	defer users.Clear()

	assert.True(t, !users.Exists("1"))
	assert.True(t, !users.Exists("2"))

	users.Set("1", &User{Name: "User 1"})

	assert.True(t, users.Exists("1"))
	assert.True(t, !users.Exists("2"))

	users.Set("2", &User{Name: "User 1"})

	assert.True(t, users.Exists("1"))
	assert.True(t, users.Exists("2"))

	users.Delete("1")

	assert.True(t, !users.Exists("1"))
	assert.True(t, users.Exists("2"))

	users.Delete("2")

	assert.True(t, !users.Exists("1"))
	assert.True(t, !users.Exists("2"))
}

func TestPersistence(t *testing.T) {
	users, err := ocean.New[User]("test")
	assert.Nil(t, err)
	defer users.Clear()

	users.Set("1", &User{Name: "User 1"})
	users.Set("2", &User{Name: "User 2"})

	again, err := ocean.New[User]("test")
	assert.Nil(t, err)

	user1, err := again.Get("1")
	assert.Nil(t, err)

	user2, err := again.Get("2")
	assert.Nil(t, err)

	assert.NotNil(t, user1)
	assert.NotNil(t, user2)
}

func TestParallel(t *testing.T) {
	users, err := ocean.New[User]("test")
	assert.Nil(t, err)
	defer users.Clear()

	users.Set("1", &User{Name: "User 1"})
	wg := sync.WaitGroup{}

	for i := 0; i < 100; i++ {
		wg.Add(2)

		go func() {
			defer wg.Done()
			user, err := users.Get("1")
			assert.Nil(t, err)
			assert.NotNil(t, user)
			assert.Equal(t, user.Name, "User 1")
		}()

		go func() {
			defer wg.Done()
			users.Set("1", &User{Name: "User 1"})
		}()
	}

	wg.Wait()
}

func BenchmarkGet(b *testing.B) {
	users, err := ocean.New[User]("test")
	assert.Nil(b, err)
	defer users.Clear()
	users.Set("1", &User{Name: "User 1"})

	b.ReportAllocs()
	b.ResetTimer()

	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			_, err := users.Get("1")

			if err != nil {
				b.Fail()
			}
		}
	})

	b.StopTimer()
}

func BenchmarkSet(b *testing.B) {
	users, err := ocean.New[User]("test")
	assert.Nil(b, err)
	defer users.Clear()
	user := &User{Name: "User 1"}

	b.ReportAllocs()
	b.ResetTimer()

	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			users.Set("1", user)
		}
	})

	b.StopTimer()
}

func BenchmarkDelete(b *testing.B) {
	users, err := ocean.New[User]("test")
	assert.Nil(b, err)
	defer users.Clear()

	b.ReportAllocs()
	b.ResetTimer()

	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			users.Delete("1")
		}
	})

	b.StopTimer()
}