// Package user_test 验证 user-service 用户主数据、短号和靓号用例。
package user_test

import (
	"context"
	"strings"
	"testing"
	"time"

	"hyapp/pkg/xerr"
	userdomain "hyapp/services/user-service/internal/domain/user"
	userservice "hyapp/services/user-service/internal/service/user"
	"hyapp/services/user-service/internal/testutil/mysqltest"
)

type sequenceIDGenerator struct {
	// values 是测试预设 user_id 序列。
	values []int64
	// index 指向当前返回值。
	index int
}

func (g *sequenceIDGenerator) NewInt64() int64 {
	// 到达末尾后保持最后一个值，便于测试重试行为。
	value := g.values[g.index]
	if g.index < len(g.values)-1 {
		g.index++
	}

	return value
}

type sequenceDisplayUserIDAllocator struct {
	// values 是测试预设短号候选。
	values []string
}

func (a sequenceDisplayUserIDAllocator) NextDisplayUserID(_ int64, attempt int) string {
	if attempt >= len(a.values) {
		// 超出候选数量后复用最后一个值。
		return a.values[len(a.values)-1]
	}

	return a.values[attempt]
}

//go:fix inline
func strptr(value string) *string {
	return new(value)
}

func containsCountryCode(countries []userdomain.Country, code string) bool {
	for _, country := range countries {
		if country.CountryCode == code {
			return true
		}
	}

	return false
}

func mustResolveRegionByCountry(t *testing.T, repository *mysqltest.Repository, country string) userdomain.Region {
	t.Helper()
	region, ok, err := repository.ResolveActiveRegionByCountry(context.Background(), country)
	if err != nil {
		t.Fatalf("resolve region for country %s failed: %v", country, err)
	}
	if !ok {
		t.Fatalf("country %s should have seeded region mapping", country)
	}

	return region
}

func completedUser(user userdomain.User) userdomain.User {
	// 普通资料编辑和国家修改测试默认模拟已完成注册资料的用户；未完成场景用专门用例覆盖。
	user.ProfileCompleted = true
	if user.ProfileCompletedAtMs == 0 {
		user.ProfileCompletedAtMs = 1
	}
	user.OnboardingStatus = userdomain.OnboardingStatusCompleted
	return user
}

func newUserService(repository *mysqltest.Repository, options ...userservice.Option) *userservice.Service {
	base := []userservice.Option{
		userservice.WithIdentityRepository(repository),
		userservice.WithCountryRegionRepository(repository),
		userservice.WithCountryAdminRepository(repository),
		userservice.WithRegionAdminRepository(repository),
		userservice.WithRegionRebuildRepository(repository),
		userservice.WithDeviceRepository(repository),
	}
	return userservice.New(repository, append(base, options...)...)
}

func seedCountry(t *testing.T, repository *mysqltest.Repository, code string) userdomain.Country {
	t.Helper()
	if country, ok, err := repository.ResolveEnabledCountryByCode(context.Background(), code); err != nil {
		t.Fatalf("resolve country %s failed: %v", code, err)
	} else if ok {
		return country
	}
	return repository.PutCountry(userdomain.Country{
		CountryName:        code + " Name",
		CountryCode:        code,
		CountryDisplayName: code + " Display",
		Enabled:            true,
	})
}

func seedRegion(t *testing.T, repository *mysqltest.Repository, code string, countries []string) userdomain.Region {
	t.Helper()
	return repository.PutRegion(userdomain.Region{
		RegionCode:      code,
		Name:            code + " Region",
		Status:          userdomain.RegionStatusActive,
		Countries:       countries,
		CreatedByUserID: 1,
		UpdatedByUserID: 1,
	})
}

// TestGetUserUsesRepository 验证 user-service 查询用例只依赖 repository 接口。
func TestGetUserUsesRepository(t *testing.T) {
	repository := mysqltest.NewRepository(t)
	// PutUser 是测试辅助入口，直接准备用户主记录。
	repository.PutUser(completedUser(userdomain.User{UserID: 10001, CurrentDisplayUserID: "100001", Status: userdomain.StatusActive}))

	svc := newUserService(repository)
	user, err := svc.GetUser(context.Background(), 10001)
	if err != nil {
		t.Fatalf("GetUser failed: %v", err)
	}

	if user.UserID != 10001 || user.Status != userdomain.StatusActive {
		t.Fatalf("unexpected user: %+v", user)
	}
}

func TestBusinessUserLookupRestrictsSceneKeywordAndInactiveUsers(t *testing.T) {
	repository := mysqltest.NewRepository(t)
	repository.PutUser(completedUser(userdomain.User{
		UserID:               700001,
		CurrentDisplayUserID: "910001",
		Username:             "Alice Star",
		Avatar:               "https://cdn.example/alice.png",
		RegionID:             1001,
		Status:               userdomain.StatusActive,
	}))
	repository.PutUser(completedUser(userdomain.User{
		UserID:               700002,
		CurrentDisplayUserID: "910002",
		Username:             "Alice Disabled",
		RegionID:             1001,
		Status:               userdomain.StatusDisabled,
	}))
	svc := newUserService(repository)

	byDisplayID, err := svc.BusinessUserLookup(context.Background(), userservice.BusinessSceneManagerResourceGrant, "910001", 99)
	if err != nil {
		t.Fatalf("BusinessUserLookup by display id failed: %v", err)
	}
	if len(byDisplayID) != 1 || byDisplayID[0].UserID != 700001 || byDisplayID[0].DisplayUserID != "910001" || byDisplayID[0].Status != userdomain.StatusActive {
		t.Fatalf("display id lookup mismatch: %+v", byDisplayID)
	}

	byNickname, err := svc.BusinessUserLookup(context.Background(), userservice.BusinessSceneManagerResourceGrant, "Alice", 20)
	if err != nil {
		t.Fatalf("BusinessUserLookup by nickname failed: %v", err)
	}
	if len(byNickname) != 1 || byNickname[0].UserID != 700001 {
		t.Fatalf("nickname lookup must exclude inactive users: %+v", byNickname)
	}

	if _, err := svc.BusinessUserLookup(context.Background(), "unknown_scene", "Alice", 20); !xerr.IsCode(err, xerr.InvalidArgument) {
		t.Fatalf("expected INVALID_ARGUMENT for unknown scene, got %v", err)
	}
	if _, err := svc.BusinessUserLookup(context.Background(), userservice.BusinessSceneManagerResourceGrant, "A", 20); !xerr.IsCode(err, xerr.InvalidArgument) {
		t.Fatalf("expected INVALID_ARGUMENT for short keyword, got %v", err)
	}
}

func TestGetMyProfileStatsReadsCounterTable(t *testing.T) {
	repository := mysqltest.NewRepository(t)
	svc := newUserService(repository)

	stats, err := svc.GetMyProfileStats(context.Background(), 10001)
	if err != nil {
		t.Fatalf("GetMyProfileStats default failed: %v", err)
	}
	if stats.UserID != 10001 || stats.VisitorsCount != 0 || stats.FollowingCount != 0 || stats.FriendsCount != 0 {
		t.Fatalf("missing stats should return zero projection: %+v", stats)
	}

	_, err = repository.RawDB().Exec(`
		INSERT INTO user_profile_stats (
			app_code, user_id, visitors_count, following_count, friends_count, updated_at_ms
		) VALUES ('lalu', 10001, 12, 34, 56, 7000)`)
	if err != nil {
		t.Fatalf("seed profile stats failed: %v", err)
	}

	stats, err = svc.GetMyProfileStats(context.Background(), 10001)
	if err != nil {
		t.Fatalf("GetMyProfileStats failed: %v", err)
	}
	if stats.VisitorsCount != 12 || stats.FollowingCount != 34 || stats.FriendsCount != 56 || stats.UpdatedAtMs != 7000 {
		t.Fatalf("stats mismatch: %+v", stats)
	}
}

func TestSocialRelationsUseReadModelsAndIdempotentEdges(t *testing.T) {
	repository := mysqltest.NewRepository(t)
	for _, seeded := range []userdomain.User{
		{UserID: 10001, CurrentDisplayUserID: "100001", Status: userdomain.StatusActive},
		{UserID: 10002, CurrentDisplayUserID: "100002", Status: userdomain.StatusActive},
		{UserID: 10003, CurrentDisplayUserID: "100003", Status: userdomain.StatusActive},
	} {
		repository.PutUser(completedUser(seeded))
	}
	now := time.UnixMilli(9000)
	svc := newUserService(repository, userservice.WithClock(func() time.Time { return now }))

	if _, _, err := svc.RecordProfileVisit(context.Background(), 10001, 10001); !xerr.IsCode(err, xerr.InvalidArgument) {
		t.Fatalf("self visit should be rejected, got %v", err)
	}
	recorded, stats, err := svc.RecordProfileVisit(context.Background(), 10001, 10002)
	if err != nil || !recorded || stats.VisitorsCount != 1 {
		t.Fatalf("first visit mismatch: recorded=%v stats=%+v err=%v", recorded, stats, err)
	}
	recorded, stats, err = svc.RecordProfileVisit(context.Background(), 10001, 10002)
	if err != nil || recorded || stats.VisitorsCount != 1 {
		t.Fatalf("repeat visit should not increase unique visitors: recorded=%v stats=%+v err=%v", recorded, stats, err)
	}
	visitors, total, err := svc.ListProfileVisitors(context.Background(), 10002, 1, 20)
	if err != nil || total != 1 || len(visitors) != 1 || visitors[0].VisitCount != 2 || visitors[0].VisitorUserID != 10001 {
		t.Fatalf("visitors mismatch: visitors=%+v total=%d err=%v", visitors, total, err)
	}

	now = time.UnixMilli(8000)
	stats, err = svc.FollowUser(context.Background(), 10001, 10002)
	if err != nil || stats.FollowingCount != 1 {
		t.Fatalf("follow failed: stats=%+v err=%v", stats, err)
	}
	stats, err = svc.FollowUser(context.Background(), 10001, 10002)
	if err != nil || stats.FollowingCount != 1 {
		t.Fatalf("repeat follow should be idempotent: stats=%+v err=%v", stats, err)
	}
	now = time.UnixMilli(9000)
	stats, err = svc.FollowUser(context.Background(), 10001, 10003)
	if err != nil || stats.FollowingCount != 2 {
		t.Fatalf("second follow failed: stats=%+v err=%v", stats, err)
	}
	following, total, err := svc.ListFollowing(context.Background(), 10001, 1, 20, 0, 0)
	if err != nil || total != 2 || len(following) != 2 || following[0].FolloweeUserID != 10003 || following[1].FolloweeUserID != 10002 {
		t.Fatalf("following mismatch: following=%+v total=%d err=%v", following, total, err)
	}
	following, total, err = svc.ListFollowing(context.Background(), 10001, 1, 20, 9000, 10003)
	if err != nil || total != 2 || len(following) != 1 || following[0].FolloweeUserID != 10002 {
		t.Fatalf("following cursor mismatch: following=%+v total=%d err=%v", following, total, err)
	}
	stats, err = svc.UnfollowUser(context.Background(), 10001, 10002)
	if err != nil || stats.FollowingCount != 1 {
		t.Fatalf("unfollow failed: stats=%+v err=%v", stats, err)
	}
	stats, err = svc.UnfollowUser(context.Background(), 10001, 10002)
	if err != nil || stats.FollowingCount != 1 {
		t.Fatalf("repeat unfollow should stay unchanged: stats=%+v err=%v", stats, err)
	}

	application, alreadyFriends, err := svc.ApplyFriend(context.Background(), 10001, 10002)
	if err != nil || alreadyFriends || application.Status != userdomain.FriendApplicationStatusPending {
		t.Fatalf("apply friend mismatch: app=%+v already=%v err=%v", application, alreadyFriends, err)
	}
	friends, total, err := svc.ListFriends(context.Background(), 10001, 1, 20, 0, 0)
	if err != nil || total != 0 || len(friends) != 0 {
		t.Fatalf("friend application must not create friendship before accept: friends=%+v total=%d err=%v", friends, total, err)
	}
	applications, total, err := svc.ListFriendApplications(context.Background(), 10002, "incoming", 1, 20)
	if err != nil || total != 1 || len(applications) != 1 || applications[0].RequesterUserID != 10001 {
		t.Fatalf("incoming application mismatch: applications=%+v total=%d err=%v", applications, total, err)
	}
	friend, err := svc.AcceptFriendApplication(context.Background(), 10002, 10001)
	if err != nil || friend.UserID != 10002 || friend.FriendUserID != 10001 {
		t.Fatalf("accept friend failed: friend=%+v err=%v", friend, err)
	}
	friend, err = svc.AcceptFriendApplication(context.Background(), 10002, 10001)
	if err != nil || friend.UserID != 10002 || friend.FriendUserID != 10001 {
		t.Fatalf("repeat accept should be idempotent: friend=%+v err=%v", friend, err)
	}
	for _, userID := range []int64{10001, 10002} {
		friends, total, err = svc.ListFriends(context.Background(), userID, 1, 20, 0, 0)
		if err != nil || total != 1 || len(friends) != 1 {
			t.Fatalf("bidirectional friendship missing for user %d: friends=%+v total=%d err=%v", userID, friends, total, err)
		}
		stats, err = svc.GetMyProfileStats(context.Background(), userID)
		if err != nil || stats.FriendsCount != 1 {
			t.Fatalf("friend count mismatch for user %d: stats=%+v err=%v", userID, stats, err)
		}
	}
	deleted, err := svc.DeleteFriend(context.Background(), 10001, 10002)
	if err != nil || !deleted {
		t.Fatalf("delete friend failed: deleted=%v err=%v", deleted, err)
	}
	deleted, err = svc.DeleteFriend(context.Background(), 10001, 10002)
	if err != nil || deleted {
		t.Fatalf("repeat delete should be idempotent false: deleted=%v err=%v", deleted, err)
	}
	for _, userID := range []int64{10001, 10002} {
		friends, total, err = svc.ListFriends(context.Background(), userID, 1, 20, 0, 0)
		if err != nil || total != 0 || len(friends) != 0 {
			t.Fatalf("friend should be removed for user %d: friends=%+v total=%d err=%v", userID, friends, total, err)
		}
		stats, err = svc.GetMyProfileStats(context.Background(), userID)
		if err != nil || stats.FriendsCount != 0 {
			t.Fatalf("friend count should be decremented for user %d: stats=%+v err=%v", userID, stats, err)
		}
	}
}

func TestListUserIDsUsesCursorAndTargetFilters(t *testing.T) {
	repository := mysqltest.NewRepository(t)
	for _, user := range []userdomain.User{
		{UserID: 10001, CurrentDisplayUserID: "100001", Status: userdomain.StatusActive, Country: "US", RegionID: 7},
		{UserID: 10002, CurrentDisplayUserID: "100002", Status: userdomain.StatusActive, Country: "SG", RegionID: 8},
		{UserID: 10003, CurrentDisplayUserID: "100003", Status: userdomain.StatusActive, Country: "US", RegionID: 7},
		{UserID: 10004, CurrentDisplayUserID: "100004", Status: userdomain.StatusDisabled, Country: "US", RegionID: 7},
	} {
		repository.PutUser(completedUser(user))
	}
	svc := newUserService(repository)

	userIDs, next, done, err := svc.ListUserIDs(context.Background(), userdomain.UserIDPageFilter{TargetScope: userdomain.UserIDTargetAllActiveUsers, PageSize: 2})
	if err != nil || done || next != 10002 || len(userIDs) != 2 || userIDs[0] != 10001 || userIDs[1] != 10002 {
		t.Fatalf("all active first page mismatch: ids=%v next=%d done=%v err=%v", userIDs, next, done, err)
	}
	userIDs, next, done, err = svc.ListUserIDs(context.Background(), userdomain.UserIDPageFilter{TargetScope: userdomain.UserIDTargetRegion, RegionID: 7, CursorUserID: next, PageSize: 10})
	if err != nil || !done || next != 10003 || len(userIDs) != 1 || userIDs[0] != 10003 {
		t.Fatalf("region page mismatch: ids=%v next=%d done=%v err=%v", userIDs, next, done, err)
	}
	userIDs, next, done, err = svc.ListUserIDs(context.Background(), userdomain.UserIDPageFilter{TargetScope: userdomain.UserIDTargetCountry, Country: " us ", PageSize: 10})
	if err != nil || !done || next != 10003 || len(userIDs) != 2 || userIDs[0] != 10001 || userIDs[1] != 10003 {
		t.Fatalf("country page mismatch: ids=%v next=%d done=%v err=%v", userIDs, next, done, err)
	}
	if _, _, _, err := svc.ListUserIDs(context.Background(), userdomain.UserIDPageFilter{TargetScope: userdomain.UserIDTargetCountry, Country: "1"}); !xerr.IsCode(err, xerr.InvalidArgument) {
		t.Fatalf("invalid country should fail, got %v", err)
	}
}

func TestUpdateUserProfile(t *testing.T) {
	repository := mysqltest.NewRepository(t)
	repository.PutUser(completedUser(userdomain.User{
		UserID:               10001,
		CurrentDisplayUserID: "100001",
		Username:             "old-name",
		Avatar:               "old-avatar",
		BirthDate:            "1999-01-01",
		Status:               userdomain.StatusActive,
	}))
	now := time.UnixMilli(2000)
	svc := newUserService(repository, userservice.WithClock(func() time.Time { return now }))

	user, err := svc.UpdateUserProfile(context.Background(), 10001, new(" new-name "), new(" https://cdn.example/a.png "), new(" male "), new("2000-01-02"))
	if err != nil {
		t.Fatalf("UpdateUserProfile failed: %v", err)
	}
	if user.Username != "new-name" || user.Avatar != "https://cdn.example/a.png" || user.Gender != "male" || user.BirthDate != "2000-01-02" || user.UpdatedAtMs != 2000 {
		t.Fatalf("profile update mismatch: %+v", user)
	}

	_, err = svc.UpdateUserProfile(context.Background(), 10001, nil, nil, nil, new("2000/01/02"))
	if !xerr.IsCode(err, xerr.InvalidArgument) {
		t.Fatalf("expected invalid birth format, got %v", err)
	}
	_, err = svc.UpdateUserProfile(context.Background(), 10001, nil, nil, nil, new("0001-01-01"))
	if !xerr.IsCode(err, xerr.InvalidArgument) {
		// Go 零值日期虽然能被 time.Parse 接受，但 MySQL DATE 严格模式不能写入，必须在 service 层拒绝。
		t.Fatalf("expected invalid birth range, got %v", err)
	}

	invalidCases := []struct {
		name     string
		username *string
		avatar   *string
		gender   *string
		birth    *string
	}{
		{
			name:     "empty username",
			username: new("   "),
		},
		{
			name:     "too long username",
			username: new(strings.Repeat("a", userdomain.ProfileUsernameMaxRunes+1)),
		},
		{
			name:   "too long avatar",
			avatar: new("https://cdn.example/" + strings.Repeat("a", userdomain.ProfileAvatarMaxRunes)),
		},
		{
			name:   "non http avatar",
			avatar: new("ftp://cdn.example/a.png"),
		},
		{
			name:   "empty gender",
			gender: new("   "),
		},
	}
	for _, tc := range invalidCases {
		t.Run(tc.name, func(t *testing.T) {
			_, err := svc.UpdateUserProfile(context.Background(), 10001, tc.username, tc.avatar, tc.gender, tc.birth)
			if !xerr.IsCode(err, xerr.InvalidArgument) {
				t.Fatalf("expected invalid profile update, got %v", err)
			}
		})
	}

	user, err = svc.UpdateUserProfile(context.Background(), 10001, nil, new(""), nil, new(""))
	if err != nil {
		t.Fatalf("clearing optional profile fields failed: %v", err)
	}
	if user.Avatar != "" || user.BirthDate != "" {
		t.Fatalf("optional profile fields should clear: %+v", user)
	}
}

func TestBindAndDeletePushToken(t *testing.T) {
	ctx := context.Background()
	repository := mysqltest.NewRepository(t)
	current := time.UnixMilli(1700000000000)
	svc := newUserService(repository, userservice.WithClock(func() time.Time { return current }))
	repository.PutUser(completedUser(userdomain.User{
		UserID:               10001,
		DefaultDisplayUserID: "100001",
		CurrentDisplayUserID: "100001",
		Status:               userdomain.StatusActive,
	}))

	updatedAt, err := svc.BindPushToken(ctx, 10001, " dev-1 ", " push-token-1 ", "", " android ", "1.2.3", "en-US", "America/Los_Angeles", "req-push-bind")
	if err != nil {
		t.Fatalf("BindPushToken failed: %v", err)
	}
	if updatedAt != 1700000000000 {
		t.Fatalf("updated_at mismatch: got %d", updatedAt)
	}

	deleted, deletedAt, err := svc.DeletePushToken(ctx, 10001, "dev-1", "push-token-1", "req-push-delete")
	if err != nil {
		t.Fatalf("DeletePushToken failed: %v", err)
	}
	if !deleted || deletedAt != 1700000000000 {
		t.Fatalf("delete response mismatch: deleted=%v deletedAt=%d", deleted, deletedAt)
	}
}

func TestBindPushTokenValidation(t *testing.T) {
	ctx := context.Background()
	repository := mysqltest.NewRepository(t)
	svc := newUserService(repository)
	repository.PutUser(completedUser(userdomain.User{
		UserID:               10001,
		DefaultDisplayUserID: "100001",
		CurrentDisplayUserID: "100001",
		Status:               userdomain.StatusActive,
	}))

	tests := []struct {
		name     string
		deviceID string
		token    string
		platform string
		wantCode xerr.Code
	}{
		{name: "device", deviceID: "", token: "push-1", platform: "android", wantCode: xerr.InvalidArgument},
		{name: "token", deviceID: "dev-1", token: "", platform: "android", wantCode: xerr.InvalidArgument},
		{name: "platform", deviceID: "dev-1", token: "push-1", platform: "web", wantCode: xerr.InvalidArgument},
	}
	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			_, err := svc.BindPushToken(ctx, 10001, test.deviceID, test.token, "", test.platform, "", "", "", "req-"+test.name)
			if !xerr.IsCode(err, test.wantCode) {
				t.Fatalf("error code mismatch: got %v want %s", err, test.wantCode)
			}
		})
	}
}

func TestCompleteOnboardingWritesProfileRegionAndSkipsCountryCooldown(t *testing.T) {
	// CompleteOnboarding 是注册页原子提交点，首次国家写入不能污染后续国家修改冷却日志。
	ctx := context.Background()
	repository := mysqltest.NewRepository(t)
	seedCountry(t, repository, "SG")
	seedCountry(t, repository, "US")
	region := mustResolveRegionByCountry(t, repository, "SG")
	repository.PutUser(userdomain.User{
		UserID:               10001,
		CurrentDisplayUserID: "100001",
		Status:               userdomain.StatusActive,
	})
	current := time.UnixMilli(1000)
	svc := newUserService(repository,
		userservice.WithClock(func() time.Time { return current }),
		userservice.WithCountryChangeCooldown(time.Hour),
	)

	user, err := svc.CompleteOnboarding(ctx, 10001, " hy ", " https://cdn.example/a.png ", " male ", " sg ", "", "")
	if err != nil {
		t.Fatalf("CompleteOnboarding failed: %v", err)
	}
	if user.Username != "hy" || user.Avatar != "https://cdn.example/a.png" || user.Gender != "male" || user.Country != "SG" || user.RegionID != region.RegionID {
		t.Fatalf("onboarding profile mismatch: %+v", user)
	}
	if !user.ProfileCompleted || user.ProfileCompletedAtMs != 1000 || user.OnboardingStatus != userdomain.OnboardingStatusCompleted {
		t.Fatalf("onboarding completion flags mismatch: %+v", user)
	}

	current = current.Add(10 * time.Minute)
	user, _, err = svc.ChangeUserCountry(ctx, 10001, "US", "req-change-after-onboarding")
	if err != nil {
		t.Fatalf("first country change after onboarding must not be cooled down: %v", err)
	}
	if user.Country != "US" {
		t.Fatalf("country after first change mismatch: %+v", user)
	}
}

func TestCountryWithoutExplicitRegionFallsBackToGlobal(t *testing.T) {
	ctx := context.Background()
	repository := mysqltest.NewRepository(t)
	seedCountry(t, repository, "ZZ")
	repository.PutUser(userdomain.User{
		UserID:               10001,
		CurrentDisplayUserID: "100001",
		Status:               userdomain.StatusActive,
	})
	svc := newUserService(repository)

	region, ok, err := repository.ResolveActiveRegionByCountry(ctx, "ZZ")
	if err != nil {
		t.Fatalf("ResolveActiveRegionByCountry failed: %v", err)
	}
	if !ok || region.RegionID != 0 || region.RegionCode != userdomain.GlobalRegionCode {
		t.Fatalf("country without mapping should resolve to GLOBAL: ok=%t region=%+v", ok, region)
	}

	user, err := svc.CompleteOnboarding(ctx, 10001, "hy", "https://cdn.example/a.png", "male", "ZZ", "", "")
	if err != nil {
		t.Fatalf("CompleteOnboarding failed: %v", err)
	}
	if user.RegionID != 0 || user.RegionCode != userdomain.GlobalRegionCode || user.RegionName != userdomain.GlobalRegionCode {
		t.Fatalf("user should enter GLOBAL region: %+v", user)
	}
}

func TestCompleteOnboardingValidation(t *testing.T) {
	// 必填字段和展示资料格式在 service 层稳定返回 INVALID_ARGUMENT，不能依赖 MySQL 约束报错。
	ctx := context.Background()
	repository := mysqltest.NewRepository(t)
	seedCountry(t, repository, "SG")
	repository.PutUser(completedUser(userdomain.User{UserID: 10001, CurrentDisplayUserID: "100001", Status: userdomain.StatusActive}))
	svc := newUserService(repository)

	cases := []struct {
		name     string
		username string
		avatar   string
		gender   string
		country  string
	}{
		{name: "username", username: " ", avatar: "https://cdn.example/a.png", gender: "male", country: "SG"},
		{name: "avatar", username: "hy", avatar: "", gender: "male", country: "SG"},
		{name: "avatar_url", username: "hy", avatar: "ftp://cdn.example/a.png", gender: "male", country: "SG"},
		{name: "gender", username: "hy", avatar: "https://cdn.example/a.png", gender: "", country: "SG"},
		{name: "gender_too_long", username: "hy", avatar: "https://cdn.example/a.png", gender: strings.Repeat("a", userdomain.ProfileGenderMaxRunes+1), country: "SG"},
		{name: "country", username: "hy", avatar: "https://cdn.example/a.png", gender: "male", country: ""},
		{name: "unknown_country", username: "hy", avatar: "https://cdn.example/a.png", gender: "male", country: "ZZ"},
	}
	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			_, err := svc.CompleteOnboarding(ctx, 10001, tc.username, tc.avatar, tc.gender, tc.country, "", "")
			if !xerr.IsCode(err, xerr.InvalidArgument) {
				t.Fatalf("expected INVALID_ARGUMENT, got %v", err)
			}
		})
	}
}

func TestChangeUserCountryWritesCooldown(t *testing.T) {
	repository := mysqltest.NewRepository(t)
	seedCountry(t, repository, "CN")
	seedCountry(t, repository, "US")
	seedCountry(t, repository, "JP")
	repository.PutUser(completedUser(userdomain.User{UserID: 10001, CurrentDisplayUserID: "100001", Country: "CN", Status: userdomain.StatusActive}))
	current := time.UnixMilli(1000)
	svc := newUserService(repository,
		userservice.WithClock(func() time.Time { return current }),
		userservice.WithCountryChangeCooldown(time.Hour),
	)

	user, nextAllowedAt, err := svc.ChangeUserCountry(context.Background(), 10001, " US ", "req-country-1")
	if err != nil {
		t.Fatalf("ChangeUserCountry failed: %v", err)
	}
	if user.Country != "US" || nextAllowedAt != current.Add(time.Hour).UnixMilli() {
		t.Fatalf("country change mismatch: user=%+v next=%d", user, nextAllowedAt)
	}

	current = current.Add(10 * time.Minute)
	if _, _, err := svc.ChangeUserCountry(context.Background(), 10001, "JP", "req-country-2"); !xerr.IsCode(err, xerr.CountryChangeCooldown) {
		t.Fatalf("expected country cooldown, got %v", err)
	}
	if user, _, err := svc.ChangeUserCountry(context.Background(), 10001, "US", "req-country-same"); err != nil || user.Country != "US" {
		// 相同国家重复提交不写新日志，也不被冷却期阻断。
		t.Fatalf("same country should be idempotent: user=%+v err=%v", user, err)
	}

	current = current.Add(2 * time.Hour)
	user, _, err = svc.ChangeUserCountry(context.Background(), 10001, "JP", "req-country-3")
	if err != nil {
		t.Fatalf("ChangeUserCountry after cooldown failed: %v", err)
	}
	if user.Country != "JP" {
		t.Fatalf("country after cooldown mismatch: %+v", user)
	}
}

func TestProfileMutationsRequireCompletedOnboarding(t *testing.T) {
	// 未完成注册资料时，CompleteOnboarding 是唯一资料写入口；改国家不能提前写日志或消耗冷却。
	ctx := context.Background()
	repository := mysqltest.NewRepository(t)
	seedCountry(t, repository, "CN")
	seedCountry(t, repository, "US")
	repository.PutUser(userdomain.User{UserID: 10001, CurrentDisplayUserID: "100001", Country: "CN", Status: userdomain.StatusActive})
	current := time.UnixMilli(1000)
	svc := newUserService(repository,
		userservice.WithClock(func() time.Time { return current }),
		userservice.WithCountryChangeCooldown(time.Hour),
	)

	if _, err := svc.UpdateUserProfile(ctx, 10001, new("new-name"), nil, nil, nil); !xerr.IsCode(err, xerr.ProfileRequired) {
		t.Fatalf("expected PROFILE_REQUIRED for incomplete profile update, got %v", err)
	}
	if _, _, err := svc.ChangeUserCountry(ctx, 10001, "US", "req-before-onboarding"); !xerr.IsCode(err, xerr.ProfileRequired) {
		t.Fatalf("expected PROFILE_REQUIRED for incomplete country change, got %v", err)
	}

	completed := completedUser(userdomain.User{UserID: 10001, CurrentDisplayUserID: "100001", Country: "CN", Status: userdomain.StatusActive})
	repository.PutUser(completed)
	user, _, err := svc.ChangeUserCountry(ctx, 10001, "US", "req-after-onboarding")
	if err != nil {
		// 如果未完成阶段误写了国家变更日志，这里会被冷却期挡住。
		t.Fatalf("first country change after completing profile should not be cooled down: %v", err)
	}
	if user.Country != "US" {
		t.Fatalf("country after completed profile mismatch: %+v", user)
	}
}

func TestCountryAndRegionAdminValidation(t *testing.T) {
	// user-service 仍负责国家更新归一、元数据校验和区域国家归属校验。
	ctx := context.Background()
	repository := mysqltest.NewRepository(t)
	svc := newUserService(repository)

	aa := repository.PutCountry(userdomain.Country{
		CountryName:        "Alpha Area",
		CountryCode:        "AA",
		CountryDisplayName: "测试国家",
		Enabled:            true,
		SortOrder:          10,
	})
	aa, err := svc.UpdateCountry(ctx, userdomain.UpdateCountryCommand{
		CountryID:          aa.CountryID,
		CountryName:        "Alpha Area",
		ISOAlpha3:          " aaa ",
		ISONumeric:         " 001 ",
		CountryDisplayName: "测试国家",
		PhoneCountryCode:   " +1 ",
		Flag:               "AA",
		SortOrder:          10,
		OperatorUserID:     1,
		RequestID:          "req-update-aa",
	})
	if err != nil {
		t.Fatalf("UpdateCountry AA failed: %v", err)
	}
	if aa.CountryCode != "AA" || aa.ISOAlpha3 != "AAA" || aa.ISONumeric != "001" || aa.PhoneCountryCode != "+1" || !aa.Enabled {
		t.Fatalf("country code should normalize to AA: %+v", aa)
	}
	tla := repository.PutCountry(userdomain.Country{
		CountryName:        "Three Letter Land",
		CountryCode:        "tla",
		CountryDisplayName: "三字码国家",
		Enabled:            true,
		SortOrder:          30,
	})
	if tla.CountryCode != "TLA" {
		t.Fatalf("three-letter canonical country code mismatch: %+v", tla)
	}
	if _, err := svc.UpdateCountry(ctx, userdomain.UpdateCountryCommand{CountryID: aa.CountryID, CountryName: "Bad ISO", ISOAlpha3: "B1D", CountryDisplayName: "Bad ISO", OperatorUserID: 1, RequestID: "req-bad-iso"}); !xerr.IsCode(err, xerr.InvalidArgument) {
		t.Fatalf("expected invalid iso alpha3, got %v", err)
	}

	sea := repository.PutRegion(userdomain.Region{
		RegionCode: "sea",
		Name:       "Southeast Asia",
		Status:     userdomain.RegionStatusActive,
		Countries:  []string{"AA"},
	})
	sea, err = svc.UpdateRegion(ctx, sea.RegionID, "sea", "Southeast Asia", 0, 1, "req-sea")
	if err != nil {
		t.Fatalf("UpdateRegion failed: %v", err)
	}
	if sea.RegionCode != "SEA" || len(sea.Countries) != 1 || sea.Countries[0] != "AA" {
		t.Fatalf("region normalization mismatch: %+v", sea)
	}
	subregion := repository.PutRegion(userdomain.Region{
		RegionCode: "TEST_SUBREGION",
		Name:       "测试子区域",
		Status:     userdomain.RegionStatusActive,
		Countries:  []string{"TLA"},
	})
	subregion, err = svc.UpdateRegion(ctx, subregion.RegionID, "Test Subregion", "测试子区域", 0, 1, "req-subregion")
	if err != nil {
		t.Fatalf("descriptive subregion code should be accepted: %v", err)
	}
	if subregion.RegionCode != "Test Subregion" || len(subregion.Countries) != 1 || subregion.Countries[0] != "TLA" {
		t.Fatalf("descriptive region code mismatch: %+v", subregion)
	}
	if _, err := svc.ReplaceRegionCountries(ctx, subregion.RegionID, []string{"AA"}, 1, "req-apac"); !xerr.IsCode(err, xerr.RegionCountryConflict) {
		t.Fatalf("expected region country conflict, got %v", err)
	}
}

func TestRegistrationCountriesUseEnabledFlagAndRegionKeepsDisabledCountryMapping(t *testing.T) {
	// enabled 只控制 App 用户能否选择；区域预配置仍允许引用暂未开放的国家。
	ctx := context.Background()
	repository := mysqltest.NewRepository(t)
	svc := newUserService(repository, userservice.WithCountryChangeCooldown(0))

	openCountry := repository.PutCountry(userdomain.Country{
		CountryName:        "Beta Bay",
		CountryCode:        "BB",
		ISONumeric:         "997",
		CountryDisplayName: "Beta",
		PhoneCountryCode:   "+997",
		Enabled:            true,
		SortOrder:          -50,
	})
	closedCountry := repository.PutCountry(userdomain.Country{
		CountryName:        "Closed Country",
		CountryCode:        "CC",
		ISONumeric:         "998",
		CountryDisplayName: "Closed",
		PhoneCountryCode:   "+998",
		Enabled:            false,
		SortOrder:          -100,
	})

	countries, err := svc.ListRegistrationCountries(ctx)
	if err != nil {
		t.Fatalf("ListRegistrationCountries failed: %v", err)
	}
	if !containsCountryCode(countries, openCountry.CountryCode) || containsCountryCode(countries, closedCountry.CountryCode) {
		t.Fatalf("registration list must include enabled and exclude disabled countries: %+v", countries)
	}
	region := repository.PutRegion(userdomain.Region{
		RegionCode:      "pre",
		Name:            "Preconfigured",
		Status:          userdomain.RegionStatusActive,
		Countries:       []string{closedCountry.CountryCode},
		CreatedByUserID: 1,
		UpdatedByUserID: 1,
	})
	if len(region.Countries) != 1 || region.Countries[0] != closedCountry.CountryCode {
		t.Fatalf("region countries mismatch: %+v", region)
	}

	repository.PutUser(completedUser(userdomain.User{UserID: 10001, CurrentDisplayUserID: "100001", Status: userdomain.StatusActive}))
	if _, _, err := svc.ChangeUserCountry(ctx, 10001, closedCountry.CountryCode, "req-change-closed"); !xerr.IsCode(err, xerr.InvalidArgument) {
		t.Fatalf("disabled country must be rejected for user selection, got %v", err)
	}

	repository.SetCountryEnabled(closedCountry.CountryID, true)
	countries, err = svc.ListRegistrationCountries(ctx)
	if err != nil {
		t.Fatalf("ListRegistrationCountries after enable failed: %v", err)
	}
	if len(countries) == 0 || countries[0].CountryCode != closedCountry.CountryCode || !containsCountryCode(countries, openCountry.CountryCode) {
		t.Fatalf("registration list should sort enabled countries by sort_order: %+v", countries)
	}

	repository.SetCountryEnabled(closedCountry.CountryID, false)
	region, err = svc.GetRegion(ctx, region.RegionID)
	if err != nil {
		t.Fatalf("GetRegion failed: %v", err)
	}
	if len(region.Countries) != 1 || region.Countries[0] != closedCountry.CountryCode {
		t.Fatalf("disabling country must not release region mapping: %+v", region)
	}
}

func TestChangeUserCountryUpdatesRegionAndSameCountryRepairsStaleRegion(t *testing.T) {
	// 改国家同步重算 region_id；相同国家不写冷却日志，但允许修正历史 stale region_id。
	ctx := context.Background()
	repository := mysqltest.NewRepository(t)
	seedCountry(t, repository, "US")
	seedCountry(t, repository, "SG")
	region := mustResolveRegionByCountry(t, repository, "SG")
	repository.PutUser(completedUser(userdomain.User{UserID: 10001, CurrentDisplayUserID: "100001", Country: "US", Status: userdomain.StatusActive}))
	current := time.UnixMilli(1000)
	svc := newUserService(repository,
		userservice.WithClock(func() time.Time { return current }),
		userservice.WithCountryChangeCooldown(time.Hour),
	)

	user, _, err := svc.ChangeUserCountry(ctx, 10001, "sg", "req-sg")
	if err != nil {
		t.Fatalf("ChangeUserCountry SG failed: %v", err)
	}
	if user.Country != "SG" || user.RegionID != region.RegionID || user.RegionCode != region.RegionCode {
		t.Fatalf("region after country change mismatch: %+v", user)
	}

	stale := user
	stale.RegionID = 0
	repository.PutUser(stale)
	current = current.Add(10 * time.Minute)
	user, _, err = svc.ChangeUserCountry(ctx, 10001, "SG", "req-same")
	if err != nil {
		t.Fatalf("same-country stale repair should not hit cooldown: %v", err)
	}
	if user.RegionID != region.RegionID {
		t.Fatalf("same-country stale region was not repaired: %+v", user)
	}

	current = current.Add(10 * time.Minute)
	if _, _, err := svc.ChangeUserCountry(ctx, 10001, "US", "req-cooldown"); !xerr.IsCode(err, xerr.CountryChangeCooldown) {
		t.Fatalf("expected cooldown after real country change, got %v", err)
	}
}

func TestChangeUserCountryRejectsUnknownOrDisabledCountry(t *testing.T) {
	// 改国家不能把未配置或 disabled 国家码写入 users.country。
	ctx := context.Background()
	repository := mysqltest.NewRepository(t)
	country := seedCountry(t, repository, "MY")
	repository.PutUser(completedUser(userdomain.User{UserID: 10001, CurrentDisplayUserID: "100001", Country: "", Status: userdomain.StatusActive}))
	svc := newUserService(repository, userservice.WithCountryChangeCooldown(0))
	repository.SetCountryEnabled(country.CountryID, false)

	for _, country := range []string{"ZZ", "MY"} {
		if _, _, err := svc.ChangeUserCountry(ctx, 10001, country, "req-"+country); !xerr.IsCode(err, xerr.InvalidArgument) {
			t.Fatalf("expected INVALID_ARGUMENT for country %s, got %v", country, err)
		}
	}
}

func TestRegionRebuildWorkerUpdatesHistoricalUsers(t *testing.T) {
	// 管理端新增区域后，worker 必须消费 rebuild task，把历史同 country 用户刷到目标 region_id。
	ctx := context.Background()
	repository := mysqltest.NewRepository(t)
	seedCountry(t, repository, "QAA")
	repository.PutUser(userdomain.User{UserID: 10001, CurrentDisplayUserID: "100001", Country: "QAA", Status: userdomain.StatusActive})
	repository.PutUser(userdomain.User{UserID: 10002, CurrentDisplayUserID: "100002", Country: "QAA", Status: userdomain.StatusActive})
	current := time.UnixMilli(1000)
	svc := newUserService(repository, userservice.WithClock(func() time.Time { return current }))
	region := repository.PutRegion(userdomain.Region{
		RegionCode:      "SEA",
		Name:            "Southeast Asia",
		Status:          userdomain.RegionStatusActive,
		Countries:       []string{"QAA"},
		CreatedByUserID: 1,
		UpdatedByUserID: 1,
		CreatedAtMs:     current.UnixMilli(),
		UpdatedAtMs:     current.UnixMilli(),
	})

	current = time.UnixMilli(2000)
	result, err := svc.ProcessNextRegionRebuildTask(ctx, userservice.RegionRebuildWorkerOptions{WorkerID: "test", BatchSize: 100})
	if err != nil {
		t.Fatalf("ProcessNextRegionRebuildTask failed: %v", err)
	}
	if result.Status != userdomain.RegionRebuildTaskStatusCompleted || result.ProcessedUsers != 2 {
		t.Fatalf("unexpected rebuild result: %+v", result)
	}
	for _, userID := range []int64{10001, 10002} {
		user, err := repository.GetUser(ctx, userID)
		if err != nil {
			t.Fatalf("GetUser %d failed: %v", userID, err)
		}
		if user.RegionID != region.RegionID || user.RegionCode != "SEA" {
			t.Fatalf("user region was not rebuilt: %+v", user)
		}
	}
}

func TestRegionRebuildWorkerSkipsStaleRevision(t *testing.T) {
	// 同一 country 出现更新 revision 后，旧任务必须 skipped，避免旧区域覆盖新区域或清空结果。
	ctx := context.Background()
	repository := mysqltest.NewRepository(t)
	seedCountry(t, repository, "QAB")
	current := time.UnixMilli(1000)
	svc := newUserService(repository, userservice.WithClock(func() time.Time { return current }))
	region := repository.PutRegion(userdomain.Region{
		RegionCode:      "SEA",
		Name:            "Southeast Asia",
		Status:          userdomain.RegionStatusActive,
		Countries:       []string{"QAB"},
		CreatedByUserID: 1,
		UpdatedByUserID: 1,
		CreatedAtMs:     current.UnixMilli(),
		UpdatedAtMs:     current.UnixMilli(),
	})
	repository.PutUser(userdomain.User{UserID: 10001, CurrentDisplayUserID: "100001", Country: "QAB", RegionID: region.RegionID, Status: userdomain.StatusActive})

	current = time.UnixMilli(2000)
	if _, err := svc.ReplaceRegionCountries(ctx, region.RegionID, []string{"QAB"}, 1, "req-replace-sea"); err != nil {
		t.Fatalf("ReplaceRegionCountries failed: %v", err)
	}

	current = time.UnixMilli(3000)
	result, err := svc.ProcessNextRegionRebuildTask(ctx, userservice.RegionRebuildWorkerOptions{WorkerID: "test", BatchSize: 100})
	if err != nil {
		t.Fatalf("Process stale task failed: %v", err)
	}
	if result.Status != userdomain.RegionRebuildTaskStatusSkipped {
		t.Fatalf("old task should be skipped: %+v", result)
	}
	current = time.UnixMilli(4000)
	result, err = svc.ProcessNextRegionRebuildTask(ctx, userservice.RegionRebuildWorkerOptions{WorkerID: "test", BatchSize: 100})
	if err != nil {
		t.Fatalf("Process latest task failed: %v", err)
	}
	if result.Status != userdomain.RegionRebuildTaskStatusCompleted || result.TargetRegionID != region.RegionID {
		t.Fatalf("latest task should set region: %+v", result)
	}
	user, err := repository.GetUser(ctx, 10001)
	if err != nil {
		t.Fatalf("GetUser failed: %v", err)
	}
	if user.RegionID != region.RegionID {
		t.Fatalf("stale region should be refreshed by latest task: %+v", user)
	}
}

// TestGetUserValidatesID 锁定 service 层的领域错误，不让 transport 层承担参数校验。
func TestGetUserValidatesID(t *testing.T) {
	svc := newUserService(mysqltest.NewRepository(t))

	_, err := svc.GetUser(context.Background(), 0)
	if !xerr.IsCode(err, xerr.InvalidArgument) {
		t.Fatalf("expected INVALID_ARGUMENT, got %v", err)
	}
}

// TestCreateUserAllocatesDisplayUserID 验证新用户创建时同时生成 user_id 和 active display_user_id。
func TestCreateUserAllocatesDisplayUserID(t *testing.T) {
	repository := mysqltest.NewRepository(t)
	svc := newUserService(repository,
		userservice.WithIDGenerator(&sequenceIDGenerator{values: []int64{900001}}),
		userservice.WithDisplayUserIDAllocator(sequenceDisplayUserIDAllocator{values: []string{"100001"}}),
		userservice.WithClock(func() time.Time { return time.UnixMilli(1000) }),
	)

	user, identity, err := svc.CreateUser(context.Background())
	if err != nil {
		t.Fatalf("CreateUser failed: %v", err)
	}

	if user.UserID != 900001 || identity.DisplayUserID != "100001" {
		t.Fatalf("unexpected created identity: user=%+v identity=%+v", user, identity)
	}

	resolved, err := svc.ResolveDisplayUserID(context.Background(), "100001")
	if err != nil {
		t.Fatalf("ResolveDisplayUserID failed: %v", err)
	}

	if resolved.UserID != 900001 {
		t.Fatalf("resolved user mismatch: %+v", resolved)
	}
}

// TestCreateUserRetriesDisplayUserIDConflict 验证默认短号冲突时有限重试。
func TestCreateUserRetriesDisplayUserIDConflict(t *testing.T) {
	repository := mysqltest.NewRepository(t)
	// 先占用 100001，强制 CreateUser 走第二个候选。
	repository.PutUser(userdomain.User{UserID: 1, CurrentDisplayUserID: "100001", Status: userdomain.StatusActive})
	svc := newUserService(repository,
		userservice.WithIDGenerator(&sequenceIDGenerator{values: []int64{900001, 900002}}),
		userservice.WithDisplayUserIDAllocator(sequenceDisplayUserIDAllocator{values: []string{"100001", "100002"}}),
	)

	_, identity, err := svc.CreateUser(context.Background())
	if err != nil {
		t.Fatalf("CreateUser should retry display_user_id conflict: %v", err)
	}

	if identity.DisplayUserID != "100002" {
		t.Fatalf("retry display_user_id mismatch: %+v", identity)
	}
}

// TestResolveDisplayUserIDNotFound 锁定短号不存在的专用 reason。
func TestResolveDisplayUserIDNotFound(t *testing.T) {
	svc := newUserService(mysqltest.NewRepository(t))

	_, err := svc.ResolveDisplayUserID(context.Background(), "100001")
	if !xerr.IsCode(err, xerr.DisplayUserIDNotFound) {
		t.Fatalf("expected DISPLAY_USER_ID_NOT_FOUND, got %v", err)
	}
}

// TestChangeDisplayUserID 验证修改短号后旧短号不再解析。
func TestChangeDisplayUserID(t *testing.T) {
	repository := mysqltest.NewRepository(t)
	// 当前默认短号为 100001，修改后旧短号应释放。
	repository.PutUser(userdomain.User{UserID: 10001, CurrentDisplayUserID: "100001", Status: userdomain.StatusActive})
	now := time.UnixMilli(2000)
	svc := newUserService(repository,
		userservice.WithClock(func() time.Time { return now }),
		userservice.WithDisplayUserIDPolicy(8, 30*24*time.Hour),
	)

	identity, err := svc.ChangeDisplayUserID(context.Background(), 10001, "100002", "user_request", 10001, "req-1")
	if err != nil {
		t.Fatalf("ChangeDisplayUserID failed: %v", err)
	}

	if identity.DisplayUserID != "100002" {
		t.Fatalf("changed identity mismatch: %+v", identity)
	}

	_, err = svc.ResolveDisplayUserID(context.Background(), "100001")
	if !xerr.IsCode(err, xerr.DisplayUserIDNotFound) {
		t.Fatalf("expected old display_user_id to be released, got %v", err)
	}
}

// TestChangeDisplayUserIDConflictAndCooldown 锁定占用和冷却期两个失败分支。
func TestChangeDisplayUserIDConflictAndCooldown(t *testing.T) {
	repository := mysqltest.NewRepository(t)
	// 100002 被另一个用户占用，用来验证短号冲突分支。
	repository.PutUser(userdomain.User{UserID: 10001, CurrentDisplayUserID: "100001", Status: userdomain.StatusActive})
	repository.PutUser(userdomain.User{UserID: 10002, CurrentDisplayUserID: "100002", Status: userdomain.StatusActive})
	current := time.UnixMilli(3000)
	svc := newUserService(repository,
		userservice.WithClock(func() time.Time { return current }),
		userservice.WithDisplayUserIDPolicy(8, time.Hour),
	)

	_, err := svc.ChangeDisplayUserID(context.Background(), 10001, "100002", "conflict", 10001, "req-1")
	if !xerr.IsCode(err, xerr.DisplayUserIDExists) {
		t.Fatalf("expected DISPLAY_USER_ID_EXISTS, got %v", err)
	}

	if _, err := svc.ChangeDisplayUserID(context.Background(), 10001, "100003", "first", 10001, "req-2"); err != nil {
		t.Fatalf("first change failed: %v", err)
	}

	current = current.Add(10 * time.Minute)
	// 冷却期为 1 小时，10 分钟后再次修改应被拒绝。
	_, err = svc.ChangeDisplayUserID(context.Background(), 10001, "100004", "second", 10001, "req-3")
	if !xerr.IsCode(err, xerr.DisplayUserIDCooldown) {
		t.Fatalf("expected DISPLAY_USER_ID_COOLDOWN, got %v", err)
	}
}

// TestApplyPrettyDisplayUserIDOverridesAndExpires 锁定“临时靓号覆盖当前展示号，过期恢复默认短号”的核心语义。
func TestApplyPrettyDisplayUserIDOverridesAndExpires(t *testing.T) {
	// 覆盖靓号申请、默认号 held、靓号 active 解析、过期后默认号恢复。
	repository := mysqltest.NewRepository(t)
	current := time.UnixMilli(1000)
	svc := newUserService(repository,
		userservice.WithIDGenerator(&sequenceIDGenerator{values: []int64{900001}}),
		userservice.WithDisplayUserIDAllocator(sequenceDisplayUserIDAllocator{values: []string{"100001"}}),
		userservice.WithClock(func() time.Time { return current }),
	)

	user, _, err := svc.CreateUser(context.Background())
	if err != nil {
		t.Fatalf("CreateUser failed: %v", err)
	}

	identity, leaseID, err := svc.ApplyPrettyDisplayUserID(context.Background(), user.UserID, "888888", 1000, "receipt-1", "req-pretty")
	if err != nil {
		t.Fatalf("ApplyPrettyDisplayUserID failed: %v", err)
	}
	if leaseID == "" || identity.DisplayUserID != "888888" || identity.DefaultDisplayUserID != "100001" || identity.DisplayUserIDKind != userdomain.DisplayUserIDKindPretty {
		t.Fatalf("unexpected pretty identity: identity=%+v lease=%s", identity, leaseID)
	}

	if _, _, err := svc.ApplyPrettyDisplayUserID(context.Background(), user.UserID, "999999", 1000, "receipt-2", "req-pretty-2"); !xerr.IsCode(err, xerr.DisplayUserIDPrettyActive) {
		// active 靓号期间不能再申请第二个靓号。
		t.Fatalf("expected DISPLAY_USER_ID_PRETTY_ACTIVE, got %v", err)
	}

	if resolved, err := svc.ResolveDisplayUserID(context.Background(), "888888"); err != nil || resolved.UserID != user.UserID {
		t.Fatalf("pretty display_user_id should resolve while active: identity=%+v err=%v", resolved, err)
	}
	if _, err := svc.ResolveDisplayUserID(context.Background(), "100001"); !xerr.IsCode(err, xerr.DisplayUserIDNotFound) {
		t.Fatalf("default display_user_id should be held while pretty is active, got %v", err)
	}

	current = time.UnixMilli(2500)
	// Resolve 默认号会触发懒过期恢复。
	resolved, err := svc.ResolveDisplayUserID(context.Background(), "100001")
	if err != nil {
		t.Fatalf("default display_user_id should recover after pretty expires: %v", err)
	}
	if resolved.DisplayUserID != "100001" || resolved.DisplayUserIDKind != userdomain.DisplayUserIDKindDefault {
		t.Fatalf("unexpected recovered identity: %+v", resolved)
	}
	if _, err := svc.ResolveDisplayUserID(context.Background(), "888888"); !xerr.IsCode(err, xerr.DisplayUserIDNotFound) {
		t.Fatalf("expired pretty display_user_id should not resolve, got %v", err)
	}
}