photography/backend/internal/service/user_service.go

package service

import (
	"context"
	"errors"
	"time"

	"photography-backend/internal/model/entity"

	"go.uber.org/zap"
	"golang.org/x/crypto/bcrypt"
	"gorm.io/gorm"
)

type UserService struct {
	db     *gorm.DB
	logger *zap.Logger
}

func NewUserService(db *gorm.DB, logger *zap.Logger) *UserService {
	return &UserService{
		db:     db,
		logger: logger,
	}
}

// UserListParams 用户列表查询参数
type UserListParams struct {
	Page     int    `json:"page" form:"page"`
	Limit    int    `json:"limit" form:"limit"`
	Search   string `json:"search" form:"search"`
	Role     string `json:"role" form:"role"`
	IsActive *bool  `json:"is_active" form:"is_active"`
}

// UserListResponse 用户列表响应
type UserListResponse struct {
	Users []entity.User `json:"users"`
	Total int64         `json:"total"`
	Page  int           `json:"page"`
	Limit int           `json:"limit"`
	Pages int           `json:"pages"`
}

// GetUsers 获取用户列表
func (s *UserService) GetUsers(ctx context.Context, params UserListParams) (*UserListResponse, error) {
	// 设置默认值
	if params.Page <= 0 {
		params.Page = 1
	}
	if params.Limit <= 0 {
		params.Limit = 20
	}
	if params.Limit > 100 {
		params.Limit = 100
	}

	// 构建查询
	query := s.db.WithContext(ctx)

	// 搜索过滤
	if params.Search != "" {
		searchPattern := "%" + params.Search + "%"
		query = query.Where("username ILIKE ? OR email ILIKE ?", searchPattern, searchPattern)
	}

	// 角色过滤
	if params.Role != "" {
		query = query.Where("role = ?", params.Role)
	}

	// 状态过滤
	if params.IsActive != nil {
		query = query.Where("is_active = ?", *params.IsActive)
	}

	// 计算总数
	var total int64
	countQuery := query
	if err := countQuery.Model(&entity.User{}).Count(&total).Error; err != nil {
		s.logger.Error("Failed to count users", zap.Error(err))
		return nil, err
	}

	// 分页查询
	offset := (params.Page - 1) * params.Limit
	var users []entity.User
	if err := query.
		Order("created_at DESC").
		Offset(offset).
		Limit(params.Limit).
		Find(&users).Error; err != nil {
		s.logger.Error("Failed to get users", zap.Error(err))
		return nil, err
	}

	// 计算总页数
	pages := int((total + int64(params.Limit) - 1) / int64(params.Limit))

	return &UserListResponse{
		Users: users,
		Total: total,
		Page:  params.Page,
		Limit: params.Limit,
		Pages: pages,
	}, nil
}

// GetUserByID 根据ID获取用户
func (s *UserService) GetUserByID(ctx context.Context, id uint) (*entity.User, error) {
	var user entity.User
	if err := s.db.WithContext(ctx).First(&user, id).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, errors.New("user not found")
		}
		s.logger.Error("Failed to get user by ID", zap.Error(err), zap.Uint("id", id))
		return nil, err
	}

	return &user, nil
}

// GetUserByUsername 根据用户名获取用户
func (s *UserService) GetUserByUsername(ctx context.Context, username string) (*entity.User, error) {
	var user entity.User
	if err := s.db.WithContext(ctx).Where("username = ?", username).First(&user).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, errors.New("user not found")
		}
		s.logger.Error("Failed to get user by username", zap.Error(err), zap.String("username", username))
		return nil, err
	}

	return &user, nil
}

// GetUserByEmail 根据邮箱获取用户
func (s *UserService) GetUserByEmail(ctx context.Context, email string) (*entity.User, error) {
	var user entity.User
	if err := s.db.WithContext(ctx).Where("email = ?", email).First(&user).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, errors.New("user not found")
		}
		s.logger.Error("Failed to get user by email", zap.Error(err), zap.String("email", email))
		return nil, err
	}

	return &user, nil
}

// CreateUser 创建用户
func (s *UserService) CreateUser(ctx context.Context, req *entity.CreateUserRequest) (*entity.User, error) {
	// 验证用户名唯一性
	var existingUser entity.User
	if err := s.db.WithContext(ctx).Where("username = ?", req.Username).First(&existingUser).Error; err == nil {
		return nil, errors.New("username already exists")
	}

	// 验证邮箱唯一性
	if err := s.db.WithContext(ctx).Where("email = ?", req.Email).First(&existingUser).Error; err == nil {
		return nil, errors.New("email already exists")
	}

	// 加密密码
	hashedPassword, err := bcrypt.GenerateFromPassword([]byte(req.Password), bcrypt.DefaultCost)
	if err != nil {
		s.logger.Error("Failed to hash password", zap.Error(err))
		return nil, err
	}

	user := &entity.User{
		Username: req.Username,
		Email:    req.Email,
		Password: string(hashedPassword),
		Role:     req.Role,
		IsActive: true,
	}

	if err := s.db.WithContext(ctx).Create(user).Error; err != nil {
		s.logger.Error("Failed to create user", zap.Error(err))
		return nil, err
	}

	s.logger.Info("User created successfully", zap.Uint("id", user.ID))
	return user, nil
}

// UpdateUser 更新用户
func (s *UserService) UpdateUser(ctx context.Context, id uint, req *entity.UpdateUserRequest) (*entity.User, error) {
	// 检查用户是否存在
	var user entity.User
	if err := s.db.WithContext(ctx).First(&user, id).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, errors.New("user not found")
		}
		return nil, err
	}

	// 构建更新数据
	updates := map[string]interface{}{}
	
	if req.Username != nil {
		// 验证用户名唯一性
		var existingUser entity.User
		if err := s.db.WithContext(ctx).Where("username = ? AND id != ?", *req.Username, id).First(&existingUser).Error; err == nil {
			return nil, errors.New("username already exists")
		}
		updates["username"] = *req.Username
	}
	
	if req.Email != nil {
		// 验证邮箱唯一性
		var existingUser entity.User
		if err := s.db.WithContext(ctx).Where("email = ? AND id != ?", *req.Email, id).First(&existingUser).Error; err == nil {
			return nil, errors.New("email already exists")
		}
		updates["email"] = *req.Email
	}
	
	if req.Role != nil {
		updates["role"] = *req.Role
	}
	
	if req.IsActive != nil {
		updates["is_active"] = *req.IsActive
	}

	if len(updates) > 0 {
		if err := s.db.WithContext(ctx).Model(&user).Updates(updates).Error; err != nil {
			s.logger.Error("Failed to update user", zap.Error(err))
			return nil, err
		}
	}

	s.logger.Info("User updated successfully", zap.Uint("id", id))
	return &user, nil
}

// UpdateCurrentUser 更新当前用户信息
func (s *UserService) UpdateCurrentUser(ctx context.Context, id uint, req *entity.UpdateCurrentUserRequest) (*entity.User, error) {
	// 检查用户是否存在
	var user entity.User
	if err := s.db.WithContext(ctx).First(&user, id).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, errors.New("user not found")
		}
		return nil, err
	}

	// 构建更新数据
	updates := map[string]interface{}{}
	
	if req.Username != nil {
		// 验证用户名唯一性
		var existingUser entity.User
		if err := s.db.WithContext(ctx).Where("username = ? AND id != ?", *req.Username, id).First(&existingUser).Error; err == nil {
			return nil, errors.New("username already exists")
		}
		updates["username"] = *req.Username
	}
	
	if req.Email != nil {
		// 验证邮箱唯一性
		var existingUser entity.User
		if err := s.db.WithContext(ctx).Where("email = ? AND id != ?", *req.Email, id).First(&existingUser).Error; err == nil {
			return nil, errors.New("email already exists")
		}
		updates["email"] = *req.Email
	}

	if len(updates) > 0 {
		if err := s.db.WithContext(ctx).Model(&user).Updates(updates).Error; err != nil {
			s.logger.Error("Failed to update current user", zap.Error(err))
			return nil, err
		}
	}

	s.logger.Info("Current user updated successfully", zap.Uint("id", id))
	return &user, nil
}

// DeleteUser 删除用户
func (s *UserService) DeleteUser(ctx context.Context, id uint) error {
	// 检查用户是否存在
	var user entity.User
	if err := s.db.WithContext(ctx).First(&user, id).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return errors.New("user not found")
		}
		return err
	}

	// 删除用户
	if err := s.db.WithContext(ctx).Delete(&user).Error; err != nil {
		s.logger.Error("Failed to delete user", zap.Error(err))
		return err
	}

	s.logger.Info("User deleted successfully", zap.Uint("id", id))
	return nil
}

// ChangePassword 修改密码
func (s *UserService) ChangePassword(ctx context.Context, id uint, req *entity.ChangePasswordRequest) error {
	// 检查用户是否存在
	var user entity.User
	if err := s.db.WithContext(ctx).First(&user, id).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return errors.New("user not found")
		}
		return err
	}

	// 验证旧密码
	if err := bcrypt.CompareHashAndPassword([]byte(user.Password), []byte(req.OldPassword)); err != nil {
		return errors.New("old password is incorrect")
	}

	// 加密新密码
	hashedPassword, err := bcrypt.GenerateFromPassword([]byte(req.NewPassword), bcrypt.DefaultCost)
	if err != nil {
		s.logger.Error("Failed to hash new password", zap.Error(err))
		return err
	}

	// 更新密码
	if err := s.db.WithContext(ctx).Model(&user).Update("password", string(hashedPassword)).Error; err != nil {
		s.logger.Error("Failed to update password", zap.Error(err))
		return err
	}

	s.logger.Info("Password changed successfully", zap.Uint("id", id))
	return nil
}

// ValidateCredentials 验证用户凭据
func (s *UserService) ValidateCredentials(ctx context.Context, username, password string) (*entity.User, error) {
	var user entity.User
	
	// 根据用户名或邮箱查找用户
	if err := s.db.WithContext(ctx).Where("username = ? OR email = ?", username, username).First(&user).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, errors.New("invalid credentials")
		}
		s.logger.Error("Failed to find user", zap.Error(err))
		return nil, err
	}

	// 检查用户是否激活
	if !user.IsActive {
		return nil, errors.New("user account is disabled")
	}

	// 验证密码
	if err := bcrypt.CompareHashAndPassword([]byte(user.Password), []byte(password)); err != nil {
		return nil, errors.New("invalid credentials")
	}

	return &user, nil
}

// GetUserStats 获取用户统计信息
func (s *UserService) GetUserStats(ctx context.Context) (*entity.UserStats, error) {
	var stats entity.UserStats

	// 总用户数
	if err := s.db.WithContext(ctx).Model(&entity.User{}).Count(&stats.Total).Error; err != nil {
		return nil, err
	}

	// 活跃用户数
	if err := s.db.WithContext(ctx).Model(&entity.User{}).
		Where("is_active = ?", true).Count(&stats.Active).Error; err != nil {
		return nil, err
	}

	// 按角色统计
	var roleStats []struct {
		Role  string `json:"role"`
		Count int64  `json:"count"`
	}
	if err := s.db.WithContext(ctx).Model(&entity.User{}).
		Select("role, COUNT(*) as count").
		Where("is_active = ?", true).
		Group("role").
		Find(&roleStats).Error; err != nil {
		return nil, err
	}

	stats.RoleStats = make(map[string]int64)
	for _, stat := range roleStats {
		stats.RoleStats[stat.Role] = stat.Count
	}

	// 本月新增用户
	startOfMonth := time.Now().AddDate(0, 0, -time.Now().Day()+1)
	if err := s.db.WithContext(ctx).Model(&entity.User{}).
		Where("created_at >= ?", startOfMonth).
		Count(&stats.ThisMonth).Error; err != nil {
		return nil, err
	}

	// 今日新增用户
	startOfDay := time.Now().Truncate(24 * time.Hour)
	if err := s.db.WithContext(ctx).Model(&entity.User{}).
		Where("created_at >= ?", startOfDay).
		Count(&stats.Today).Error; err != nil {
		return nil, err
	}

	return &stats, nil
}

// IsUsernameAvailable 检查用户名是否可用
func (s *UserService) IsUsernameAvailable(ctx context.Context, username string) (bool, error) {
	var count int64
	if err := s.db.WithContext(ctx).Model(&entity.User{}).
		Where("username = ?", username).Count(&count).Error; err != nil {
		return false, err
	}
	return count == 0, nil
}

// IsEmailAvailable 检查邮箱是否可用
func (s *UserService) IsEmailAvailable(ctx context.Context, email string) (bool, error) {
	var count int64
	if err := s.db.WithContext(ctx).Model(&entity.User{}).
		Where("email = ?", email).Count(&count).Error; err != nil {
		return false, err
	}
	return count == 0, nil
}