⭐ Enhanced模式插件开发指南¶

// Enhanced插件的典型结构
package myenhanced

import (
    "time"
    "github.com/ruk1ng001/wxbot/engine/control"
    "github.com/ruk1ng001/wxbot/engine/robot"
    "github.com/ruk1ng001/wxbot/engine/pkg/sqlite"
    "github.com/ruk1ng001/wxbot/engine/pkg/monitor"
)

var (
    db         sqlite.DB
    pluginName = "myenhanced"
)

// Enhanced数据模型
type UserStats struct {
    UserID      string    `gorm:"primaryKey"`
    UserName    string    `gorm:"column:user_name"`
    TotalCount  int       `gorm:"column:total_count"`
    SuccessRate float64   `gorm:"column:success_rate"`
    Level       int       `gorm:"column:level"`
    LastActive  time.Time `gorm:"column:last_active"`
    CreatedAt   time.Time `gorm:"column:created_at"`
    UpdatedAt   time.Time `gorm:"column:updated_at"`
}

type UserPreferences struct {
    UserID     string `gorm:"primaryKey"`
    Difficulty int    `gorm:"column:difficulty"`      // 难度偏好
    Theme      string `gorm:"column:theme"`           // 主题偏好
    Language   string `gorm:"column:language"`        // 语言偏好
    Settings   string `gorm:"column:settings;type:json"` // JSON设置
}

func init() {
    engine := control.Register(pluginName, &control.Options{
        Alias:            "Enhanced示例",
        Help:             "Enhanced模式开发示例\n• 自动统计用户数据\n• 个性化体验\n• 等级系统",
        DataFolder:       pluginName,
        DisableOnDefault: false,
    })

    // 初始化数据库
    initEnhancedDatabase(engine.GetDataFolder())

    // 注册插件名称到监控系统
    robot.RegisterEnginePluginName(engine, pluginName)

    // 注册处理器
    engine.OnPrefix("enhanced").SetBlock(true).Handle(enhancedHandler)
    engine.OnPrefix("我的统计").Handle(userStatsHandler)
    engine.OnPrefix("排行榜").Handle(leaderboardHandler)
    engine.OnPrefix("设置难度").Handle(setDifficultyHandler)

    // 管理员功能
    engine.OnCommand("enhanced_admin", robot.AdminPermission).Handle(adminHandler)
}

func initEnhancedDatabase(dataFolder string) {
    if err := sqlite.Open(dataFolder+"/enhanced.db", &db); err != nil {
        panic(err)
    }

    // 创建表
    if err := db.Create("user_stats", &UserStats{}); err != nil {
        panic(err)
    }
    if err := db.Create("user_preferences", &UserPreferences{}); err != nil {
        panic(err)
    }

    // 创建索引
    db.Orm.Exec("CREATE INDEX IF NOT EXISTS idx_user_stats_level ON user_stats(level)")
    db.Orm.Exec("CREATE INDEX IF NOT EXISTS idx_user_stats_total_count ON user_stats(total_count)")
}

func enhancedHandler(ctx *robot.Ctx) {
    userId := ctx.Event.FinalFromWxId
    userName := ctx.Event.FinalFromName

    // 更新用户统计
    stats := updateUserStats(userId, userName)

    // 获取用户偏好
    prefs := getUserPreferences(userId)

    // 生成个性化响应
    response := generatePersonalizedResponse(stats, prefs)
    ctx.ReplyTextAndAt(response)
}

func updateUserStats(userId, userName string) *UserStats {
    var stats UserStats
    err := db.Orm.Where("user_id = ?", userId).First(&stats).Error

    if err != nil {
        // 新用户
        stats = UserStats{
            UserID:     userId,
            UserName:   userName,
            TotalCount: 1,
            Level:      1,
            LastActive: time.Now(),
            CreatedAt:  time.Now(),
            UpdatedAt:  time.Now(),
        }
        db.Orm.Create(&stats)
    } else {
        // 更新现有用户
        stats.TotalCount++
        stats.LastActive = time.Now()
        stats.UpdatedAt = time.Now()

        // 升级逻辑
        newLevel := calculateLevel(stats.TotalCount)
        if newLevel > stats.Level {
            stats.Level = newLevel
            // 发送升级通知
            sendLevelUpNotification(userId, userName, newLevel)
        }

        db.Orm.Save(&stats)
    }

    return &stats
}

func calculateLevel(totalCount int) int {
    switch {
    case totalCount >= 1000:
        return 10 // 传奇
    case totalCount >= 500:
        return 9  // 大师
    case totalCount >= 200:
        return 8  // 专家
    case totalCount >= 100:
        return 7  // 高级
    case totalCount >= 50:
        return 6  // 中级+
    case totalCount >= 25:
        return 5  // 中级
    case totalCount >= 15:
        return 4  // 初级+
    case totalCount >= 8:
        return 3  // 初级
    case totalCount >= 3:
        return 2  // 新手+
    default:
        return 1  // 新手
    }
}

func sendLevelUpNotification(userId, userName string, newLevel int) {
    levelNames := map[int]string{
        2: "新手+", 3: "初级", 4: "初级+", 5: "中级",
        6: "中级+", 7: "高级", 8: "专家", 9: "大师", 10: "传奇",
    }

    message := fmt.Sprintf("🎉 恭喜 %s 升级到 %s 级别！", userName, levelNames[newLevel])

    // 这里可以发送升级通知，但需要上下文，在实际应用中可以通过事件系统实现
}

func generatePersonalizedResponse(stats *UserStats, prefs *UserPreferences) string {
    var response strings.Builder

    // 根据等级生成不同的问候语
    greeting := getGreetingByLevel(stats.Level)
    response.WriteString(greeting + "\n\n")

    // 显示个人统计
    response.WriteString(fmt.Sprintf("📊 你的数据：\n"))
    response.WriteString(fmt.Sprintf("🏅 等级：%d级 (%s)\n", stats.Level, getLevelName(stats.Level)))
    response.WriteString(fmt.Sprintf("📈 使用次数：%d次\n", stats.TotalCount))

    // 计算距离下一级的进度
    nextLevelRequirement := getNextLevelRequirement(stats.Level)
    if nextLevelRequirement > 0 {
        remaining := nextLevelRequirement - stats.TotalCount
        response.WriteString(fmt.Sprintf("🎯 距离下一级还需：%d次\n", remaining))
    }

    // 根据偏好调整内容
    if prefs != nil && prefs.Difficulty > 0 {
        response.WriteString(fmt.Sprintf("⚙️ 当前难度：%s\n", getDifficultyName(prefs.Difficulty)))
    }

    // 添加激励信息
    motivation := getMotivationMessage(stats.Level, stats.TotalCount)
    response.WriteString("\n" + motivation)

    return response.String()
}

func getGreetingByLevel(level int) string {
    greetings := map[int]string{
        1: "🌟 新手用户，欢迎使用Enhanced功能！",
        2: "⭐ 新手+，你已经开始熟悉了！",
        3: "🏆 初级用户，继续保持！",
        4: "💎 初级+，表现不错！",
        5: "🎖️ 中级用户，你很厉害！",
        6: "🏅 中级+，持续进步中！",
        7: "👑 高级用户，你是我们的忠实用户！",
        8: "🌟 专家级别，技能超群！",
        9: "🚀 大师级别，令人敬佩！",
        10: "🏆 传奇用户，无人能敌！",
    }

    if greeting, exists := greetings[level]; exists {
        return greeting
    }
    return "👋 你好！欢迎使用Enhanced功能！"
}

func getUserPreferences(userId string) *UserPreferences {
    var prefs UserPreferences
    err := db.Orm.Where("user_id = ?", userId).First(&prefs).Error
    if err != nil {
        // 创建默认偏好
        prefs = UserPreferences{
            UserID:     userId,
            Difficulty: 2, // 默认中等难度
            Theme:      "default",
            Language:   "zh-CN",
            Settings:   "{}",
        }
        db.Orm.Create(&prefs)
    }
    return &prefs
}

func leaderboardHandler(ctx *robot.Ctx) {
    // 获取不同类型的排行榜
    arg := ctx.State["args"].(string)

    var response string
    switch arg {
    case "等级", "level":
        response = generateLevelLeaderboard()
    case "活跃", "active":
        response = generateActiveLeaderboard()
    case "总榜", "total", "":
        response = generateTotalLeaderboard()
    default:
        response = "📋 排行榜类型：\n• 排行榜 等级 - 等级排行\n• 排行榜 活跃 - 活跃度排行\n• 排行榜 总榜 - 综合排行"
    }

    ctx.ReplyText(response)
}

func generateTotalLeaderboard() string {
    var topUsers []UserStats
    db.Orm.Order("total_count DESC").Limit(10).Find(&topUsers)

    if len(topUsers) == 0 {
        return "📊 暂无排行数据"
    }

    var response strings.Builder
    response.WriteString("🏆 Enhanced使用排行榜 TOP10:\n\n")

    for i, user := range topUsers {
        emoji := getRankEmoji(i + 1)
        levelName := getLevelName(user.Level)

        response.WriteString(fmt.Sprintf("%s %d. %s\n", emoji, i+1, user.UserName))
        response.WriteString(fmt.Sprintf("    📊 %d次 | 🏅 %s | ⏰ %s\n\n",
            user.TotalCount,
            levelName,
            user.LastActive.Format("01-02 15:04")))
    }

    return response.String()
}

func generateLevelLeaderboard() string {
    var topUsers []UserStats
    db.Orm.Order("level DESC, total_count DESC").Limit(10).Find(&topUsers)

    var response strings.Builder
    response.WriteString("🏅 等级排行榜 TOP10:\n\n")

    for i, user := range topUsers {
        emoji := getRankEmoji(i + 1)
        levelName := getLevelName(user.Level)

        response.WriteString(fmt.Sprintf("%s %d. %s - %s\n",
            emoji, i+1, user.UserName, levelName))
    }

    return response.String()
}

func getRankEmoji(rank int) string {
    switch rank {
    case 1:
        return "🥇"
    case 2:
        return "🥈"
    case 3:
        return "🥉"
    default:
        return "🏆"
    }
}

func setDifficultyHandler(ctx *robot.Ctx) {
    userId := ctx.Event.FinalFromWxId
    arg := ctx.State["args"].(string)

    if arg == "" {
        ctx.ReplyTextAndAt("请指定难度等级：\n• 设置难度 1 - 简单\n• 设置难度 2 - 中等\n• 设置难度 3 - 困难\n• 设置难度 4 - 专家")
        return
    }

    difficulty, err := strconv.Atoi(arg)
    if err != nil || difficulty < 1 || difficulty > 4 {
        ctx.ReplyTextAndAt("难度等级必须是1-4之间的数字")
        return
    }

    // 更新用户偏好
    var prefs UserPreferences
    db.Orm.Where("user_id = ?", userId).First(&prefs)

    prefs.UserID = userId
    prefs.Difficulty = difficulty

    db.Orm.Save(&prefs)

    difficultyName := getDifficultyName(difficulty)
    ctx.ReplyTextAndAt(fmt.Sprintf("✅ 难度已设置为：%s", difficultyName))
}

func getDifficultyName(difficulty int) string {
    names := map[int]string{
        1: "简单",
        2: "中等", 
        3: "困难",
        4: "专家",
    }
    if name, exists := names[difficulty]; exists {
        return name
    }
    return "未知"
}

type UserBehaviorAnalysis struct {
    UserID          string    `gorm:"primaryKey"`
    ActiveHours     string    `gorm:"column:active_hours;type:json"`     // 活跃时段
    PreferredFeatures string  `gorm:"column:preferred_features;type:json"` // 偏好功能
    UsagePattern    string    `gorm:"column:usage_pattern"`              // 使用模式
    Engagement      float64   `gorm:"column:engagement"`                 // 参与度
    LastAnalysis    time.Time `gorm:"column:last_analysis"`
}

func analyzeUserBehavior(userId string) *UserBehaviorAnalysis {
    // 分析用户使用时段
    activeHours := analyzeActiveHours(userId)

    // 分析偏好功能
    preferredFeatures := analyzePreferredFeatures(userId)

    // 计算参与度
    engagement := calculateEngagement(userId)

    // 识别使用模式
    pattern := identifyUsagePattern(userId)

    analysis := &UserBehaviorAnalysis{
        UserID:            userId,
        ActiveHours:       activeHours,
        PreferredFeatures: preferredFeatures,
        UsagePattern:      pattern,
        Engagement:        engagement,
        LastAnalysis:      time.Now(),
    }

    // 保存分析结果
    db.Orm.Save(analysis)

    return analysis
}

func generatePersonalizedRecommendations(userId string) []string {
    analysis := analyzeUserBehavior(userId)
    var recommendations []string

    // 基于参与度的推荐
    if analysis.Engagement < 0.3 {
        recommendations = append(recommendations, "🎯 建议尝试简单模式，提升使用体验")
    } else if analysis.Engagement > 0.8 {
        recommendations = append(recommendations, "🚀 你很活跃！试试专家模式挑战吧")
    }

    // 基于使用模式的推荐
    switch analysis.UsagePattern {
    case "casual":
        recommendations = append(recommendations, "📱 轻度用户，建议开启每日提醒")
    case "regular":
        recommendations = append(recommendations, "⭐ 规律用户，可以参与排行榜竞争")
    case "intensive":
        recommendations = append(recommendations, "🏆 重度用户，建议尝试高级功能")
    }

    return recommendations
}

type GroupAnalysis struct {
    GroupID         string    `gorm:"primaryKey"`
    MemberCount     int       `gorm:"column:member_count"`
    ActiveUsers     int       `gorm:"column:active_users"`
    EngagementRate  float64   `gorm:"column:engagement_rate"`
    CompetitionLevel string   `gorm:"column:competition_level"`
    TopFeatures     string    `gorm:"column:top_features;type:json"`
    LastAnalysis    time.Time `gorm:"column:last_analysis"`
}

func analyzeGroupDynamics(groupId string) *GroupAnalysis {
    // 获取群成员统计
    var memberStats []UserStats
    db.Orm.Joins("JOIN group_members ON user_stats.user_id = group_members.user_id").
        Where("group_members.group_id = ?", groupId).
        Find(&memberStats)

    if len(memberStats) == 0 {
        return nil
    }

    // 计算活跃用户数
    activeUsers := 0
    totalEngagement := 0.0

    for _, stat := range memberStats {
        if time.Since(stat.LastActive) < 7*24*time.Hour { // 7天内活跃
            activeUsers++
        }
        totalEngagement += float64(stat.TotalCount)
    }

    engagementRate := totalEngagement / float64(len(memberStats))
    competitionLevel := determineCompetitionLevel(memberStats)

    analysis := &GroupAnalysis{
        GroupID:          groupId,
        MemberCount:      len(memberStats),
        ActiveUsers:      activeUsers,
        EngagementRate:   engagementRate,
        CompetitionLevel: competitionLevel,
        LastAnalysis:     time.Now(),
    }

    db.Orm.Save(analysis)
    return analysis
}

func determineCompetitionLevel(stats []UserStats) string {
    if len(stats) < 5 {
        return "low"
    }

    highLevelUsers := 0
    for _, stat := range stats {
        if stat.Level >= 5 {
            highLevelUsers++
        }
    }

    ratio := float64(highLevelUsers) / float64(len(stats))

    switch {
    case ratio > 0.5:
        return "high"
    case ratio > 0.2:
        return "medium"
    default:
        return "low"
    }
}

// ✅ 好的设计 - 规范化和索引
type UserStats struct {
    UserID      string    `gorm:"primaryKey;index"`
    UserName    string    `gorm:"column:user_name;index"`
    TotalCount  int       `gorm:"column:total_count;index"`
    Level       int       `gorm:"column:level;index"`
    LastActive  time.Time `gorm:"column:last_active;index"`
    CreatedAt   time.Time `gorm:"column:created_at"`
    UpdatedAt   time.Time `gorm:"column:updated_at"`
}

// ❌ 差的设计 - 缺少索引和规范化
type BadUserStats struct {
    UserID string
    Data   string // JSON字符串，不易查询
}

// ✅ 批量操作
func batchUpdateStats(userUpdates []UserStats) error {
    return db.Orm.Transaction(func(tx *gorm.DB) error {
        for _, update := range userUpdates {
            if err := tx.Save(&update).Error; err != nil {
                return err
            }
        }
        return nil
    })
}

// ✅ 缓存频繁查询
var levelCache = sync.Map{}

func getCachedLevel(userId string) int {
    if level, ok := levelCache.Load(userId); ok {
        return level.(int)
    }

    var stats UserStats
    db.Orm.Select("level").Where("user_id = ?", userId).First(&stats)
    levelCache.Store(userId, stats.Level)

    return stats.Level
}

func enhancedHandlerWithMonitoring(ctx *robot.Ctx) {
    start := time.Now()

    defer func() {
        duration := time.Since(start)

        // 记录业务指标
        if duration > 500*time.Millisecond {
            monitor.GlobalMetrics.RecordSlowOperation("enhanced_handler", duration)
        }

        // 记录用户行为
        monitor.GlobalMetrics.RecordUserAction(ctx.Event.FinalFromWxId, "enhanced_usage")
    }()

    // 业务逻辑
    enhancedBusinessLogic(ctx)
}