package user_test

import (
	"net/netip"
	"path/filepath"
	"testing"
	"time"

	"github.com/stretchr/testify/require"
	dbtest "heckel.io/ntfy/v2/db/test"
	"heckel.io/ntfy/v2/user"
)

func forEachStoreBackend(t *testing.T, f func(t *testing.T, store user.Store)) {
	t.Run("sqlite", func(t *testing.T) {
		store, err := user.NewSQLiteStore(filepath.Join(t.TempDir(), "user.db"), "")
		require.Nil(t, err)
		t.Cleanup(func() { store.Close() })
		f(t, store)
	})
	t.Run("postgres", func(t *testing.T) {
		testDB := dbtest.CreateTestPostgres(t)
		store, err := user.NewPostgresStore(testDB)
		require.Nil(t, err)
		f(t, store)
	})
}

func TestStoreAddUser(t *testing.T) {
	forEachStoreBackend(t, func(t *testing.T, store user.Store) {
		require.Nil(t, store.AddUser("phil", "philhash", user.RoleUser, false))
		u, err := store.User("phil")
		require.Nil(t, err)
		require.Equal(t, "phil", u.Name)
		require.Equal(t, user.RoleUser, u.Role)
		require.False(t, u.Provisioned)
		require.NotEmpty(t, u.ID)
		require.NotEmpty(t, u.SyncTopic)
	})
}

func TestStoreAddUserAlreadyExists(t *testing.T) {
	forEachStoreBackend(t, func(t *testing.T, store user.Store) {
		require.Nil(t, store.AddUser("phil", "philhash", user.RoleUser, false))
		require.Equal(t, user.ErrUserExists, store.AddUser("phil", "philhash", user.RoleUser, false))
	})
}

func TestStoreRemoveUser(t *testing.T) {
	forEachStoreBackend(t, func(t *testing.T, store user.Store) {
		require.Nil(t, store.AddUser("phil", "philhash", user.RoleUser, false))
		u, err := store.User("phil")
		require.Nil(t, err)
		require.Equal(t, "phil", u.Name)

		require.Nil(t, store.RemoveUser("phil"))
		_, err = store.User("phil")
		require.Equal(t, user.ErrUserNotFound, err)
	})
}

func TestStoreUserByID(t *testing.T) {
	forEachStoreBackend(t, func(t *testing.T, store user.Store) {
		require.Nil(t, store.AddUser("phil", "philhash", user.RoleAdmin, false))
		u, err := store.User("phil")
		require.Nil(t, err)

		u2, err := store.UserByID(u.ID)
		require.Nil(t, err)
		require.Equal(t, u.Name, u2.Name)
		require.Equal(t, u.ID, u2.ID)
	})
}

func TestStoreUserByToken(t *testing.T) {
	forEachStoreBackend(t, func(t *testing.T, store user.Store) {
		require.Nil(t, store.AddUser("phil", "philhash", user.RoleUser, false))
		u, err := store.User("phil")
		require.Nil(t, err)

		tk, err := store.CreateToken(u.ID, "tk_test123", "test token", time.Now(), netip.MustParseAddr("1.2.3.4"), time.Now().Add(24*time.Hour), 0, false)
		require.Nil(t, err)
		require.Equal(t, "tk_test123", tk.Value)

		u2, err := store.UserByToken(tk.Value)
		require.Nil(t, err)
		require.Equal(t, "phil", u2.Name)
	})
}

func TestStoreUserByStripeCustomer(t *testing.T) {
	forEachStoreBackend(t, func(t *testing.T, store user.Store) {
		require.Nil(t, store.AddUser("phil", "philhash", user.RoleUser, false))
		require.Nil(t, store.ChangeBilling("phil", &user.Billing{
			StripeCustomerID:     "cus_test123",
			StripeSubscriptionID: "sub_test123",
		}))

		u, err := store.UserByStripeCustomer("cus_test123")
		require.Nil(t, err)
		require.Equal(t, "phil", u.Name)
		require.Equal(t, "cus_test123", u.Billing.StripeCustomerID)
	})
}

func TestStoreUsers(t *testing.T) {
	forEachStoreBackend(t, func(t *testing.T, store user.Store) {
		require.Nil(t, store.AddUser("phil", "philhash", user.RoleUser, false))
		require.Nil(t, store.AddUser("ben", "benhash", user.RoleAdmin, false))

		users, err := store.Users()
		require.Nil(t, err)
		require.True(t, len(users) >= 3) // phil, ben, and the everyone user
	})
}

func TestStoreUsersCount(t *testing.T) {
	forEachStoreBackend(t, func(t *testing.T, store user.Store) {
		count, err := store.UsersCount()
		require.Nil(t, err)
		require.True(t, count >= 1) // At least the everyone user

		require.Nil(t, store.AddUser("phil", "philhash", user.RoleUser, false))
		count2, err := store.UsersCount()
		require.Nil(t, err)
		require.Equal(t, count+1, count2)
	})
}

func TestStoreChangePassword(t *testing.T) {
	forEachStoreBackend(t, func(t *testing.T, store user.Store) {
		require.Nil(t, store.AddUser("phil", "philhash", user.RoleUser, false))
		u, err := store.User("phil")
		require.Nil(t, err)
		require.Equal(t, "philhash", u.Hash)

		require.Nil(t, store.ChangePassword("phil", "newhash"))
		u, err = store.User("phil")
		require.Nil(t, err)
		require.Equal(t, "newhash", u.Hash)
	})
}

func TestStoreChangeRole(t *testing.T) {
	forEachStoreBackend(t, func(t *testing.T, store user.Store) {
		require.Nil(t, store.AddUser("phil", "philhash", user.RoleUser, false))
		u, err := store.User("phil")
		require.Nil(t, err)
		require.Equal(t, user.RoleUser, u.Role)

		require.Nil(t, store.ChangeRole("phil", user.RoleAdmin))
		u, err = store.User("phil")
		require.Nil(t, err)
		require.Equal(t, user.RoleAdmin, u.Role)
	})
}

func TestStoreTokens(t *testing.T) {
	forEachStoreBackend(t, func(t *testing.T, store user.Store) {
		require.Nil(t, store.AddUser("phil", "philhash", user.RoleUser, false))
		u, err := store.User("phil")
		require.Nil(t, err)

		now := time.Now()
		expires := now.Add(24 * time.Hour)
		origin := netip.MustParseAddr("9.9.9.9")

		tk, err := store.CreateToken(u.ID, "tk_abc", "my token", now, origin, expires, 0, false)
		require.Nil(t, err)
		require.Equal(t, "tk_abc", tk.Value)
		require.Equal(t, "my token", tk.Label)

		// Get single token
		tk2, err := store.Token(u.ID, "tk_abc")
		require.Nil(t, err)
		require.Equal(t, "tk_abc", tk2.Value)
		require.Equal(t, "my token", tk2.Label)

		// Get all tokens
		tokens, err := store.Tokens(u.ID)
		require.Nil(t, err)
		require.Len(t, tokens, 1)
		require.Equal(t, "tk_abc", tokens[0].Value)
	})
}

func TestStoreTokenChange(t *testing.T) {
	forEachStoreBackend(t, func(t *testing.T, store user.Store) {
		require.Nil(t, store.AddUser("phil", "philhash", user.RoleUser, false))
		u, err := store.User("phil")
		require.Nil(t, err)

		expires := time.Now().Add(time.Hour)
		_, err = store.CreateToken(u.ID, "tk_abc", "old label", time.Now(), netip.MustParseAddr("1.2.3.4"), expires, 0, false)
		require.Nil(t, err)

		newExpires := time.Now().Add(2 * time.Hour)
		require.Nil(t, store.ChangeToken(u.ID, "tk_abc", "new label", newExpires))
		tk, err := store.Token(u.ID, "tk_abc")
		require.Nil(t, err)
		require.Equal(t, "new label", tk.Label)
		require.Equal(t, newExpires.Unix(), tk.Expires.Unix())
	})
}

func TestStoreTokenRemove(t *testing.T) {
	forEachStoreBackend(t, func(t *testing.T, store user.Store) {
		require.Nil(t, store.AddUser("phil", "philhash", user.RoleUser, false))
		u, err := store.User("phil")
		require.Nil(t, err)

		_, err = store.CreateToken(u.ID, "tk_abc", "label", time.Now(), netip.MustParseAddr("1.2.3.4"), time.Now().Add(time.Hour), 0, false)
		require.Nil(t, err)

		require.Nil(t, store.RemoveToken(u.ID, "tk_abc"))
		_, err = store.Token(u.ID, "tk_abc")
		require.Equal(t, user.ErrTokenNotFound, err)
	})
}

func TestStoreTokenRemoveExpired(t *testing.T) {
	forEachStoreBackend(t, func(t *testing.T, store user.Store) {
		require.Nil(t, store.AddUser("phil", "philhash", user.RoleUser, false))
		u, err := store.User("phil")
		require.Nil(t, err)

		// Create expired token and active token
		_, err = store.CreateToken(u.ID, "tk_expired", "expired", time.Now(), netip.MustParseAddr("1.2.3.4"), time.Now().Add(-time.Hour), 0, false)
		require.Nil(t, err)
		_, err = store.CreateToken(u.ID, "tk_active", "active", time.Now(), netip.MustParseAddr("1.2.3.4"), time.Now().Add(time.Hour), 0, false)
		require.Nil(t, err)

		require.Nil(t, store.RemoveExpiredTokens())

		// Expired token should be gone
		_, err = store.Token(u.ID, "tk_expired")
		require.Equal(t, user.ErrTokenNotFound, err)

		// Active token should still exist
		tk, err := store.Token(u.ID, "tk_active")
		require.Nil(t, err)
		require.Equal(t, "tk_active", tk.Value)
	})
}

func TestStoreTokenCreatePrunesExcess(t *testing.T) {
	forEachStoreBackend(t, func(t *testing.T, store user.Store) {
		require.Nil(t, store.AddUser("phil", "philhash", user.RoleUser, false))
		u, err := store.User("phil")
		require.Nil(t, err)

		// Create 2 tokens with no pruning
		for i, name := range []string{"tk_a", "tk_b"} {
			_, err = store.CreateToken(u.ID, name, name, time.Now(), netip.MustParseAddr("1.2.3.4"), time.Now().Add(time.Duration(i+1)*time.Hour), 0, false)
			require.Nil(t, err)
		}

		// Create a 3rd token with maxTokenCount=2, which should prune tk_a (earliest expiry)
		_, err = store.CreateToken(u.ID, "tk_c", "tk_c", time.Now(), netip.MustParseAddr("1.2.3.4"), time.Now().Add(3*time.Hour), 2, false)
		require.Nil(t, err)

		tokens, err := store.Tokens(u.ID)
		require.Nil(t, err)
		require.Equal(t, 2, len(tokens))

		// tk_a should be removed (earliest expiry)
		_, err = store.Token(u.ID, "tk_a")
		require.Equal(t, user.ErrTokenNotFound, err)

		// tk_b and tk_c should remain
		_, err = store.Token(u.ID, "tk_b")
		require.Nil(t, err)
		_, err = store.Token(u.ID, "tk_c")
		require.Nil(t, err)
	})
}

func TestStoreTokenUpdateLastAccess(t *testing.T) {
	forEachStoreBackend(t, func(t *testing.T, store user.Store) {
		require.Nil(t, store.AddUser("phil", "philhash", user.RoleUser, false))
		u, err := store.User("phil")
		require.Nil(t, err)

		_, err = store.CreateToken(u.ID, "tk_abc", "label", time.Now(), netip.MustParseAddr("1.2.3.4"), time.Now().Add(time.Hour), 0, false)
		require.Nil(t, err)

		newTime := time.Now().Add(5 * time.Minute)
		newOrigin := netip.MustParseAddr("5.5.5.5")
		require.Nil(t, store.UpdateTokenLastAccess(map[string]*user.TokenUpdate{"tk_abc": {LastAccess: newTime, LastOrigin: newOrigin}}))

		tk, err := store.Token(u.ID, "tk_abc")
		require.Nil(t, err)
		require.Equal(t, newTime.Unix(), tk.LastAccess.Unix())
		require.Equal(t, newOrigin, tk.LastOrigin)
	})
}

func TestStoreAllowAccess(t *testing.T) {
	forEachStoreBackend(t, func(t *testing.T, store user.Store) {
		require.Nil(t, store.AddUser("phil", "philhash", user.RoleUser, false))

		require.Nil(t, store.AllowAccess("phil", "mytopic", true, true, "", false))
		grants, err := store.Grants("phil")
		require.Nil(t, err)
		require.Len(t, grants, 1)
		require.Equal(t, "mytopic", grants[0].TopicPattern)
		require.True(t, grants[0].Permission.IsReadWrite())
	})
}

func TestStoreAllowAccessReadOnly(t *testing.T) {
	forEachStoreBackend(t, func(t *testing.T, store user.Store) {
		require.Nil(t, store.AddUser("phil", "philhash", user.RoleUser, false))

		require.Nil(t, store.AllowAccess("phil", "announcements", true, false, "", false))
		grants, err := store.Grants("phil")
		require.Nil(t, err)
		require.Len(t, grants, 1)
		require.True(t, grants[0].Permission.IsRead())
		require.False(t, grants[0].Permission.IsWrite())
	})
}

func TestStoreResetAccess(t *testing.T) {
	forEachStoreBackend(t, func(t *testing.T, store user.Store) {
		require.Nil(t, store.AddUser("phil", "philhash", user.RoleUser, false))
		require.Nil(t, store.AllowAccess("phil", "topic1", true, true, "", false))
		require.Nil(t, store.AllowAccess("phil", "topic2", true, false, "", false))

		grants, err := store.Grants("phil")
		require.Nil(t, err)
		require.Len(t, grants, 2)

		require.Nil(t, store.ResetAccess("phil", "topic1"))
		grants, err = store.Grants("phil")
		require.Nil(t, err)
		require.Len(t, grants, 1)
		require.Equal(t, "topic2", grants[0].TopicPattern)
	})
}

func TestStoreResetAccessAll(t *testing.T) {
	forEachStoreBackend(t, func(t *testing.T, store user.Store) {
		require.Nil(t, store.AddUser("phil", "philhash", user.RoleUser, false))
		require.Nil(t, store.AllowAccess("phil", "topic1", true, true, "", false))
		require.Nil(t, store.AllowAccess("phil", "topic2", true, false, "", false))

		require.Nil(t, store.ResetAccess("phil", ""))
		grants, err := store.Grants("phil")
		require.Nil(t, err)
		require.Len(t, grants, 0)
	})
}

func TestStoreAuthorizeTopicAccess(t *testing.T) {
	forEachStoreBackend(t, func(t *testing.T, store user.Store) {
		require.Nil(t, store.AddUser("phil", "philhash", user.RoleUser, false))
		require.Nil(t, store.AllowAccess("phil", "mytopic", true, true, "", false))

		read, write, found, err := store.AuthorizeTopicAccess("phil", "mytopic")
		require.Nil(t, err)
		require.True(t, found)
		require.True(t, read)
		require.True(t, write)
	})
}

func TestStoreAuthorizeTopicAccessNotFound(t *testing.T) {
	forEachStoreBackend(t, func(t *testing.T, store user.Store) {
		require.Nil(t, store.AddUser("phil", "philhash", user.RoleUser, false))

		_, _, found, err := store.AuthorizeTopicAccess("phil", "other")
		require.Nil(t, err)
		require.False(t, found)
	})
}

func TestStoreAuthorizeTopicAccessDenyAll(t *testing.T) {
	forEachStoreBackend(t, func(t *testing.T, store user.Store) {
		require.Nil(t, store.AddUser("phil", "philhash", user.RoleUser, false))
		require.Nil(t, store.AllowAccess("phil", "secret", false, false, "", false))

		read, write, found, err := store.AuthorizeTopicAccess("phil", "secret")
		require.Nil(t, err)
		require.True(t, found)
		require.False(t, read)
		require.False(t, write)
	})
}

func TestStoreReservations(t *testing.T) {
	forEachStoreBackend(t, func(t *testing.T, store user.Store) {
		require.Nil(t, store.AddUser("phil", "philhash", user.RoleUser, false))
		require.Nil(t, store.AllowAccess("phil", "mytopic", true, true, "phil", false))
		require.Nil(t, store.AllowAccess(user.Everyone, "mytopic", true, false, "phil", false))

		reservations, err := store.Reservations("phil")
		require.Nil(t, err)
		require.Len(t, reservations, 1)
		require.Equal(t, "mytopic", reservations[0].Topic)
		require.True(t, reservations[0].Owner.IsReadWrite())
		require.True(t, reservations[0].Everyone.IsRead())
		require.False(t, reservations[0].Everyone.IsWrite())
	})
}

func TestStoreReservationsCount(t *testing.T) {
	forEachStoreBackend(t, func(t *testing.T, store user.Store) {
		require.Nil(t, store.AddUser("phil", "philhash", user.RoleUser, false))
		require.Nil(t, store.AllowAccess("phil", "topic1", true, true, "phil", false))
		require.Nil(t, store.AllowAccess("phil", "topic2", true, true, "phil", false))

		count, err := store.ReservationsCount("phil")
		require.Nil(t, err)
		require.Equal(t, int64(2), count)
	})
}

func TestStoreHasReservation(t *testing.T) {
	forEachStoreBackend(t, func(t *testing.T, store user.Store) {
		require.Nil(t, store.AddUser("phil", "philhash", user.RoleUser, false))
		require.Nil(t, store.AllowAccess("phil", "mytopic", true, true, "phil", false))

		has, err := store.HasReservation("phil", "mytopic")
		require.Nil(t, err)
		require.True(t, has)

		has, err = store.HasReservation("phil", "other")
		require.Nil(t, err)
		require.False(t, has)
	})
}

func TestStoreReservationOwner(t *testing.T) {
	forEachStoreBackend(t, func(t *testing.T, store user.Store) {
		require.Nil(t, store.AddUser("phil", "philhash", user.RoleUser, false))
		require.Nil(t, store.AllowAccess("phil", "mytopic", true, true, "phil", false))

		owner, err := store.ReservationOwner("mytopic")
		require.Nil(t, err)
		require.NotEmpty(t, owner) // Returns the user ID

		owner, err = store.ReservationOwner("unowned")
		require.Nil(t, err)
		require.Empty(t, owner)
	})
}

func TestStoreTiers(t *testing.T) {
	forEachStoreBackend(t, func(t *testing.T, store user.Store) {
		tier := &user.Tier{
			ID:                       "ti_test",
			Code:                     "pro",
			Name:                     "Pro",
			MessageLimit:             5000,
			MessageExpiryDuration:    24 * time.Hour,
			EmailLimit:               100,
			CallLimit:                10,
			ReservationLimit:         20,
			AttachmentFileSizeLimit:  10 * 1024 * 1024,
			AttachmentTotalSizeLimit: 100 * 1024 * 1024,
			AttachmentExpiryDuration: 48 * time.Hour,
			AttachmentBandwidthLimit: 500 * 1024 * 1024,
		}
		require.Nil(t, store.AddTier(tier))

		// Get by code
		t2, err := store.Tier("pro")
		require.Nil(t, err)
		require.Equal(t, "ti_test", t2.ID)
		require.Equal(t, "pro", t2.Code)
		require.Equal(t, "Pro", t2.Name)
		require.Equal(t, int64(5000), t2.MessageLimit)
		require.Equal(t, int64(100), t2.EmailLimit)
		require.Equal(t, int64(10), t2.CallLimit)
		require.Equal(t, int64(20), t2.ReservationLimit)

		// List all tiers
		tiers, err := store.Tiers()
		require.Nil(t, err)
		require.Len(t, tiers, 1)
		require.Equal(t, "pro", tiers[0].Code)
	})
}

func TestStoreTierUpdate(t *testing.T) {
	forEachStoreBackend(t, func(t *testing.T, store user.Store) {
		tier := &user.Tier{
			ID:   "ti_test",
			Code: "pro",
			Name: "Pro",
		}
		require.Nil(t, store.AddTier(tier))

		tier.Name = "Professional"
		tier.MessageLimit = 9999
		require.Nil(t, store.UpdateTier(tier))

		t2, err := store.Tier("pro")
		require.Nil(t, err)
		require.Equal(t, "Professional", t2.Name)
		require.Equal(t, int64(9999), t2.MessageLimit)
	})
}

func TestStoreTierRemove(t *testing.T) {
	forEachStoreBackend(t, func(t *testing.T, store user.Store) {
		tier := &user.Tier{
			ID:   "ti_test",
			Code: "pro",
			Name: "Pro",
		}
		require.Nil(t, store.AddTier(tier))

		t2, err := store.Tier("pro")
		require.Nil(t, err)
		require.Equal(t, "pro", t2.Code)

		require.Nil(t, store.RemoveTier("pro"))
		_, err = store.Tier("pro")
		require.Equal(t, user.ErrTierNotFound, err)
	})
}

func TestStoreTierByStripePrice(t *testing.T) {
	forEachStoreBackend(t, func(t *testing.T, store user.Store) {
		tier := &user.Tier{
			ID:                   "ti_test",
			Code:                 "pro",
			Name:                 "Pro",
			StripeMonthlyPriceID: "price_monthly",
			StripeYearlyPriceID:  "price_yearly",
		}
		require.Nil(t, store.AddTier(tier))

		t2, err := store.TierByStripePrice("price_monthly")
		require.Nil(t, err)
		require.Equal(t, "pro", t2.Code)

		t3, err := store.TierByStripePrice("price_yearly")
		require.Nil(t, err)
		require.Equal(t, "pro", t3.Code)
	})
}

func TestStoreChangeTier(t *testing.T) {
	forEachStoreBackend(t, func(t *testing.T, store user.Store) {
		tier := &user.Tier{
			ID:   "ti_test",
			Code: "pro",
			Name: "Pro",
		}
		require.Nil(t, store.AddTier(tier))
		require.Nil(t, store.AddUser("phil", "philhash", user.RoleUser, false))
		require.Nil(t, store.ChangeTier("phil", "pro"))

		u, err := store.User("phil")
		require.Nil(t, err)
		require.NotNil(t, u.Tier)
		require.Equal(t, "pro", u.Tier.Code)
	})
}

func TestStorePhoneNumbers(t *testing.T) {
	forEachStoreBackend(t, func(t *testing.T, store user.Store) {
		require.Nil(t, store.AddUser("phil", "philhash", user.RoleUser, false))
		u, err := store.User("phil")
		require.Nil(t, err)

		require.Nil(t, store.AddPhoneNumber(u.ID, "+1234567890"))
		require.Nil(t, store.AddPhoneNumber(u.ID, "+0987654321"))

		numbers, err := store.PhoneNumbers(u.ID)
		require.Nil(t, err)
		require.Len(t, numbers, 2)

		require.Nil(t, store.RemovePhoneNumber(u.ID, "+1234567890"))
		numbers, err = store.PhoneNumbers(u.ID)
		require.Nil(t, err)
		require.Len(t, numbers, 1)
		require.Equal(t, "+0987654321", numbers[0])
	})
}

func TestStoreChangeSettings(t *testing.T) {
	forEachStoreBackend(t, func(t *testing.T, store user.Store) {
		require.Nil(t, store.AddUser("phil", "philhash", user.RoleUser, false))
		u, err := store.User("phil")
		require.Nil(t, err)

		lang := "de"
		prefs := &user.Prefs{Language: &lang}
		require.Nil(t, store.ChangeSettings(u.ID, prefs))

		u2, err := store.User("phil")
		require.Nil(t, err)
		require.NotNil(t, u2.Prefs)
		require.Equal(t, "de", *u2.Prefs.Language)
	})
}

func TestStoreChangeBilling(t *testing.T) {
	forEachStoreBackend(t, func(t *testing.T, store user.Store) {
		require.Nil(t, store.AddUser("phil", "philhash", user.RoleUser, false))

		billing := &user.Billing{
			StripeCustomerID:     "cus_123",
			StripeSubscriptionID: "sub_456",
		}
		require.Nil(t, store.ChangeBilling("phil", billing))

		u, err := store.User("phil")
		require.Nil(t, err)
		require.Equal(t, "cus_123", u.Billing.StripeCustomerID)
		require.Equal(t, "sub_456", u.Billing.StripeSubscriptionID)
	})
}

func TestStoreUpdateStats(t *testing.T) {
	forEachStoreBackend(t, func(t *testing.T, store user.Store) {
		require.Nil(t, store.AddUser("phil", "philhash", user.RoleUser, false))
		u, err := store.User("phil")
		require.Nil(t, err)

		stats := &user.Stats{Messages: 42, Emails: 3, Calls: 1}
		require.Nil(t, store.UpdateStats(map[string]*user.Stats{u.ID: stats}))

		u2, err := store.User("phil")
		require.Nil(t, err)
		require.Equal(t, int64(42), u2.Stats.Messages)
		require.Equal(t, int64(3), u2.Stats.Emails)
		require.Equal(t, int64(1), u2.Stats.Calls)
	})
}

func TestStoreResetStats(t *testing.T) {
	forEachStoreBackend(t, func(t *testing.T, store user.Store) {
		require.Nil(t, store.AddUser("phil", "philhash", user.RoleUser, false))
		u, err := store.User("phil")
		require.Nil(t, err)

		require.Nil(t, store.UpdateStats(map[string]*user.Stats{u.ID: {Messages: 42, Emails: 3, Calls: 1}}))
		require.Nil(t, store.ResetStats())

		u2, err := store.User("phil")
		require.Nil(t, err)
		require.Equal(t, int64(0), u2.Stats.Messages)
		require.Equal(t, int64(0), u2.Stats.Emails)
		require.Equal(t, int64(0), u2.Stats.Calls)
	})
}

func TestStoreMarkUserRemoved(t *testing.T) {
	forEachStoreBackend(t, func(t *testing.T, store user.Store) {
		require.Nil(t, store.AddUser("phil", "philhash", user.RoleUser, false))
		u, err := store.User("phil")
		require.Nil(t, err)

		require.Nil(t, store.MarkUserRemoved(u.ID))

		u2, err := store.User("phil")
		require.Nil(t, err)
		require.True(t, u2.Deleted)
	})
}

func TestStoreRemoveDeletedUsers(t *testing.T) {
	forEachStoreBackend(t, func(t *testing.T, store user.Store) {
		require.Nil(t, store.AddUser("phil", "philhash", user.RoleUser, false))
		u, err := store.User("phil")
		require.Nil(t, err)

		require.Nil(t, store.MarkUserRemoved(u.ID))

		// RemoveDeletedUsers only removes users past the hard-delete duration (7 days).
		// Immediately after marking, the user should still exist.
		require.Nil(t, store.RemoveDeletedUsers())
		u2, err := store.User("phil")
		require.Nil(t, err)
		require.True(t, u2.Deleted)
	})
}

func TestStoreAllGrants(t *testing.T) {
	forEachStoreBackend(t, func(t *testing.T, store user.Store) {
		require.Nil(t, store.AddUser("phil", "philhash", user.RoleUser, false))
		require.Nil(t, store.AddUser("ben", "benhash", user.RoleUser, false))
		phil, err := store.User("phil")
		require.Nil(t, err)
		ben, err := store.User("ben")
		require.Nil(t, err)

		require.Nil(t, store.AllowAccess("phil", "topic1", true, true, "", false))
		require.Nil(t, store.AllowAccess("ben", "topic2", true, false, "", false))

		grants, err := store.AllGrants()
		require.Nil(t, err)
		require.Contains(t, grants, phil.ID)
		require.Contains(t, grants, ben.ID)
	})
}

func TestStoreOtherAccessCount(t *testing.T) {
	forEachStoreBackend(t, func(t *testing.T, store user.Store) {
		require.Nil(t, store.AddUser("phil", "philhash", user.RoleUser, false))
		require.Nil(t, store.AddUser("ben", "benhash", user.RoleUser, false))
		require.Nil(t, store.AllowAccess("ben", "mytopic", true, true, "ben", false))

		count, err := store.OtherAccessCount("phil", "mytopic")
		require.Nil(t, err)
		require.Equal(t, 1, count)
	})
}