backend/internal/service/texture_service.go

package service

import (
	"carrotskin/internal/model"
	"carrotskin/internal/repository"
	"errors"
	"fmt"

	"gorm.io/gorm"
)

// CreateTexture 创建材质
func CreateTexture(db *gorm.DB, uploaderID int64, name, description, textureType, url, hash string, size int, isPublic, isSlim bool) (*model.Texture, error) {
	// 验证用户存在
	user, err := repository.FindUserByID(uploaderID)
	if err != nil {
		return nil, err
	}
	if user == nil {
		return nil, errors.New("用户不存在")
	}

	// 检查Hash是否已存在
	existingTexture, err := repository.FindTextureByHash(hash)
	if err != nil {
		return nil, err
	}
	if existingTexture != nil {
		return nil, errors.New("该材质已存在")
	}

	// 转换材质类型
	var textureTypeEnum model.TextureType
	switch textureType {
	case "SKIN":
		textureTypeEnum = model.TextureTypeSkin
	case "CAPE":
		textureTypeEnum = model.TextureTypeCape
	default:
		return nil, errors.New("无效的材质类型")
	}

	// 创建材质
	texture := &model.Texture{
		UploaderID:    uploaderID,
		Name:          name,
		Description:   description,
		Type:          textureTypeEnum,
		URL:           url,
		Hash:          hash,
		Size:          size,
		IsPublic:      isPublic,
		IsSlim:        isSlim,
		Status:        1,
		DownloadCount: 0,
		FavoriteCount: 0,
	}

	if err := repository.CreateTexture(texture); err != nil {
		return nil, err
	}

	return texture, nil
}

// GetTextureByID 根据ID获取材质
func GetTextureByID(db *gorm.DB, id int64) (*model.Texture, error) {
	texture, err := repository.FindTextureByID(id)
	if err != nil {
		return nil, err
	}
	if texture == nil {
		return nil, errors.New("材质不存在")
	}
	if texture.Status == -1 {
		return nil, errors.New("材质已删除")
	}
	return texture, nil
}

// GetUserTextures 获取用户上传的材质列表
func GetUserTextures(db *gorm.DB, uploaderID int64, page, pageSize int) ([]*model.Texture, int64, error) {
	if page < 1 {
		page = 1
	}
	if pageSize < 1 || pageSize > 100 {
		pageSize = 20
	}

	return repository.FindTexturesByUploaderID(uploaderID, page, pageSize)
}

// SearchTextures 搜索材质
func SearchTextures(db *gorm.DB, keyword string, textureType model.TextureType, publicOnly bool, page, pageSize int) ([]*model.Texture, int64, error) {
	if page < 1 {
		page = 1
	}
	if pageSize < 1 || pageSize > 100 {
		pageSize = 20
	}

	return repository.SearchTextures(keyword, textureType, publicOnly, page, pageSize)
}

// UpdateTexture 更新材质
func UpdateTexture(db *gorm.DB, textureID, uploaderID int64, name, description string, isPublic *bool) (*model.Texture, error) {
	// 获取材质
	texture, err := repository.FindTextureByID(textureID)
	if err != nil {
		return nil, err
	}
	if texture == nil {
		return nil, errors.New("材质不存在")
	}

	// 检查权限：只有上传者可以修改
	if texture.UploaderID != uploaderID {
		return nil, errors.New("无权修改此材质")
	}

	// 更新字段
	updates := make(map[string]interface{})
	if name != "" {
		updates["name"] = name
	}
	if description != "" {
		updates["description"] = description
	}
	if isPublic != nil {
		updates["is_public"] = *isPublic
	}

	if len(updates) > 0 {
		if err := repository.UpdateTextureFields(textureID, updates); err != nil {
			return nil, err
		}
	}

	// 返回更新后的材质
	return repository.FindTextureByID(textureID)
}

// DeleteTexture 删除材质
func DeleteTexture(db *gorm.DB, textureID, uploaderID int64) error {
	// 获取材质
	texture, err := repository.FindTextureByID(textureID)
	if err != nil {
		return err
	}
	if texture == nil {
		return errors.New("材质不存在")
	}

	// 检查权限：只有上传者可以删除
	if texture.UploaderID != uploaderID {
		return errors.New("无权删除此材质")
	}

	return repository.DeleteTexture(textureID)
}

// RecordTextureDownload 记录下载
func RecordTextureDownload(db *gorm.DB, textureID int64, userID *int64, ipAddress, userAgent string) error {
	// 检查材质是否存在
	texture, err := repository.FindTextureByID(textureID)
	if err != nil {
		return err
	}
	if texture == nil {
		return errors.New("材质不存在")
	}

	// 增加下载次数
	if err := repository.IncrementTextureDownloadCount(textureID); err != nil {
		return err
	}

	// 创建下载日志
	log := &model.TextureDownloadLog{
		TextureID: textureID,
		UserID:    userID,
		IPAddress: ipAddress,
		UserAgent: userAgent,
	}

	return repository.CreateTextureDownloadLog(log)
}

// ToggleTextureFavorite 切换收藏状态
func ToggleTextureFavorite(db *gorm.DB, userID, textureID int64) (bool, error) {
	// 检查材质是否存在
	texture, err := repository.FindTextureByID(textureID)
	if err != nil {
		return false, err
	}
	if texture == nil {
		return false, errors.New("材质不存在")
	}

	// 检查是否已收藏
	isFavorited, err := repository.IsTextureFavorited(userID, textureID)
	if err != nil {
		return false, err
	}

	if isFavorited {
		// 取消收藏
		if err := repository.RemoveTextureFavorite(userID, textureID); err != nil {
			return false, err
		}
		if err := repository.DecrementTextureFavoriteCount(textureID); err != nil {
			return false, err
		}
		return false, nil
	} else {
		// 添加收藏
		if err := repository.AddTextureFavorite(userID, textureID); err != nil {
			return false, err
		}
		if err := repository.IncrementTextureFavoriteCount(textureID); err != nil {
			return false, err
		}
		return true, nil
	}
}

// GetUserTextureFavorites 获取用户收藏的材质列表
func GetUserTextureFavorites(db *gorm.DB, userID int64, page, pageSize int) ([]*model.Texture, int64, error) {
	if page < 1 {
		page = 1
	}
	if pageSize < 1 || pageSize > 100 {
		pageSize = 20
	}

	return repository.GetUserTextureFavorites(userID, page, pageSize)
}

// CheckTextureUploadLimit 检查用户上传材质数量限制
func CheckTextureUploadLimit(db *gorm.DB, uploaderID int64, maxTextures int) error {
	count, err := repository.CountTexturesByUploaderID(uploaderID)
	if err != nil {
		return err
	}

	if count >= int64(maxTextures) {
		return fmt.Errorf("已达到最大上传数量限制(%d)", maxTextures)
	}

	return nil
}