package repository

import (
	"testing"
	"time"

	"github.com/topfans/backend/pkg/database"
	"github.com/topfans/backend/pkg/models"
	"gorm.io/gorm"
)

// setupTestDB 设置测试数据库
func setupTestDB(t *testing.T) *gorm.DB {
	config := database.Config{
		Host:     "localhost",
		Port:     5432,
		User:     "haihuizhu",
		Password: "admin",
		DBName:   "top-fans",
		SSLMode:  "disable",
		TimeZone: "Asia/Shanghai",
	}

	if err := database.Init(config); err != nil {
		t.Skipf("Skipping test: failed to connect to test database: %v", err)
	}

	db := database.GetDB()

	// 只迁移好友相关表（假设基础表已存在）
	// 注意：如果表已存在，AutoMigrate会自动更新表结构
	if err := db.AutoMigrate(&models.FriendRequest{}, &models.Friendship{}); err != nil {
		t.Logf("Warning: Failed to migrate friend tables (may already exist): %v", err)
		// 不要失败，继续测试
	}

	return db
}

// cleanupTestDB 清理测试数据
func cleanupTestDB(t *testing.T, db *gorm.DB) {
	// 清理测试数据（注意外键约束顺序）
	db.Exec("DELETE FROM friendships WHERE user_id IN (SELECT id FROM users WHERE mobile LIKE '188%')")
	db.Exec("DELETE FROM friend_requests WHERE from_user_id IN (SELECT id FROM users WHERE mobile LIKE '188%')")
	db.Exec("DELETE FROM fan_profiles WHERE user_id IN (SELECT id FROM users WHERE mobile LIKE '188%')")
	db.Exec("DELETE FROM users WHERE mobile LIKE '188%'")
	db.Exec("DELETE FROM stars WHERE identity_id LIKE 'test_social_%'")
}

// createTestStar 创建测试用明星
func createTestStar(t *testing.T, db *gorm.DB, identityID string) *models.Star {
	star := &models.Star{
		Name:       "测试明星-" + identityID,
		IdentityID: identityID,
		IsActive:   true,
	}
	if err := db.Create(star).Error; err != nil {
		t.Fatalf("Failed to create test star: %v", err)
	}
	return star
}

// createTestUser 创建测试用户
func createTestUser(t *testing.T, db *gorm.DB, mobile string) *models.User {
	user := &models.User{
		Mobile:       mobile,
		PasswordHash: "test_hash",
		IsActive:     true,
	}
	if err := db.Create(user).Error; err != nil {
		t.Fatalf("Failed to create test user: %v", err)
	}
	return user
}

// createTestFanProfile 创建测试粉丝档案
func createTestFanProfile(t *testing.T, db *gorm.DB, userID, starID int64, nickname string) *models.FanProfile {
	profile := &models.FanProfile{
		UserID:   userID,
		StarID:   starID,
		Nickname: nickname,
		Level:    1,
		Social:   0,
	}
	if err := db.Create(profile).Error; err != nil {
		t.Fatalf("Failed to create test fan profile: %v", err)
	}
	return profile
}

// ==================== 好友请求相关测试 ====================

func TestSocialRepository_CreateRequest(t *testing.T) {
	db := setupTestDB(t)
	defer cleanupTestDB(t, db)

	repo := NewSocialRepository()

	// 创建测试数据
	star := createTestStar(t, db, "test_social_001")
	user1 := createTestUser(t, db, "18800000001")
	user2 := createTestUser(t, db, "18800000002")

	// 创建好友请求
	expiresAt := time.Now().Add(30 * 24 * time.Hour).UnixMilli()
	message := "你好，我想加你为好友"
	request := &models.FriendRequest{
		FromUserID: user1.ID,
		ToUserID:   user2.ID,
		StarID:     star.StarID,
		Message:    &message,
		Status:     models.FriendRequestStatusPending,
		ExpiresAt:  &expiresAt,
	}

	err := repo.CreateRequest(request)
	if err != nil {
		t.Fatalf("CreateRequest failed: %v", err)
	}

	// 验证
	if request.ID == 0 {
		t.Fatal("Request ID should not be zero after creation")
	}

	if request.CreatedAt == 0 {
		t.Fatal("CreatedAt should be set")
	}

	// 测试nil请求
	err = repo.CreateRequest(nil)
	if err == nil {
		t.Fatal("Expected error for nil request")
	}
}

func TestSocialRepository_GetRequestByID(t *testing.T) {
	db := setupTestDB(t)
	defer cleanupTestDB(t, db)

	repo := NewSocialRepository()

	// 创建测试数据
	star := createTestStar(t, db, "test_social_002")
	user1 := createTestUser(t, db, "18800000003")
	user2 := createTestUser(t, db, "18800000004")

	expiresAt := time.Now().Add(30 * 24 * time.Hour).UnixMilli()
	message := "测试消息"
	request := &models.FriendRequest{
		FromUserID: user1.ID,
		ToUserID:   user2.ID,
		StarID:     star.StarID,
		Message:    &message,
		Status:     models.FriendRequestStatusPending,
		ExpiresAt:  &expiresAt,
	}
	db.Create(request)

	// 测试正常查询
	retrieved, err := repo.GetRequestByID(request.ID)
	if err != nil {
		t.Fatalf("GetRequestByID failed: %v", err)
	}

	if retrieved == nil {
		t.Fatal("Retrieved request should not be nil")
	}

	if retrieved.ID != request.ID {
		t.Errorf("ID mismatch: expected %d, got %d", request.ID, retrieved.ID)
	}

	if retrieved.FromUserID != user1.ID {
		t.Errorf("FromUserID mismatch: expected %d, got %d", user1.ID, retrieved.FromUserID)
	}

	// 测试不存在的请求
	retrieved, err = repo.GetRequestByID(99999)
	if err != nil {
		t.Fatalf("GetRequestByID failed for non-existent request: %v", err)
	}

	if retrieved != nil {
		t.Fatal("Expected nil for non-existent request")
	}
}

func TestSocialRepository_GetRequestsByUser(t *testing.T) {
	db := setupTestDB(t)
	defer cleanupTestDB(t, db)

	repo := NewSocialRepository()

	// 创建测试数据
	star := createTestStar(t, db, "test_social_003")
	user1 := createTestUser(t, db, "18800000005")
	user2 := createTestUser(t, db, "18800000006")
	user3 := createTestUser(t, db, "18800000007")

	// 创建多个请求
	expiresAt := time.Now().Add(30 * 24 * time.Hour).UnixMilli()
	message := "测试消息"

	// user1 -> user2 (pending)
	request1 := &models.FriendRequest{
		FromUserID: user1.ID,
		ToUserID:   user2.ID,
		StarID:     star.StarID,
		Message:    &message,
		Status:     models.FriendRequestStatusPending,
		ExpiresAt:  &expiresAt,
	}
	db.Create(request1)

	// user1 -> user3 (accepted)
	request2 := &models.FriendRequest{
		FromUserID: user1.ID,
		ToUserID:   user3.ID,
		StarID:     star.StarID,
		Message:    &message,
		Status:     models.FriendRequestStatusAccepted,
		ExpiresAt:  &expiresAt,
	}
	db.Create(request2)

	// user3 -> user1 (pending)
	request3 := &models.FriendRequest{
		FromUserID: user3.ID,
		ToUserID:   user1.ID,
		StarID:     star.StarID,
		Message:    &message,
		Status:     models.FriendRequestStatusPending,
		ExpiresAt:  &expiresAt,
	}
	db.Create(request3)

	// 测试获取发出的请求（sent）
	sentRequests, total, err := repo.GetRequestsByUser(user1.ID, star.StarID, models.FriendRequestTypeSent, "", 1, 10)
	if err != nil {
		t.Fatalf("GetRequestsByUser (sent) failed: %v", err)
	}

	if total != 2 {
		t.Errorf("Expected 2 sent requests, got %d", total)
	}

	if len(sentRequests) != 2 {
		t.Errorf("Expected 2 sent requests in list, got %d", len(sentRequests))
	}

	// 测试获取收到的请求（received）
	_, total, err = repo.GetRequestsByUser(user1.ID, star.StarID, models.FriendRequestTypeReceived, "", 1, 10)
	if err != nil {
		t.Fatalf("GetRequestsByUser (received) failed: %v", err)
	}

	if total != 1 {
		t.Errorf("Expected 1 received request, got %d", total)
	}

	// 测试状态筛选
	_, total, err = repo.GetRequestsByUser(user1.ID, star.StarID, models.FriendRequestTypeSent, models.FriendRequestStatusPending, 1, 10)
	if err != nil {
		t.Fatalf("GetRequestsByUser (pending) failed: %v", err)
	}

	if total != 1 {
		t.Errorf("Expected 1 pending sent request, got %d", total)
	}

	// 测试分页
	pagedRequests, total, err := repo.GetRequestsByUser(user1.ID, star.StarID, models.FriendRequestTypeSent, "", 1, 1)
	if err != nil {
		t.Fatalf("GetRequestsByUser (paged) failed: %v", err)
	}

	if total != 2 {
		t.Errorf("Expected total 2, got %d", total)
	}

	if len(pagedRequests) != 1 {
		t.Errorf("Expected 1 request in page, got %d", len(pagedRequests))
	}

	// 测试无效的请求类型
	_, _, err = repo.GetRequestsByUser(user1.ID, star.StarID, "invalid", "", 1, 10)
	if err == nil {
		t.Fatal("Expected error for invalid request type")
	}
}

func TestSocialRepository_GetLatestRequest(t *testing.T) {
	db := setupTestDB(t)
	defer cleanupTestDB(t, db)

	repo := NewSocialRepository()

	// 创建测试数据
	star := createTestStar(t, db, "test_social_004")
	user1 := createTestUser(t, db, "18800000008")
	user2 := createTestUser(t, db, "18800000009")

	// 创建多个历史请求
	expiresAt := time.Now().Add(30 * 24 * time.Hour).UnixMilli()
	message := "第一次请求"

	// 第一次请求（rejected）
	request1 := &models.FriendRequest{
		FromUserID: user1.ID,
		ToUserID:   user2.ID,
		StarID:     star.StarID,
		Message:    &message,
		Status:     models.FriendRequestStatusRejected,
		ExpiresAt:  &expiresAt,
	}
	db.Create(request1)

	time.Sleep(10 * time.Millisecond) // 确保时间不同

	// 第二次请求（pending）
	message2 := "第二次请求"
	request2 := &models.FriendRequest{
		FromUserID: user1.ID,
		ToUserID:   user2.ID,
		StarID:     star.StarID,
		Message:    &message2,
		Status:     models.FriendRequestStatusPending,
		ExpiresAt:  &expiresAt,
	}
	db.Create(request2)

	// 获取最新请求
	latest, err := repo.GetLatestRequest(user1.ID, user2.ID, star.StarID)
	if err != nil {
		t.Fatalf("GetLatestRequest failed: %v", err)
	}

	if latest == nil {
		t.Fatal("Latest request should not be nil")
	}

	if latest.ID != request2.ID {
		t.Errorf("Expected latest request ID %d, got %d", request2.ID, latest.ID)
	}

	if latest.Status != models.FriendRequestStatusPending {
		t.Errorf("Expected status pending, got %s", latest.Status)
	}

	// 测试不存在的请求
	latest, err = repo.GetLatestRequest(99999, 99999, star.StarID)
	if err != nil {
		t.Fatalf("GetLatestRequest failed for non-existent: %v", err)
	}

	if latest != nil {
		t.Fatal("Expected nil for non-existent request")
	}
}

func TestSocialRepository_UpdateRequestStatus(t *testing.T) {
	db := setupTestDB(t)
	defer cleanupTestDB(t, db)

	repo := NewSocialRepository()

	// 创建测试数据
	star := createTestStar(t, db, "test_social_005")
	user1 := createTestUser(t, db, "18800000010")
	user2 := createTestUser(t, db, "18800000011")

	expiresAt := time.Now().Add(30 * 24 * time.Hour).UnixMilli()
	message := "测试消息"
	request := &models.FriendRequest{
		FromUserID: user1.ID,
		ToUserID:   user2.ID,
		StarID:     star.StarID,
		Message:    &message,
		Status:     models.FriendRequestStatusPending,
		ExpiresAt:  &expiresAt,
	}
	db.Create(request)

	// 更新状态（不更新处理时间）
	err := repo.UpdateRequestStatus(request.ID, models.FriendRequestStatusAccepted, nil)
	if err != nil {
		t.Fatalf("UpdateRequestStatus failed: %v", err)
	}

	// 验证更新
	retrieved, _ := repo.GetRequestByID(request.ID)
	if retrieved.Status != models.FriendRequestStatusAccepted {
		t.Errorf("Expected status accepted, got %s", retrieved.Status)
	}

	if retrieved.ProcessedAt != nil {
		t.Error("ProcessedAt should be nil when not provided")
	}

	// 更新状态（更新处理时间）
	processedAt := time.Now().UnixMilli()
	err = repo.UpdateRequestStatus(request.ID, models.FriendRequestStatusRejected, &processedAt)
	if err != nil {
		t.Fatalf("UpdateRequestStatus with processedAt failed: %v", err)
	}

	// 验证更新
	retrieved, _ = repo.GetRequestByID(request.ID)
	if retrieved.Status != models.FriendRequestStatusRejected {
		t.Errorf("Expected status rejected, got %s", retrieved.Status)
	}

	if retrieved.ProcessedAt == nil {
		t.Fatal("ProcessedAt should not be nil")
	}

	if *retrieved.ProcessedAt != processedAt {
		t.Errorf("ProcessedAt mismatch: expected %d, got %d", processedAt, *retrieved.ProcessedAt)
	}

	// 测试不存在的请求
	err = repo.UpdateRequestStatus(99999, models.FriendRequestStatusAccepted, nil)
	if err == nil {
		t.Fatal("Expected error for non-existent request")
	}
}

// ==================== 好友关系相关测试 ====================

func TestSocialRepository_CreateFriendshipPair(t *testing.T) {
	db := setupTestDB(t)
	defer cleanupTestDB(t, db)

	repo := NewSocialRepository()

	// 创建测试数据
	star := createTestStar(t, db, "test_social_006")
	user1 := createTestUser(t, db, "18800000012")
	user2 := createTestUser(t, db, "18800000013")

	// 创建双向好友关系
	err := repo.CreateFriendshipPair(user1.ID, user2.ID, star.StarID)
	if err != nil {
		t.Fatalf("CreateFriendshipPair failed: %v", err)
	}

	// 验证 A→B 关系
	var friendship1 models.Friendship
	err = db.Where("user_id = ? AND friend_id = ? AND star_id = ?", user1.ID, user2.ID, star.StarID).First(&friendship1).Error
	if err != nil {
		t.Fatalf("Failed to find friendship A→B: %v", err)
	}

	if friendship1.Status != models.FriendshipStatusAccepted {
		t.Errorf("Expected status accepted, got %s", friendship1.Status)
	}

	// 验证 B→A 关系
	var friendship2 models.Friendship
	err = db.Where("user_id = ? AND friend_id = ? AND star_id = ?", user2.ID, user1.ID, star.StarID).First(&friendship2).Error
	if err != nil {
		t.Fatalf("Failed to find friendship B→A: %v", err)
	}

	if friendship2.Status != models.FriendshipStatusAccepted {
		t.Errorf("Expected status accepted, got %s", friendship2.Status)
	}

	// 测试重复创建（应该失败，因为有唯一索引）
	err = repo.CreateFriendshipPair(user1.ID, user2.ID, star.StarID)
	if err == nil {
		t.Fatal("Expected error for duplicate friendship")
	}
}

func TestSocialRepository_CheckFriendship(t *testing.T) {
	db := setupTestDB(t)
	defer cleanupTestDB(t, db)

	repo := NewSocialRepository()

	// 创建测试数据
	star := createTestStar(t, db, "test_social_007")
	user1 := createTestUser(t, db, "18800000014")
	user2 := createTestUser(t, db, "18800000015")
	user3 := createTestUser(t, db, "18800000016")

	// 创建好友关系
	repo.CreateFriendshipPair(user1.ID, user2.ID, star.StarID)

	// 测试已存在的好友关系
	isFriend, err := repo.CheckFriendship(user1.ID, user2.ID, star.StarID)
	if err != nil {
		t.Fatalf("CheckFriendship failed: %v", err)
	}

	if !isFriend {
		t.Error("Expected users to be friends")
	}

	// 测试反向关系
	isFriend, err = repo.CheckFriendship(user2.ID, user1.ID, star.StarID)
	if err != nil {
		t.Fatalf("CheckFriendship (reverse) failed: %v", err)
	}

	if !isFriend {
		t.Error("Expected reverse friendship to exist")
	}

	// 测试不存在的好友关系
	isFriend, err = repo.CheckFriendship(user1.ID, user3.ID, star.StarID)
	if err != nil {
		t.Fatalf("CheckFriendship (non-friend) failed: %v", err)
	}

	if isFriend {
		t.Error("Expected users to not be friends")
	}
}

func TestSocialRepository_GetFriendsByUser(t *testing.T) {
	db := setupTestDB(t)
	defer cleanupTestDB(t, db)

	repo := NewSocialRepository()

	// 创建测试数据
	star := createTestStar(t, db, "test_social_008")
	user1 := createTestUser(t, db, "18800000017")
	user2 := createTestUser(t, db, "18800000018")
	user3 := createTestUser(t, db, "18800000019")
	user4 := createTestUser(t, db, "18800000020")

	// 创建粉丝档案（为关键词搜索准备）
	createTestFanProfile(t, db, user2.ID, star.StarID, "张三")
	createTestFanProfile(t, db, user3.ID, star.StarID, "李四")
	createTestFanProfile(t, db, user4.ID, star.StarID, "王五")

	// 创建好友关系
	repo.CreateFriendshipPair(user1.ID, user2.ID, star.StarID)
	repo.CreateFriendshipPair(user1.ID, user3.ID, star.StarID)
	repo.CreateFriendshipPair(user1.ID, user4.ID, star.StarID)

	// 设置备注
	remark := "小张"
	db.Model(&models.Friendship{}).Where("user_id = ? AND friend_id = ?", user1.ID, user2.ID).Update("remark", remark)

	// 测试获取所有好友
	friends, total, err := repo.GetFriendsByUser(user1.ID, star.StarID, "", 1, 10)
	if err != nil {
		t.Fatalf("GetFriendsByUser failed: %v", err)
	}

	if total != 3 {
		t.Errorf("Expected 3 friends, got %d", total)
	}

	if len(friends) != 3 {
		t.Errorf("Expected 3 friends in list, got %d", len(friends))
	}

	// 测试关键词搜索（搜索昵称）
	friends, total, err = repo.GetFriendsByUser(user1.ID, star.StarID, "张", 1, 10)
	if err != nil {
		t.Fatalf("GetFriendsByUser with keyword failed: %v", err)
	}

	if total != 1 {
		t.Errorf("Expected 1 friend matching '张', got %d", total)
	}

	// 测试关键词搜索（搜索备注）
	friends, total, err = repo.GetFriendsByUser(user1.ID, star.StarID, "小张", 1, 10)
	if err != nil {
		t.Fatalf("GetFriendsByUser with remark keyword failed: %v", err)
	}

	if total != 1 {
		t.Errorf("Expected 1 friend matching '小张', got %d", total)
	}

	// 测试分页
	friends, total, err = repo.GetFriendsByUser(user1.ID, star.StarID, "", 1, 2)
	if err != nil {
		t.Fatalf("GetFriendsByUser with pagination failed: %v", err)
	}

	if total != 3 {
		t.Errorf("Expected total 3, got %d", total)
	}

	if len(friends) != 2 {
		t.Errorf("Expected 2 friends in first page, got %d", len(friends))
	}

	// 测试第二页
	friends, total, err = repo.GetFriendsByUser(user1.ID, star.StarID, "", 2, 2)
	if err != nil {
		t.Fatalf("GetFriendsByUser second page failed: %v", err)
	}

	if len(friends) != 1 {
		t.Errorf("Expected 1 friend in second page, got %d", len(friends))
	}
}

func TestSocialRepository_DeleteFriendshipPair(t *testing.T) {
	db := setupTestDB(t)
	defer cleanupTestDB(t, db)

	repo := NewSocialRepository()

	// 创建测试数据
	star := createTestStar(t, db, "test_social_009")
	user1 := createTestUser(t, db, "18800000021")
	user2 := createTestUser(t, db, "18800000022")

	// 创建好友关系
	repo.CreateFriendshipPair(user1.ID, user2.ID, star.StarID)

	// 验证关系存在
	isFriend, _ := repo.CheckFriendship(user1.ID, user2.ID, star.StarID)
	if !isFriend {
		t.Fatal("Friendship should exist before deletion")
	}

	// 删除好友关系
	err := repo.DeleteFriendshipPair(user1.ID, user2.ID, star.StarID)
	if err != nil {
		t.Fatalf("DeleteFriendshipPair failed: %v", err)
	}

	// 验证 A→B 关系已删除
	isFriend, _ = repo.CheckFriendship(user1.ID, user2.ID, star.StarID)
	if isFriend {
		t.Error("Friendship A→B should be deleted")
	}

	// 验证 B→A 关系已删除
	isFriend, _ = repo.CheckFriendship(user2.ID, user1.ID, star.StarID)
	if isFriend {
		t.Error("Friendship B→A should be deleted")
	}

	// 测试删除不存在的关系
	err = repo.DeleteFriendshipPair(user1.ID, user2.ID, star.StarID)
	if err == nil {
		t.Fatal("Expected error for non-existent friendship")
	}
}

func TestSocialRepository_UpdateRemark(t *testing.T) {
	db := setupTestDB(t)
	defer cleanupTestDB(t, db)

	repo := NewSocialRepository()

	// 创建测试数据
	star := createTestStar(t, db, "test_social_010")
	user1 := createTestUser(t, db, "18800000023")
	user2 := createTestUser(t, db, "18800000024")

	// 创建好友关系
	repo.CreateFriendshipPair(user1.ID, user2.ID, star.StarID)

	// 更新备注
	newRemark := "我的好朋友"
	err := repo.UpdateRemark(user1.ID, user2.ID, star.StarID, newRemark)
	if err != nil {
		t.Fatalf("UpdateRemark failed: %v", err)
	}

	// 验证更新
	var friendship models.Friendship
	db.Where("user_id = ? AND friend_id = ? AND star_id = ?", user1.ID, user2.ID, star.StarID).First(&friendship)

	if friendship.Remark == nil {
		t.Fatal("Remark should not be nil")
	}

	if *friendship.Remark != newRemark {
		t.Errorf("Remark mismatch: expected %s, got %s", newRemark, *friendship.Remark)
	}

	// 验证反向关系的备注未改变
	var reverseFriendship models.Friendship
	db.Where("user_id = ? AND friend_id = ? AND star_id = ?", user2.ID, user1.ID, star.StarID).First(&reverseFriendship)

	if reverseFriendship.Remark != nil {
		t.Error("Reverse friendship remark should not be updated")
	}

	// 测试更新不存在的关系
	err = repo.UpdateRemark(99999, 99999, star.StarID, "test")
	if err == nil {
		t.Fatal("Expected error for non-existent friendship")
	}
}

func TestSocialRepository_CountFriends(t *testing.T) {
	db := setupTestDB(t)
	defer cleanupTestDB(t, db)

	repo := NewSocialRepository()

	// 创建测试数据
	star := createTestStar(t, db, "test_social_011")
	user1 := createTestUser(t, db, "18800000025")
	user2 := createTestUser(t, db, "18800000026")
	user3 := createTestUser(t, db, "18800000027")
	user4 := createTestUser(t, db, "18800000028")

	// 创建好友关系
	repo.CreateFriendshipPair(user1.ID, user2.ID, star.StarID)
	repo.CreateFriendshipPair(user1.ID, user3.ID, star.StarID)
	repo.CreateFriendshipPair(user1.ID, user4.ID, star.StarID)

	// 统计好友数量
	count, err := repo.CountFriends(user1.ID, star.StarID)
	if err != nil {
		t.Fatalf("CountFriends failed: %v", err)
	}

	if count != 3 {
		t.Errorf("Expected 3 friends, got %d", count)
	}

	// 测试user2的好友数量
	count, err = repo.CountFriends(user2.ID, star.StarID)
	if err != nil {
		t.Fatalf("CountFriends for user2 failed: %v", err)
	}

	if count != 1 {
		t.Errorf("Expected 1 friend for user2, got %d", count)
	}

	// 测试没有好友的用户
	user5 := createTestUser(t, db, "18800000029")
	count, err = repo.CountFriends(user5.ID, star.StarID)
	if err != nil {
		t.Fatalf("CountFriends for user with no friends failed: %v", err)
	}

	if count != 0 {
		t.Errorf("Expected 0 friends, got %d", count)
	}
}

// ==================== 边界情况和集成测试 ====================

func TestSocialRepository_CompleteFlow(t *testing.T) {
	db := setupTestDB(t)
	defer cleanupTestDB(t, db)

	repo := NewSocialRepository()

	// 创建测试数据
	star := createTestStar(t, db, "test_social_012")
	userA := createTestUser(t, db, "18800000030")
	userB := createTestUser(t, db, "18800000031")

	// 1. A 发送好友请求给 B
	expiresAt := time.Now().Add(30 * 24 * time.Hour).UnixMilli()
	message := "你好，我想加你为好友"
	request := &models.FriendRequest{
		FromUserID: userA.ID,
		ToUserID:   userB.ID,
		StarID:     star.StarID,
		Message:    &message,
		Status:     models.FriendRequestStatusPending,
		ExpiresAt:  &expiresAt,
	}
	err := repo.CreateRequest(request)
	if err != nil {
		t.Fatalf("Failed to create request: %v", err)
	}

	// 2. B 查看收到的请求
	_, total, err := repo.GetRequestsByUser(userB.ID, star.StarID, models.FriendRequestTypeReceived, models.FriendRequestStatusPending, 1, 10)
	if err != nil {
		t.Fatalf("Failed to get received requests: %v", err)
	}

	if total != 1 {
		t.Errorf("Expected 1 received request, got %d", total)
	}

	// 3. B 接受请求
	processedAt := time.Now().UnixMilli()
	err = repo.UpdateRequestStatus(request.ID, models.FriendRequestStatusAccepted, &processedAt)
	if err != nil {
		t.Fatalf("Failed to update request status: %v", err)
	}

	// 4. 创建双向好友关系
	err = repo.CreateFriendshipPair(userA.ID, userB.ID, star.StarID)
	if err != nil {
		t.Fatalf("Failed to create friendship: %v", err)
	}

	// 5. 验证好友关系
	isFriend, err := repo.CheckFriendship(userA.ID, userB.ID, star.StarID)
	if err != nil || !isFriend {
		t.Fatal("Failed to verify friendship")
	}

	// 6. A 设置 B 的备注
	err = repo.UpdateRemark(userA.ID, userB.ID, star.StarID, "B的昵称")
	if err != nil {
		t.Fatalf("Failed to update remark: %v", err)
	}

	// 7. 查询好友列表
	friends, _, err := repo.GetFriendsByUser(userA.ID, star.StarID, "", 1, 10)
	if err != nil {
		t.Fatalf("Failed to get friends: %v", err)
	}

	if len(friends) != 1 {
		t.Errorf("Expected 1 friend, got %d", len(friends))
	}

	// 8. 统计好友数量
	count, err := repo.CountFriends(userA.ID, star.StarID)
	if err != nil {
		t.Fatalf("Failed to count friends: %v", err)
	}

	if count != 1 {
		t.Errorf("Expected count 1, got %d", count)
	}

	// 9. A 删除好友
	err = repo.DeleteFriendshipPair(userA.ID, userB.ID, star.StarID)
	if err != nil {
		t.Fatalf("Failed to delete friendship: %v", err)
	}

	// 10. 验证好友关系已删除
	isFriend, err = repo.CheckFriendship(userA.ID, userB.ID, star.StarID)
	if err != nil || isFriend {
		t.Fatal("Friendship should be deleted")
	}

	// 11. 验证好友数量为0
	count, err = repo.CountFriends(userA.ID, star.StarID)
	if err != nil {
		t.Fatalf("Failed to count friends after deletion: %v", err)
	}

	if count != 0 {
		t.Errorf("Expected count 0, got %d", count)
	}
}