package ocean_test

import (
	"fmt"
	"strconv"
	"sync"
	"testing"

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

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

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

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

	t.Run("All", func(t *testing.T) {
		count := 0

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

		assert.Equal(t, count, 3)
	})

	t.Run("Filter", func(t *testing.T) {
		count := 0

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

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

		assert.Equal(t, count, 1)
	})

	t.Run("Get", func(t *testing.T) {
		user, err := users.Get("1")
		assert.Nil(t, err)
		assert.NotNil(t, user)
		assert.Equal(t, user.Name, "User 1")
	})

	t.Run("Exists", func(t *testing.T) {
		assert.True(t, users.Exists("1"))
		assert.True(t, users.Exists("2"))
		assert.True(t, users.Exists("3"))
		assert.True(t, !users.Exists("4"))
	})

	t.Run("Parallel Get and Set", func(t *testing.T) {
		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()
	})

	t.Run("Persistence", func(t *testing.T) {
		users.Sync()

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

		user, err := again.Get("1")
		assert.Nil(t, err)
		assert.NotNil(t, user)
		assert.Equal(t, user.Name, "User 1")

		user, err = again.Get("2")
		assert.Nil(t, err)
		assert.NotNil(t, user)
		assert.Equal(t, user.Name, "User 2")

		user, err = again.Get("3")
		assert.Nil(t, err)
		assert.NotNil(t, user)
		assert.Equal(t, user.Name, "User 3")
	})

	t.Run("Delete", func(t *testing.T) {
		assert.True(t, users.Exists("1"))
		assert.True(t, users.Exists("2"))
		assert.True(t, users.Exists("3"))

		users.Delete("1")

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

		users.Delete("2")

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

		users.Delete("3")

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

func BenchmarkGet(b *testing.B) {
	users, err := ocean.New[User]("test")
	assert.Nil(b, err)
	defer users.Sync()
	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.Sync()
	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.Sync()
	defer users.Clear()

	b.ReportAllocs()
	b.ResetTimer()

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

	b.StopTimer()
}

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

	b.Run("100", func(b *testing.B) {
		for i := 0; i < 100; i++ {
			users.Set(strconv.Itoa(i), &User{Name: fmt.Sprintf("User %d", i)})
		}

		b.ReportAllocs()
		b.ResetTimer()

		for n := 0; n < b.N; n++ {
			again, err := ocean.New[User]("test")
			assert.Nil(b, err)
			assert.NotNil(b, again)
		}

		b.StopTimer()
	})
}