package repository

import (
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/topfans/backend/pkg/models"
	
)

// TestRankingRepository_GetHotRankingTotal 测试获取热度排行榜-全部
func TestRankingRepository_GetHotRankingTotal(t *testing.T) {
	db := setupTestDB(t)
	defer cleanupTestDB(t, db)

	repo := NewRankingRepository(db)

	// 创建测试数据
	star := createTestStar(t, db, "test_ranking_total")
	user1 := createTestUser(t, db, "19910000001")
	user2 := createTestUser(t, db, "19910000002")
	user3 := createTestUser(t, db, "19910000003")

	// 创建粉丝档案
	createTestFanProfile(t, db, user1.ID, star.StarID, "用户1")
	createTestFanProfile(t, db, user2.ID, star.StarID, "用户2")
	createTestFanProfile(t, db, user3.ID, star.StarID, "用户3")

	// 创建资产（不同点赞数）
	asset1 := &models.Asset{
		OwnerUID:   user1.ID,
		StarID:     star.StarID,
		Name:       "测试资产1",
		CoverURL:   "https://example.com/cover1.jpg",
		LikeCount:  100,
		Status:     models.AssetStatusActive,
		IsActive:   true,
		IsOriginal: false,
	}
	asset2 := &models.Asset{
		OwnerUID:   user2.ID,
		StarID:     star.StarID,
		Name:       "测试资产2",
		CoverURL:   "https://example.com/cover2.jpg",
		LikeCount:  50,
		Status:     models.AssetStatusActive,
		IsActive:   true,
		IsOriginal: false,
	}
	asset3 := &models.Asset{
		OwnerUID:   user3.ID,
		StarID:     star.StarID,
		Name:       "测试资产3",
		CoverURL:   "https://example.com/cover3.jpg",
		LikeCount:  200,
		Status:     models.AssetStatusActive,
		IsActive:   true,
		IsOriginal: false,
	}

	assert.NoError(t, db.Create(asset1).Error)
	assert.NoError(t, db.Create(asset2).Error)
	assert.NoError(t, db.Create(asset3).Error)

	// 测试获取排行榜
	items, total, err := repo.GetHotRankingTotal(star.StarID, 10, 0)

	assert.NoError(t, err)
	assert.Equal(t, int64(3), total)
	assert.Len(t, items, 3)

	// 验证按点赞数降序排列
	assert.Equal(t, asset3.ID, items[0].AssetID) // 200 likes
	assert.Equal(t, asset1.ID, items[1].AssetID) // 100 likes
	assert.Equal(t, asset2.ID, items[2].AssetID) // 50 likes
}

// TestRankingRepository_GetHotRankingDisplaying 测试获取热度排行榜-展示中
func TestRankingRepository_GetHotRankingDisplaying(t *testing.T) {
	db := setupTestDB(t)
	defer cleanupTestDB(t, db)

	repo := NewRankingRepository(db)

	// 创建测试数据
	star := createTestStar(t, db, "test_ranking_displaying")
	user1 := createTestUser(t, db, "19910000004")
	user2 := createTestUser(t, db, "19910000005")

	profile1 := createTestFanProfile(t, db, user1.ID, star.StarID, "用户1")
	// profile2 := createTestFanProfile(t, db, user2.ID, star.StarID, "用户2")

	// 创建资产
	asset1 := &models.Asset{
		OwnerUID:   user1.ID,
		StarID:     star.StarID,
		Name:       "展示中资产",
		CoverURL:   "https://example.com/cover1.jpg",
		LikeCount:  100,
		Status:     models.AssetStatusActive,
		IsActive:   true,
		IsOriginal: false,
	}
	asset2 := &models.Asset{
		OwnerUID:   user2.ID,
		StarID:     star.StarID,
		Name:       "未展示资产",
		CoverURL:   "https://example.com/cover2.jpg",
		LikeCount:  200,
		Status:     models.AssetStatusActive,
		IsActive:   true,
		IsOriginal: false,
	}

	assert.NoError(t, db.Create(asset1).Error)
	assert.NoError(t, db.Create(asset2).Error)

	// 创建展示记录（asset1 正在展示）
	exhibition := &models.Exhibition{
		HostProfileID: profile1.ID,
		AssetID:      asset1.ID,
		SlotID:       1,
		ExpireAt:     2531751708000, // 2050-01-01
	}
	assert.NoError(t, db.Create(exhibition).Error)

	// 测试获取展示中排行榜
	items, total, err := repo.GetHotRankingDisplaying(star.StarID, 10, 0)

	assert.NoError(t, err)
	assert.Equal(t, int64(1), total)
	assert.Len(t, items, 1)
	assert.Equal(t, asset1.ID, items[0].AssetID)
}

// TestRankingRepository_GetOriginalRankingTotal 测试获取自制排行榜-全部
func TestRankingRepository_GetOriginalRankingTotal(t *testing.T) {
	db := setupTestDB(t)
	defer cleanupTestDB(t, db)

	repo := NewRankingRepository(db)

	// 创建测试数据
	star := createTestStar(t, db, "test_ranking_original")
	user1 := createTestUser(t, db, "19910000006")
	user2 := createTestUser(t, db, "19910000007")
	user3 := createTestUser(t, db, "19910000008")

	createTestFanProfile(t, db, user1.ID, star.StarID, "用户1")
	createTestFanProfile(t, db, user2.ID, star.StarID, "用户2")
	createTestFanProfile(t, db, user3.ID, star.StarID, "用户3")

	// 创建自制资产和非自制资产
	originalAsset := &models.Asset{
		OwnerUID:   user1.ID,
		StarID:     star.StarID,
		Name:       "自制资产",
		CoverURL:   "https://example.com/original.jpg",
		LikeCount:  100,
		Status:     models.AssetStatusActive,
		IsActive:   true,
		IsOriginal: true,
	}
	nonOriginalAsset := &models.Asset{
		OwnerUID:   user2.ID,
		StarID:     star.StarID,
		Name:       "非自制资产",
		CoverURL:   "https://example.com/non-original.jpg",
		LikeCount:  200,
		Status:     models.AssetStatusActive,
		IsActive:   true,
		IsOriginal: false,
	}
	anotherOriginalAsset := &models.Asset{
		OwnerUID:   user3.ID,
		StarID:     star.StarID,
		Name:       "另一个自制资产",
		CoverURL:   "https://example.com/original2.jpg",
		LikeCount:  50,
		Status:     models.AssetStatusActive,
		IsActive:   true,
		IsOriginal: true,
	}

	assert.NoError(t, db.Create(originalAsset).Error)
	assert.NoError(t, db.Create(nonOriginalAsset).Error)
	assert.NoError(t, db.Create(anotherOriginalAsset).Error)

	// 测试获取自制排行榜
	items, total, err := repo.GetOriginalRankingTotal(star.StarID, 10, 0)

	assert.NoError(t, err)
	assert.Equal(t, int64(2), total)
	assert.Len(t, items, 2)

	// 验证只返回自制资产，且按点赞数降序
	assert.Equal(t, originalAsset.ID, items[0].AssetID)
	assert.Equal(t, anotherOriginalAsset.ID, items[1].AssetID)
}

// TestRankingRepository_GetMyBestRanking 测试获取用户最佳排名
func TestRankingRepository_GetMyBestRanking(t *testing.T) {
	db := setupTestDB(t)
	defer cleanupTestDB(t, db)

	repo := NewRankingRepository(db)

	// 创建测试数据
	star := createTestStar(t, db, "test_ranking_mybest")
	user1 := createTestUser(t, db, "19910000009")
	user2 := createTestUser(t, db, "19910000010")

	createTestFanProfile(t, db, user1.ID, star.StarID, "测试用户1")
	createTestFanProfile(t, db, user2.ID, star.StarID, "测试用户2")

	// 为 user1 创建多个资产
	asset1 := &models.Asset{
		OwnerUID:   user1.ID,
		StarID:     star.StarID,
		Name:       "用户1资产1",
		CoverURL:   "https://example.com/asset1.jpg",
		LikeCount:  30,
		Status:     models.AssetStatusActive,
		IsActive:   true,
		IsOriginal: false,
	}
	asset2 := &models.Asset{
		OwnerUID:   user1.ID,
		StarID:     star.StarID,
		Name:       "用户1资产2",
		CoverURL:   "https://example.com/asset2.jpg",
		LikeCount:  80,
		Status:     models.AssetStatusActive,
		IsActive:   true,
		IsOriginal: false,
	}

	// 为 user2 创建资产
	asset3 := &models.Asset{
		OwnerUID:   user2.ID,
		StarID:     star.StarID,
		Name:       "用户2资产",
		CoverURL:   "https://example.com/asset3.jpg",
		LikeCount:  50,
		Status:     models.AssetStatusActive,
		IsActive:   true,
		IsOriginal: false,
	}

	assert.NoError(t, db.Create(asset1).Error)
	assert.NoError(t, db.Create(asset2).Error)
	assert.NoError(t, db.Create(asset3).Error)

	// 测试 user1 的最佳排名（资产2有80点赞）
	item, rank, err := repo.GetMyBestRanking(user1.ID, star.StarID, "total", false)

	assert.NoError(t, err)
	assert.NotNil(t, item)
	assert.Equal(t, asset2.ID, item.AssetID) // 点赞最多的
	assert.Equal(t, int32(1), rank)          // 80点赞排第一
}

// TestRankingRepository_InvalidStarID 测试无效的 starID
func TestRankingRepository_InvalidStarID(t *testing.T) {
	db := setupTestDB(t)
	defer cleanupTestDB(t, db)

	repo := NewRankingRepository(db)

	// 测试 starID <= 0
	_, _, err := repo.GetHotRankingTotal(0, 10, 0)
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "star_id must be greater than 0")

	_, _, err = repo.GetOriginalRankingTotal(-1, 10, 0)
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "star_id must be greater than 0")
}

// TestRankingRepository_Pagination 测试分页
func TestRankingRepository_Pagination(t *testing.T) {
	db := setupTestDB(t)
	defer cleanupTestDB(t, db)

	repo := NewRankingRepository(db)

	// 创建测试数据
	star := createTestStar(t, db, "test_ranking_page")
	user := createTestUser(t, db, "19910000011")
	createTestFanProfile(t, db, user.ID, star.StarID, "测试用户")

	// 创建10个资产
	for i := 0; i < 10; i++ {
		asset := &models.Asset{
			OwnerUID:   user.ID,
			StarID:     star.StarID,
			Name:       "资产" + string(rune('0'+i)),
			CoverURL:   "https://example.com/cover" + string(rune('0'+i)) + ".jpg",
			LikeCount:  int32((i + 1) * 10),
			Status:     models.AssetStatusActive,
			IsActive:   true,
			IsOriginal: false,
		}
		assert.NoError(t, db.Create(asset).Error)
	}

	// 测试第一页（每页3条）
	items, total, err := repo.GetHotRankingTotal(star.StarID, 3, 0)
	assert.NoError(t, err)
	assert.Equal(t, int64(10), total)
	assert.Len(t, items, 3)
	assert.Equal(t, int32(100), items[0].LikeCount) // 第一页第一个是100赞

	// 测试第二页
	items, total, err = repo.GetHotRankingTotal(star.StarID, 3, 3)
	assert.NoError(t, err)
	assert.Equal(t, int64(10), total)
	assert.Len(t, items, 3)
	assert.Equal(t, int32(70), items[0].LikeCount) // 第二页第一个是70赞
}