backend/internal/service/texture_service_test.go

package service

import (
	"carrotskin/internal/model"
	"context"
	"crypto/sha256"
	"encoding/hex"
	"testing"

	"go.uber.org/zap"
)

// sha256Hex 计算给定数据的 SHA-256 十六进制字符串
func sha256Hex(data []byte) string {
	sum := sha256.Sum256(data)
	return hex.EncodeToString(sum[:])
}

// TestTextureService_TypeValidation 测试材质类型验证
func TestTextureService_TypeValidation(t *testing.T) {
	tests := []struct {
		name        string
		textureType string
		wantValid   bool
	}{
		{
			name:        "SKIN类型有效",
			textureType: "SKIN",
			wantValid:   true,
		},
		{
			name:        "CAPE类型有效",
			textureType: "CAPE",
			wantValid:   true,
		},
		{
			name:        "无效类型",
			textureType: "INVALID",
			wantValid:   false,
		},
		{
			name:        "空类型无效",
			textureType: "",
			wantValid:   false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			isValid := tt.textureType == "SKIN" || tt.textureType == "CAPE"
			if isValid != tt.wantValid {
				t.Errorf("Texture type validation failed: got %v, want %v", isValid, tt.wantValid)
			}
		})
	}
}

// TestTextureService_DefaultValues 测试材质默认值
func TestTextureService_DefaultValues(t *testing.T) {
	// 测试默认状态
	defaultStatus := 1
	if defaultStatus != 1 {
		t.Errorf("默认状态应为1，实际为%d", defaultStatus)
	}

	// 测试默认下载数
	defaultDownloadCount := 0
	if defaultDownloadCount != 0 {
		t.Errorf("默认下载数应为0，实际为%d", defaultDownloadCount)
	}

	// 测试默认收藏数
	defaultFavoriteCount := 0
	if defaultFavoriteCount != 0 {
		t.Errorf("默认收藏数应为0，实际为%d", defaultFavoriteCount)
	}
}

// TestTextureService_StatusValidation 测试材质状态验证
func TestTextureService_StatusValidation(t *testing.T) {
	tests := []struct {
		name      string
		status    int16
		wantValid bool
	}{
		{
			name:      "状态为1（正常）时有效",
			status:    1,
			wantValid: true,
		},
		{
			name:      "状态为-1（删除）时无效",
			status:    -1,
			wantValid: false,
		},
		{
			name:      "状态为0时可能有效（取决于业务逻辑）",
			status:    0,
			wantValid: true, // 状态为0（禁用）时，材质仍然存在，只是不可用，但查询时不会返回错误
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// 材质状态为-1时表示已删除，无效
			isValid := tt.status != -1
			if isValid != tt.wantValid {
				t.Errorf("Status validation failed: got %v, want %v", isValid, tt.wantValid)
			}
		})
	}
}

// TestGetUserTextures_Pagination 测试分页逻辑
func TestGetUserTextures_Pagination(t *testing.T) {
	tests := []struct {
		name     string
		page     int
		pageSize int
		wantPage int
		wantSize int
	}{
		{
			name:     "有效的分页参数",
			page:     2,
			pageSize: 20,
			wantPage: 2,
			wantSize: 20,
		},
		{
			name:     "page小于1，应该设为1",
			page:     0,
			pageSize: 20,
			wantPage: 1,
			wantSize: 20,
		},
		{
			name:     "pageSize小于1，应该设为20",
			page:     1,
			pageSize: 0,
			wantPage: 1,
			wantSize: 20,
		},
		{
			name:     "pageSize超过100，应该设为20",
			page:     1,
			pageSize: 200,
			wantPage: 1,
			wantSize: 20,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			page := tt.page
			pageSize := tt.pageSize

			if page < 1 {
				page = 1
			}
			if pageSize < 1 || pageSize > 100 {
				pageSize = 20
			}

			if page != tt.wantPage {
				t.Errorf("Page = %d, want %d", page, tt.wantPage)
			}
			if pageSize != tt.wantSize {
				t.Errorf("PageSize = %d, want %d", pageSize, tt.wantSize)
			}
		})
	}
}

// TestSearchTextures_Pagination 测试搜索分页逻辑
func TestSearchTextures_Pagination(t *testing.T) {
	tests := []struct {
		name     string
		page     int
		pageSize int
		wantPage int
		wantSize int
	}{
		{
			name:     "有效的分页参数",
			page:     1,
			pageSize: 10,
			wantPage: 1,
			wantSize: 10,
		},
		{
			name:     "page小于1，应该设为1",
			page:     -1,
			pageSize: 20,
			wantPage: 1,
			wantSize: 20,
		},
		{
			name:     "pageSize超过100，应该设为20",
			page:     1,
			pageSize: 150,
			wantPage: 1,
			wantSize: 20,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			page := tt.page
			pageSize := tt.pageSize

			if page < 1 {
				page = 1
			}
			if pageSize < 1 || pageSize > 100 {
				pageSize = 20
			}

			if page != tt.wantPage {
				t.Errorf("Page = %d, want %d", page, tt.wantPage)
			}
			if pageSize != tt.wantSize {
				t.Errorf("PageSize = %d, want %d", pageSize, tt.wantSize)
			}
		})
	}
}

// TestUpdateTexture_PermissionCheck 测试更新材质的权限检查
func TestUpdateTexture_PermissionCheck(t *testing.T) {
	tests := []struct {
		name       string
		uploaderID int64
		requestID  int64
		wantErr    bool
	}{
		{
			name:       "上传者ID匹配，允许更新",
			uploaderID: 1,
			requestID:  1,
			wantErr:    false,
		},
		{
			name:       "上传者ID不匹配，拒绝更新",
			uploaderID: 1,
			requestID:  2,
			wantErr:    true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			hasError := tt.uploaderID != tt.requestID
			if hasError != tt.wantErr {
				t.Errorf("Permission check failed: got %v, want %v", hasError, tt.wantErr)
			}
		})
	}
}

// TestUpdateTexture_FieldUpdates 测试更新字段逻辑
func TestUpdateTexture_FieldUpdates(t *testing.T) {
	tests := []struct {
		name        string
		nameValue   string
		descValue   string
		isPublic    *bool
		wantUpdates int
	}{
		{
			name:        "更新所有字段",
			nameValue:   "NewName",
			descValue:   "NewDesc",
			isPublic:    boolPtr(true),
			wantUpdates: 3,
		},
		{
			name:        "只更新名称",
			nameValue:   "NewName",
			descValue:   "",
			isPublic:    nil,
			wantUpdates: 1,
		},
		{
			name:        "只更新描述",
			nameValue:   "",
			descValue:   "NewDesc",
			isPublic:    nil,
			wantUpdates: 1,
		},
		{
			name:        "只更新公开状态",
			nameValue:   "",
			descValue:   "",
			isPublic:    boolPtr(false),
			wantUpdates: 1,
		},
		{
			name:        "没有更新",
			nameValue:   "",
			descValue:   "",
			isPublic:    nil,
			wantUpdates: 0,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			updates := 0
			if tt.nameValue != "" {
				updates++
			}
			if tt.descValue != "" {
				updates++
			}
			if tt.isPublic != nil {
				updates++
			}

			if updates != tt.wantUpdates {
				t.Errorf("Updates count = %d, want %d", updates, tt.wantUpdates)
			}
		})
	}
}

// TestDeleteTexture_PermissionCheck 测试删除材质的权限检查
func TestDeleteTexture_PermissionCheck(t *testing.T) {
	tests := []struct {
		name       string
		uploaderID int64
		requestID  int64
		wantErr    bool
	}{
		{
			name:       "上传者ID匹配，允许删除",
			uploaderID: 1,
			requestID:  1,
			wantErr:    false,
		},
		{
			name:       "上传者ID不匹配，拒绝删除",
			uploaderID: 1,
			requestID:  2,
			wantErr:    true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			hasError := tt.uploaderID != tt.requestID
			if hasError != tt.wantErr {
				t.Errorf("Permission check failed: got %v, want %v", hasError, tt.wantErr)
			}
		})
	}
}

// TestToggleTextureFavorite_Logic 测试切换收藏状态的逻辑
func TestToggleTextureFavorite_Logic(t *testing.T) {
	tests := []struct {
		name        string
		isFavorited bool
		wantResult  bool
	}{
		{
			name:        "已收藏，取消收藏",
			isFavorited: true,
			wantResult:  false,
		},
		{
			name:        "未收藏，添加收藏",
			isFavorited: false,
			wantResult:  true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := !tt.isFavorited
			if result != tt.wantResult {
				t.Errorf("Toggle favorite failed: got %v, want %v", result, tt.wantResult)
			}
		})
	}
}

// TestGetUserTextureFavorites_Pagination 测试收藏列表分页
func TestGetUserTextureFavorites_Pagination(t *testing.T) {
	tests := []struct {
		name     string
		page     int
		pageSize int
		wantPage int
		wantSize int
	}{
		{
			name:     "有效的分页参数",
			page:     1,
			pageSize: 20,
			wantPage: 1,
			wantSize: 20,
		},
		{
			name:     "page小于1，应该设为1",
			page:     0,
			pageSize: 20,
			wantPage: 1,
			wantSize: 20,
		},
		{
			name:     "pageSize超过100，应该设为20",
			page:     1,
			pageSize: 200,
			wantPage: 1,
			wantSize: 20,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			page := tt.page
			pageSize := tt.pageSize

			if page < 1 {
				page = 1
			}
			if pageSize < 1 || pageSize > 100 {
				pageSize = 20
			}

			if page != tt.wantPage {
				t.Errorf("Page = %d, want %d", page, tt.wantPage)
			}
			if pageSize != tt.wantSize {
				t.Errorf("PageSize = %d, want %d", pageSize, tt.wantSize)
			}
		})
	}
}

// TestCheckTextureUploadLimit_Logic 测试上传限制检查逻辑
func TestCheckTextureUploadLimit_Logic(t *testing.T) {
	tests := []struct {
		name        string
		count       int64
		maxTextures int
		wantErr     bool
	}{
		{
			name:        "未达到上限",
			count:       5,
			maxTextures: 10,
			wantErr:     false,
		},
		{
			name:        "达到上限",
			count:       10,
			maxTextures: 10,
			wantErr:     true,
		},
		{
			name:        "超过上限",
			count:       15,
			maxTextures: 10,
			wantErr:     true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			hasError := tt.count >= int64(tt.maxTextures)
			if hasError != tt.wantErr {
				t.Errorf("Limit check failed: got %v, want %v", hasError, tt.wantErr)
			}
		})
	}
}

// 辅助函数
func boolPtr(b bool) *bool {
	return &b
}

// ============================================================================
// 使用 Mock 的集成测试
// ============================================================================

// TestTextureServiceImpl_Create 测试创建Texture
func TestTextureServiceImpl_Create(t *testing.T) {
	textureRepo := NewMockTextureRepository()
	userRepo := NewMockUserRepository()
	logger := zap.NewNop()

	// 预置用户
	testUser := &model.User{
		ID:       1,
		Username: "testuser",
		Email:    "test@example.com",
		Status:   1,
	}
	_ = userRepo.Create(context.Background(), testUser)

	cacheManager := NewMockCacheManager()
	textureService := NewTextureService(textureRepo, userRepo, nil, cacheManager, logger, nil)

	// 构造一份符合 service 大小校验（>=512B）的 PNG 文件数据
	pngFileData := make([]byte, 1024)
	for i := range pngFileData {
		pngFileData[i] = byte(i % 256)
	}
	// 计算其真实 SHA-256，用于 mock 预置与命中分支测试
	existingHash := sha256Hex(pngFileData)
	_ = textureRepo.Create(context.Background(), &model.Texture{
		ID:         100,
		UploaderID: 1,
		Name:       "ExistingTexture",
		Hash:       existingHash,
		URL:        "https://example.com/existing.png",
	})

	tests := []struct {
		name        string
		uploaderID  int64
		textureName string
		textureType string
		fileData    []byte
		wantErr     bool
		errContains string
	}{
		{
			name:        " Hash 已存在 -> 复用 URL",
			uploaderID:  1,
			textureName: "TestSkin",
			textureType: "SKIN",
			fileData:    pngFileData, // hash 命中预置记录
			wantErr:     false,
		},
		{
			name:        "Hash 不存在且 storage 为 nil -> 存储不可用",
			uploaderID:  1,
			textureName: "NewCape",
			textureType: "CAPE",
			fileData:    make([]byte, 1024), // 不同内容，hash 不会命中
			wantErr:     true,
			errContains: "存储服务不可用",
		},
		{
			name:        "用户不存在",
			uploaderID:  999,
			textureName: "TestTexture",
			textureType: "SKIN",
			fileData:    pngFileData,
			wantErr:     true,
		},
		{
			name:        "无效的材质类型",
			uploaderID:  1,
			textureName: "InvalidTypeTexture",
			textureType: "INVALID",
			fileData:    pngFileData,
			wantErr:     true,
			errContains: "无效的材质类型",
		},
		{
			name:        "文件过小",
			uploaderID:  1,
			textureName: "TooSmall",
			textureType: "SKIN",
			fileData:    []byte("tiny"),
			wantErr:     true,
			errContains: "文件大小必须在",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			ctx := context.Background()
			texture, err := textureService.UploadTexture(
				ctx,
				tt.uploaderID,
				tt.textureName,
				"Test description",
				tt.textureType,
				tt.fileData,
				"test.png",
				true,
				false,
			)

			if tt.wantErr {
				if err == nil {
					t.Error("期望返回错误，但实际没有错误")
					return
				}
				if tt.errContains != "" && !containsString(err.Error(), tt.errContains) {
					t.Errorf("错误信息应包含 %q, 实际为: %v", tt.errContains, err.Error())
				}
				return
			}
			if err != nil {
				t.Errorf("不期望返回错误: %v", err)
				return
			}
			if texture == nil {
				t.Fatal("返回的Texture不应为nil")
			}
			if texture.Name != tt.textureName {
				t.Errorf("Texture名称不匹配: got %v, want %v", texture.Name, tt.textureName)
			}
		})
	}
}

// TestTextureServiceImpl_GetByID 测试获取Texture
func TestTextureServiceImpl_GetByID(t *testing.T) {
	textureRepo := NewMockTextureRepository()
	userRepo := NewMockUserRepository()
	logger := zap.NewNop()

	// 预置Texture
	testTexture := &model.Texture{
		ID:         1,
		UploaderID: 1,
		Name:       "TestTexture",
		Hash:       "test-hash",
	}
	_ = textureRepo.Create(context.Background(), testTexture)

	cacheManager := NewMockCacheManager()
	textureService := NewTextureService(textureRepo, userRepo, nil, cacheManager, logger, nil)

	tests := []struct {
		name    string
		id      int64
		wantErr bool
	}{
		{
			name:    "获取存在的Texture",
			id:      1,
			wantErr: false,
		},
		{
			name:    "获取不存在的Texture",
			id:      999,
			wantErr: true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			ctx := context.Background()
			texture, err := textureService.GetByID(ctx, tt.id)

			if tt.wantErr {
				if err == nil {
					t.Error("期望返回错误，但实际没有错误")
				}
			} else {
				if err != nil {
					t.Errorf("不期望返回错误: %v", err)
					return
				}
				if texture == nil {
					t.Error("返回的Texture不应为nil")
				}
			}
		})
	}
}

// TestTextureServiceImpl_GetByUserID_And_Search 测试 GetByUserID 与 Search 分页封装
func TestTextureServiceImpl_GetByUserID_And_Search(t *testing.T) {
	textureRepo := NewMockTextureRepository()
	userRepo := NewMockUserRepository()
	logger := zap.NewNop()

	// 预置多条 Texture
	for i := int64(1); i <= 5; i++ {
		_ = textureRepo.Create(context.Background(), &model.Texture{
			ID:         i,
			UploaderID: 1,
			Name:       "T",
			IsPublic:   i%2 == 0,
		})
	}

	cacheManager := NewMockCacheManager()
	textureService := NewTextureService(textureRepo, userRepo, nil, cacheManager, logger, nil)

	ctx := context.Background()

	// GetByUserID 应按上传者过滤并调用 NormalizePagination
	textures, total, err := textureService.GetByUserID(ctx, 1, 0, 0)
	if err != nil {
		t.Fatalf("GetByUserID 失败: %v", err)
	}
	if total != int64(len(textures)) {
		t.Fatalf("GetByUserID 返回数量与总数不一致, total=%d, len=%d", total, len(textures))
	}

	// Search 仅验证能够正常调用并返回结果
	searchResult, searchTotal, err := textureService.Search(ctx, "", model.TextureTypeSkin, true, -1, 200)
	if err != nil {
		t.Fatalf("Search 失败: %v", err)
	}
	if searchTotal != int64(len(searchResult)) {
		t.Fatalf("Search 返回数量与总数不一致, total=%d, len=%d", searchTotal, len(searchResult))
	}
}

// TestTextureServiceImpl_Update_And_Delete 测试 Update / Delete 权限与字段更新
func TestTextureServiceImpl_Update_And_Delete(t *testing.T) {
	textureRepo := NewMockTextureRepository()
	userRepo := NewMockUserRepository()
	logger := zap.NewNop()

	texture := &model.Texture{
		ID:          1,
		UploaderID:  1,
		Name:        "Old",
		Description: "OldDesc",
		IsPublic:    false,
	}
	_ = textureRepo.Create(context.Background(), texture)

	cacheManager := NewMockCacheManager()
	textureService := NewTextureService(textureRepo, userRepo, nil, cacheManager, logger, nil)

	ctx := context.Background()

	// 更新成功
	newName := "NewName"
	newDesc := "NewDesc"
	public := boolPtr(true)
	updated, err := textureService.Update(ctx, 1, 1, newName, newDesc, public)
	if err != nil {
		t.Fatalf("Update 正常情况失败: %v", err)
	}
	// 由于 MockTextureRepository.UpdateFields 不会真正修改结构体字段，这里只验证不会返回 nil 即可
	if updated == nil {
		t.Fatalf("Update 返回结果不应为 nil")
	}

	// 无权限更新
	if _, err := textureService.Update(ctx, 1, 2, "X", "Y", nil); err == nil {
		t.Fatalf("Update 在无权限时应返回错误")
	}

	// 删除成功
	if err := textureService.Delete(ctx, 1, 1); err != nil {
		t.Fatalf("Delete 正常情况失败: %v", err)
	}

	// 无权限删除
	if err := textureService.Delete(ctx, 1, 2); err == nil {
		t.Fatalf("Delete 在无权限时应返回错误")
	}
}

// TestTextureServiceImpl_FavoritesAndLimit 测试 GetUserFavorites 与 CheckUploadLimit
func TestTextureServiceImpl_FavoritesAndLimit(t *testing.T) {
	textureRepo := NewMockTextureRepository()
	userRepo := NewMockUserRepository()
	logger := zap.NewNop()

	// 预置若干 Texture 与收藏关系
	for i := int64(1); i <= 3; i++ {
		_ = textureRepo.Create(context.Background(), &model.Texture{
			ID:         i,
			UploaderID: 1,
			Name:       "T",
		})
		_ = textureRepo.AddFavorite(context.Background(), 1, i)
	}

	cacheManager := NewMockCacheManager()
	textureService := NewTextureService(textureRepo, userRepo, nil, cacheManager, logger, nil)

	ctx := context.Background()

	// GetUserFavorites
	favs, total, err := textureService.GetUserFavorites(ctx, 1, -1, -1)
	if err != nil {
		t.Fatalf("GetUserFavorites 失败: %v", err)
	}
	if int64(len(favs)) != total || total != 3 {
		t.Fatalf("GetUserFavorites 数量不正确, total=%d, len=%d", total, len(favs))
	}

	// CheckUploadLimit 未超过上限
	if err := textureService.CheckUploadLimit(ctx, 1, 10); err != nil {
		t.Fatalf("CheckUploadLimit 在未达到上限时不应报错: %v", err)
	}

	// CheckUploadLimit 超过上限
	if err := textureService.CheckUploadLimit(ctx, 1, 2); err == nil {
		t.Fatalf("CheckUploadLimit 在超过上限时应返回错误")
	}
}

// TestTextureServiceImpl_ToggleFavorite 测试收藏功能
func TestTextureServiceImpl_ToggleFavorite(t *testing.T) {
	textureRepo := NewMockTextureRepository()
	userRepo := NewMockUserRepository()
	logger := zap.NewNop()

	// 预置用户和Texture
	testUser := &model.User{ID: 1, Username: "testuser", Status: 1}
	_ = userRepo.Create(context.Background(), testUser)

	testTexture := &model.Texture{
		ID:         1,
		UploaderID: 1,
		Name:       "TestTexture",
		Hash:       "test-hash",
	}
	_ = textureRepo.Create(context.Background(), testTexture)

	cacheManager := NewMockCacheManager()
	textureService := NewTextureService(textureRepo, userRepo, nil, cacheManager, logger, nil)

	ctx := context.Background()

	// 第一次收藏
	isFavorited, err := textureService.ToggleFavorite(ctx, 1, 1)
	if err != nil {
		t.Errorf("第一次收藏失败: %v", err)
	}
	if !isFavorited {
		t.Error("第一次操作应该是添加收藏")
	}

	// 第二次取消收藏
	isFavorited, err = textureService.ToggleFavorite(ctx, 1, 1)
	if err != nil {
		t.Errorf("取消收藏失败: %v", err)
	}
	if isFavorited {
		t.Error("第二次操作应该是取消收藏")
	}
}

// 辅助函数
func containsString(s, substr string) bool {
	return len(s) >= len(substr) && (s == substr ||
		(len(s) > len(substr) && (findSubstring(s, substr) != -1)))
}

func findSubstring(s, substr string) int {
	for i := 0; i <= len(s)-len(substr); i++ {
		if s[i:i+len(substr)] == substr {
			return i
		}
	}
	return -1
}