辣评作者自述功能开发（十二）

// AuthorBio 作者自述模型
type AuthorBio struct {
    ID              uint      `gorm:"primaryKey"`
    SubmissionID    uint      `gorm:"uniqueIndex"`
    UserID          uint      `gorm:"index"`
    Content         string    `gorm:"type:text"`
    WordCount       int       // 字数统计
    IsPublished     bool      // 是否已发布
    PublishedAt     *time.Time
    CreatedAt       time.Time
    UpdatedAt       time.Time
    DeletedAt       gorm.DeletedAt `gorm:"index"`
    
    // 关联
    Submission      *Submission
    User            *User
}

// AuthorBioVersion 作者自述版本历史
type AuthorBioVersion struct {
    ID              uint
    AuthorBioID     uint
    Content         string    `gorm:"type:text"`
    WordCount       int
    VersionNumber   int
    ChangeSummary   string
    CreatedAt       time.Time
}

// AuthorBioTemplate 作者自述模板
type AuthorBioTemplate struct {
    ID              uint
    Title           string
    Description     string
    Content         string    `gorm:"type:text"`
    IsActive        bool
    CreatedAt       time.Time
}

// CreateAuthorBio 创建作者自述
func (s *AuthorBioService) CreateAuthorBio(ctx context.Context, submissionID, userID uint, content string) (*AuthorBio, error) {
    // 1. 验证权限
    submission := &Submission{}
    if err := s.db.First(submission, submissionID).Error; err != nil {
        return nil, err
    }
    
    if submission.UserID != userID {
        return nil, errors.New("无权为此投稿添加自述")
    }
    
    // 2. 验证内容
    if err := s.validateBioContent(content); err != nil {
        return nil, err
    }
    
    // 3. 计算字数
    wordCount := s.countWords(content)
    
    // 4. 创建自述
    bio := &AuthorBio{
        SubmissionID: submissionID,
        UserID:       userID,
        Content:      content,
        WordCount:    wordCount,
        IsPublished:  true,
        PublishedAt:  timePtr(time.Now()),
    }
    
    if err := s.db.Create(bio).Error; err != nil {
        return nil, err
    }
    
    // 5. 记录版本
    s.createBioVersion(ctx, bio.ID, content, wordCount, 1, "初始版本")
    
    return bio, nil
}

// UpdateAuthorBio 更新作者自述
func (s *AuthorBioService) UpdateAuthorBio(ctx context.Context, bioID, userID uint, content string) (*AuthorBio, error) {
    bio := &AuthorBio{}
    
    // 1. 获取自述
    if err := s.db.First(bio, bioID).Error; err != nil {
        return nil, err
    }
    
    // 2. 验证权限
    if bio.UserID != userID {
        return nil, errors.New("无权编辑此自述")
    }
    
    // 3. 验证内容
    if err := s.validateBioContent(content); err != nil {
        return nil, err
    }
    
    // 4. 计算新的字数
    newWordCount := s.countWords(content)
    
    // 5. 记录旧版本
    oldVersion := &AuthorBioVersion{
        AuthorBioID:   bioID,
        Content:       bio.Content,
        WordCount:     bio.WordCount,
        VersionNumber: 1,
        ChangeSummary: "编辑前版本",
    }
    s.db.Create(oldVersion)
    
    // 6. 更新自述
    updates := map[string]interface{}{
        "content":    content,
        "word_count": newWordCount,
    }
    
    if err := s.db.Model(bio).Updates(updates).Error; err != nil {
        return nil, err
    }
    
    // 7. 记录新版本
    s.createBioVersion(ctx, bioID, content, newWordCount, 2, "用户编辑")
    
    return bio, nil
}

// GetAuthorBio 获取作者自述
func (s *AuthorBioService) GetAuthorBio(ctx context.Context, submissionID uint) (*AuthorBio, error) {
    bio := &AuthorBio{}
    
    if err := s.db.Where("submission_id = ?", submissionID).
        First(bio).Error; err != nil {
        return nil, err
    }
    
    return bio, nil
}

// validateBioContent 验证自述内容
func (s *AuthorBioService) validateBioContent(content string) error {
    // 1. 检查内容长度
    if len(content) == 0 {
        return errors.New("自述内容不能为空")
    }
    
    if len(content) < 10 {
        return errors.New("自述内容过短，至少需要10个字符")
    }
    
    if len(content) > 5000 {
        return errors.New("自述内容过长，最多5000个字符")
    }
    
    // 2. 检查字数
    wordCount := s.countWords(content)
    if wordCount > 1000 {
        return errors.New("自述字数过多，最多1000字")
    }
    
    // 3. 检查敏感词
    if s.containsSensitiveWords(content) {
        return errors.New("自述内容包含不适当的词汇")
    }
    
    return nil
}

// countWords 统计字数
func (s *AuthorBioService) countWords(content string) int {
    // 移除空白字符
    content = strings.TrimSpace(content)
    
    // 统计字数（支持中文和英文）
    count := 0
    inWord := false
    
    for _, r := range content {
        if unicode.IsLetter(r) || unicode.IsNumber(r) {
            if !inWord {
                count++
                inWord = true
            }
        } else if unicode.IsPunct(r) || unicode.IsSpace(r) {
            inWord = false
        } else if unicode.Is(unicode.Han, r) {
            // 中文字符单独计数
            count++
        }
    }
    
    return count
}

// GetWordCountStats 获取字数统计
func (s *AuthorBioService) GetWordCountStats(ctx context.Context, competitionID uint) (*WordCountStatistics, error) {
    stats := &WordCountStatistics{}
    
    // 统计平均字数
    s.db.Model(&AuthorBio{}).
        Joins("JOIN submissions ON author_bios.submission_id = submissions.id").
        Where("submissions.competition_id = ?", competitionID).
        Select("AVG(word_count) as avg_word_count").
        Row().
        Scan(&stats.AverageWordCount)
    
    // 统计最大字数
    s.db.Model(&AuthorBio{}).
        Joins("JOIN submissions ON author_bios.submission_id = submissions.id").
        Where("submissions.competition_id = ?", competitionID).
        Select("MAX(word_count) as max_word_count").
        Row().
        Scan(&stats.MaxWordCount)
    
    // 统计最小字数
    s.db.Model(&AuthorBio{}).
        Joins("JOIN submissions ON author_bios.submission_id = submissions.id").
        Where("submissions.competition_id = ?", competitionID).
        Select("MIN(word_count) as min_word_count").
        Row().
        Scan(&stats.MinWordCount)
    
    return stats, nil
}

// GetBioVersions 获取自述版本历史
func (s *AuthorBioService) GetBioVersions(ctx context.Context, bioID uint) ([]AuthorBioVersion, error) {
    var versions []AuthorBioVersion
    
    if err := s.db.Where("author_bio_id = ?", bioID).
        Order("version_number DESC").
        Find(&versions).Error; err != nil {
        return nil, err
    }
    
    return versions, nil
}

// RestoreBioVersion 恢复自述版本
func (s *AuthorBioService) RestoreBioVersion(ctx context.Context, versionID, userID uint) error {
    version := &AuthorBioVersion{}
    if err := s.db.First(version, versionID).Error; err != nil {
        return err
    }
    
    bio := &AuthorBio{}
    if err := s.db.First(bio, version.AuthorBioID).Error; err != nil {
        return err
    }
    
    // 验证权限
    if bio.UserID != userID {
        return errors.New("无权恢复此版本")
    }
    
    // 恢复内容
    return s.db.Model(bio).Updates(map[string]interface{}{
        "content":    version.Content,
        "word_count": version.WordCount,
    }).Error
}