package mcpTool

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"os"
	"path/filepath"
	"strings"
	"time"
	"unicode"

	"git.echol.cn/loser/lckt/global"
	common "git.echol.cn/loser/lckt/model/common/request"
	model "git.echol.cn/loser/lckt/model/system"
	"git.echol.cn/loser/lckt/model/system/request"
	"git.echol.cn/loser/lckt/service"
	systemService "git.echol.cn/loser/lckt/service/system"
	"github.com/mark3labs/mcp-go/mcp"
	"gorm.io/gorm"
)

func init() {
	RegisterTool(&AutomationModuleAnalyzer{})
}

type AutomationModuleAnalyzer struct{}

// ModuleInfo 模块信息
type ModuleInfo struct {
	ID          uint   `json:"id"`
	PackageName string `json:"packageName"`
	Label       string `json:"label"`
	Desc        string `json:"desc"`
	Template    string `json:"template"` // "plugin" 或 "package"
	Module      string `json:"module"`
}

// HistoryInfo 历史记录信息
type HistoryInfo struct {
	ID           uint   `json:"id"`
	StructName   string `json:"structName"`
	TableName    string `json:"tableName"`
	PackageName  string `json:"packageName"`
	BusinessDB   string `json:"businessDB"`
	Description  string `json:"description"`
	Abbreviation string `json:"abbreviation"`
	CreatedAt    string `json:"createdAt"`
}

// PredesignedModuleInfo 预设计模块信息
type PredesignedModuleInfo struct {
	PackageName string   `json:"packageName"`
	PackageType string   `json:"packageType"` // "plugin" 或 "package"
	ModuleName  string   `json:"moduleName"`
	Path        string   `json:"path"`
	Modules     []string `json:"modules"` // 包含的模块列表（如api、model、service等）
	Description string   `json:"description"`
	StructName  string   `json:"structName,omitempty"` // 主要结构体名称
}

// AnalysisResponse 分析响应
type AnalysisResponse struct {
	Packages           []ModuleInfo            `json:"packages"`
	History            []HistoryInfo           `json:"history"`
	PredesignedModules []PredesignedModuleInfo `json:"predesignedModules"`
	Message            string                  `json:"message"`
}

// ExecutionPlan 执行计划 - 支持批量创建
type ExecutionPlan struct {
	PackageName        string                            `json:"packageName"`
	PackageType        string                            `json:"packageType"` // "plugin" 或 "package"
	NeedCreatedPackage bool                              `json:"needCreatedPackage"`
	NeedCreatedModules bool                              `json:"needCreatedModules"`
	PackageInfo        *request.SysAutoCodePackageCreate `json:"packageInfo,omitempty"`
	ModulesInfo        []*request.AutoCode               `json:"modulesInfo,omitempty"` // 改为数组支持多个模块
	Paths              map[string]string                 `json:"paths,omitempty"`
}

// ExecutionResult 执行结果
type ExecutionResult struct {
	Success     bool              `json:"success"`
	Message     string            `json:"message"`
	PackageID   uint              `json:"packageId,omitempty"`
	HistoryID   uint              `json:"historyId,omitempty"`
	Paths       map[string]string `json:"paths,omitempty"`
	NextActions []string          `json:"nextActions,omitempty"`
}

// ConfirmationRequest 确认请求结构
type ConfirmationRequest struct {
	PackageName        string                            `json:"packageName"`
	ModuleName         string                            `json:"moduleName"`
	NeedCreatedPackage bool                              `json:"needCreatedPackage"`
	NeedCreatedModules bool                              `json:"needCreatedModules"`
	PackageInfo        *request.SysAutoCodePackageCreate `json:"packageInfo,omitempty"`
	ModulesInfo        *request.AutoCode                 `json:"modulesInfo,omitempty"`
}

// ConfirmationResponse 确认响应结构
type ConfirmationResponse struct {
	Message         string `json:"message"`
	PackageConfirm  bool   `json:"packageConfirm"`
	ModulesConfirm  bool   `json:"modulesConfirm"`
	CanProceed      bool   `json:"canProceed"`
	ConfirmationKey string `json:"confirmationKey"`
}

// New 返回工具注册信息
func (t *AutomationModuleAnalyzer) New() mcp.Tool {
	return mcp.NewTool("gva_auto_generate",
		mcp.WithDescription(`**🔧 核心执行工具：接收requirement_analyzer分析结果，执行具体的模块创建操作**

**工作流位置：**
- **第二优先级**：在requirement_analyzer之后使用
- **接收输入**：来自requirement_analyzer的1xxx2xxx格式分析结果
- **执行操作**：根据分析结果创建完整模块、包、功能模块

**批量创建功能：**
- 支持在单个ExecutionPlan中创建多个模块
- modulesInfo字段为数组，可包含多个模块配置
- 一次性处理多个模块的创建和字典生成
- 与requirement_analyzer配合实现完整工作流

分步骤分析自动化模块：1) 分析现有模块信息供AI选择 2) 请求用户确认 3) 根据确认结果执行创建操作

**新功能：自动字典创建**
- 当结构体字段使用了字典类型（dictType不为空）时，系统会自动检查字典是否存在
- 如果字典不存在，会自动创建对应的字典及默认的字典详情项
- 字典创建包括：字典主表记录和默认的选项值（选项1、选项2等）

**推荐工作流：**
1. 用户提出需求 → requirement_analyzer（最高优先级）
2. AI分析需求为1xxx2xxx格式 → gva_auto_generate（执行创建）
3. 创建完成后，根据需要使用其他辅助工具

**重要限制：**
- 当needCreatedModules=true时，模块创建会自动生成API和菜单，因此不应再调用api_creator和menu_creator工具
- 只有在单独创建API或菜单（不涉及模块创建）时才使用api_creator和menu_creator工具

重要：ExecutionPlan结构体格式要求（支持批量创建）：
{
  "packageName": "包名(string)",
  "packageType": "package或plugin(string)",
  "needCreatedPackage": "是否需要创建包(bool)",
  "needCreatedModules": "是否需要创建模块(bool)",
  "packageInfo": {
    "desc": "描述(string)",
    "label": "展示名(string)", 
    "template": "package或plugin(string)",
    "packageName": "包名(string)"
  },
  "modulesInfo": [{
    "package": "包名(string)",
    "tableName": "数据库表名(string)",
    "businessDB": "业务数据库(string)",
    "structName": "结构体名(string)",
    "packageName": "文件名称(string)",
    "description": "中文描述(string)",
    "abbreviation": "简称(string)",
    "humpPackageName": "文件名称 一般是结构体名的小驼峰(string)",
    "gvaModel": "是否使用GVA模型(bool) 固定为true 后续不需要创建ID created_at deleted_at updated_at",
    "autoMigrate": "是否自动迁移(bool)",
    "autoCreateResource": "是否创建资源(bool)",
    "autoCreateApiToSql": "是否创建API(bool)",
    "autoCreateMenuToSql": "是否创建菜单(bool)",
    "autoCreateBtnAuth": "是否创建按钮权限(bool)",
    "onlyTemplate": "是否仅模板(bool)",
    "isTree": "是否树形结构(bool)",
    "treeJson": "树形JSON字段(string)",
    "isAdd": "是否新增(bool) 固定为false",
    "generateWeb": "是否生成前端(bool)",
    "generateServer": "是否生成后端(bool)",
    "fields": [{
      "fieldName": "字段名(string)必须大写开头",
      "fieldDesc": "字段描述(string)",
      "fieldType": "字段类型支持：string（字符串）,richtext（富文本）,int（整型）,bool（布尔值）,float64（浮点型）,time.Time（时间）,enum（枚举）,picture（单图片，字符串）,pictures（多图片，json字符串）,video（视频，字符串）,file（文件，json字符串）,json（JSON）,array（数组）",
      "fieldJson": "JSON标签(string 必须是小驼峰命名，例:userName)",
      "dataTypeLong": "数据长度(string)",
      "comment": "注释(string)",
      "columnName": "数据库列名(string)",
      "fieldSearchType": "搜索类型:=/>/</>=/<=/NOT BETWEEN/LIKE/BETWEEN/IN/NOT IN等(string)",
      "fieldSearchHide": "是否隐藏搜索(bool)",
      "dictType": "字典类型(string)",
      "form": "表单显示(bool)",
      "table": "表格显示(bool)",
      "desc": "详情显示(bool)",
      "excel": "导入导出(bool)",
      "require": "是否必填(bool)",
      "defaultValue": "默认值(string)，JSON类型（array,json,file,pictures）请保持为空他们不可以设置默认值",
      "errorText": "错误提示(string)",
      "clearable": "是否可清空(bool)",
      "sort": "是否排序(bool)",
      "primaryKey": "是否主键(bool)",
      "dataSource": "数据源配置(object) - 用于配置字段的关联表信息，结构：{\"dbName\":\"数据库名\",\"table\":\"关联表名\",\"label\":\"显示字段\",\"value\":\"值字段\",\"association\":1或2(1=一对一,2=一对多),\"hasDeletedAt\":true/false}。\n\n**获取表名提示：**\n- 可在 server/model 和 plugin/xxx/model 目录下查看对应模块的 TableName() 接口实现获取实际表名\n- 例如：SysUser 的表名为 \"sys_users\"，ExaFileUploadAndDownload 的表名为 \"exa_file_upload_and_downloads\"\n- 插件模块示例：Info 的表名为 \"gva_announcements_info\"\n\n**获取数据库名提示：**\n- 主数据库：通常使用 \"gva\"（默认数据库标识）\n- 多数据库：可在 config.yaml 的 db-list 配置中查看可用数据库的 alias-name 字段\n- 如果用户未提及关联多数据库信息 则使用默认数据库 默认数据库的情况下 dbName此处填写为空",
      "checkDataSource": "是否检查数据源(bool) - 启用后会验证关联表的存在性",
      "fieldIndexType": "索引类型(string)"
    }]
  }, {
    "package": "包名(string)",
    "tableName": "第二个模块的表名(string)",
    "structName": "第二个模块的结构体名(string)",
    "description": "第二个模块的描述(string)",
    "...": "更多模块配置..."
  }]
}

注意：
1. needCreatedPackage=true时packageInfo必需
2. needCreatedModules=true时modulesInfo必需
3. packageType只能是"package"或"plugin"
4. 字段类型支持：string（字符串）,richtext（富文本）,int（整型）,bool（布尔值）,float64（浮点型）,time.Time（时间）,enum（枚举）,picture（单图片，字符串）,pictures（多图片，json字符串）,video（视频，字符串）,file（文件，json字符串）,json（JSON）,array（数组）
5. 搜索类型支持：=,!=,>,>=,<,<=,NOT BETWEEN/LIKE/BETWEEN/IN/NOT IN
6. gvaModel=true时自动包含ID,CreatedAt,UpdatedAt,DeletedAt字段
7. **重要**：当gvaModel=false时，必须有一个字段的primaryKey=true，否则会导致PrimaryField为nil错误
8. **重要**：当gvaModel=true时，系统会自动设置ID字段为主键，无需手动设置primaryKey=true
9. 智能字典创建功能：当字段使用字典类型(DictType)时，系统会：
   - 自动检查字典是否存在，如果不存在则创建字典
   - 根据字典类型和字段描述智能生成默认选项，支持状态、性别、类型、等级、优先级、审批、角色、布尔值、订单、颜色、尺寸等常见场景
   - 为无法识别的字典类型提供通用默认选项
10. **模块关联配置**：当需要配置模块间的关联关系时，使用dataSource字段：
   - **dbName**: 关联的数据库名称
   - **table**: 关联的表名
   - **label**: 用于显示的字段名（如name、title等）
   - **value**: 用于存储的值字段名（通常是id）
   - **association**: 关联关系类型（1=一对一关联，2=一对多关联）
   - **hasDeletedAt**: 关联表是否有软删除字段
   - **checkDataSource**: 设为true时会验证关联表的存在性
   - 示例：{"dbName":"gva","table":"sys_users","label":"username","value":"id","association":2,"hasDeletedAt":true}`),
		mcp.WithString("action",
			mcp.Required(),
			mcp.Description("执行操作：'analyze' 分析现有模块信息，'confirm' 请求用户确认创建，'execute' 执行创建操作（支持批量创建多个模块）"),
		),
		mcp.WithString("requirement",
			mcp.Description("用户需求描述（action=analyze时必需）"),
		),
		mcp.WithObject("executionPlan",
			mcp.Description("执行计划（action=confirm或execute时必需，必须严格按照上述格式提供完整的JSON对象）"),
		),
		mcp.WithString("packageConfirm",
			mcp.Description("用户对创建包的确认（action=execute时，如果需要创建包则必需）：'yes' 或 'no'"),
		),
		mcp.WithString("modulesConfirm",
			mcp.Description("用户对创建模块的确认（action=execute时，如果需要创建模块则必需）：'yes' 或 'no'"),
		),
	)
}

// scanPredesignedModules 扫描预设计的模块
func (t *AutomationModuleAnalyzer) scanPredesignedModules() ([]PredesignedModuleInfo, error) {
	var predesignedModules []PredesignedModuleInfo

	// 获取autocode配置路径
	if global.GVA_CONFIG.AutoCode.Root == "" {
		return predesignedModules, nil // 配置不存在时返回空列表，不报错
	}

	serverPath := filepath.Join(global.GVA_CONFIG.AutoCode.Root, global.GVA_CONFIG.AutoCode.Server)

	// 扫描plugin目录下的各个插件模块
	pluginPath := filepath.Join(serverPath, "plugin")
	if pluginModules, err := t.scanPluginModules(pluginPath); err == nil {
		predesignedModules = append(predesignedModules, pluginModules...)
	}

	// 扫描model目录下的各个包模块
	modelPath := filepath.Join(serverPath, "model")
	if packageModules, err := t.scanPackageModules(modelPath); err == nil {
		predesignedModules = append(predesignedModules, packageModules...)
	}

	return predesignedModules, nil
}

// scanPluginModules 扫描plugin目录下的各个插件模块
func (t *AutomationModuleAnalyzer) scanPluginModules(pluginPath string) ([]PredesignedModuleInfo, error) {
	var modules []PredesignedModuleInfo

	if _, err := os.Stat(pluginPath); os.IsNotExist(err) {
		return modules, nil
	}

	entries, err := os.ReadDir(pluginPath)
	if err != nil {
		return modules, err
	}

	for _, entry := range entries {
		if !entry.IsDir() {
			continue
		}

		pluginName := entry.Name()
		pluginDir := filepath.Join(pluginPath, pluginName)

		// 扫描插件下的model目录，查找具体的模块文件
		modelDir := filepath.Join(pluginDir, "model")
		if _, err := os.Stat(modelDir); err == nil {
			if pluginModules, err := t.scanModuleFiles(modelDir, pluginName, "plugin"); err == nil {
				modules = append(modules, pluginModules...)
			}
		}
	}

	return modules, nil
}

// scanPackageModules 扫描model目录下的各个包模块
func (t *AutomationModuleAnalyzer) scanPackageModules(modelPath string) ([]PredesignedModuleInfo, error) {
	var modules []PredesignedModuleInfo

	if _, err := os.Stat(modelPath); os.IsNotExist(err) {
		return modules, nil
	}

	entries, err := os.ReadDir(modelPath)
	if err != nil {
		return modules, err
	}

	for _, entry := range entries {
		if !entry.IsDir() {
			continue
		}

		packageName := entry.Name()
		// 跳过一些系统目录
		if packageName == "common" || packageName == "request" || packageName == "response" {
			continue
		}

		packageDir := filepath.Join(modelPath, packageName)

		// 扫描包目录下的模块文件
		if packageModules, err := t.scanModuleFiles(packageDir, packageName, "package"); err == nil {
			modules = append(modules, packageModules...)
		}
	}

	return modules, nil
}

// scanModuleFiles 扫描目录下的Go文件，识别具体的模块
func (t *AutomationModuleAnalyzer) scanModuleFiles(dir, packageName, packageType string) ([]PredesignedModuleInfo, error) {
	var modules []PredesignedModuleInfo

	entries, err := os.ReadDir(dir)
	if err != nil {
		return modules, err
	}

	for _, entry := range entries {
		if entry.IsDir() {
			continue
		}

		fileName := entry.Name()
		if !strings.HasSuffix(fileName, ".go") {
			continue
		}

		// 跳过一些非模块文件
		if strings.HasSuffix(fileName, "_test.go") ||
			fileName == "enter.go" ||
			fileName == "request.go" ||
			fileName == "response.go" {
			continue
		}

		filePath := filepath.Join(dir, fileName)
		moduleName := strings.TrimSuffix(fileName, ".go")

		// 分析模块文件，提取结构体信息
		if moduleInfo, err := t.analyzeModuleFile(filePath, packageName, moduleName, packageType); err == nil {
			modules = append(modules, *moduleInfo)
		}
	}

	return modules, nil
}

// analyzeModuleFile 分析具体的模块文件
func (t *AutomationModuleAnalyzer) analyzeModuleFile(filePath, packageName, moduleName, packageType string) (*PredesignedModuleInfo, error) {
	content, err := os.ReadFile(filePath)
	if err != nil {
		return nil, err
	}

	fileContent := string(content)

	// 提取结构体名称和描述
	structNames := t.extractStructNames(fileContent)
	description := t.extractModuleDescription(fileContent, moduleName)

	// 确定主要结构体名称
	mainStruct := moduleName
	if len(structNames) > 0 {
		// 优先选择与文件名相关的结构体
		for _, structName := range structNames {
			if strings.Contains(strings.ToLower(structName), strings.ToLower(moduleName)) {
				mainStruct = structName
				break
			}
		}
		if mainStruct == moduleName && len(structNames) > 0 {
			mainStruct = structNames[0] // 如果没有匹配的，使用第一个
		}
	}

	return &PredesignedModuleInfo{
		PackageName: packageName,
		PackageType: packageType,
		ModuleName:  moduleName,
		Path:        filePath,
		Modules:     structNames,
		Description: description,
		StructName:  mainStruct,
	}, nil
}

// extractStructNames 从文件内容中提取结构体名称
func (t *AutomationModuleAnalyzer) extractStructNames(content string) []string {
	var structNames []string
	lines := strings.Split(content, "\n")

	for _, line := range lines {
		line = strings.TrimSpace(line)
		if strings.HasPrefix(line, "type ") && strings.Contains(line, " struct") {
			// 提取结构体名称
			parts := strings.Fields(line)
			if len(parts) >= 3 && parts[2] == "struct" {
				structNames = append(structNames, parts[1])
			}
		}
	}

	return structNames
}

// extractModuleDescription 从文件内容中提取模块描述
func (t *AutomationModuleAnalyzer) extractModuleDescription(content, moduleName string) string {
	lines := strings.Split(content, "\n")

	// 查找package注释
	for i, line := range lines {
		line = strings.TrimSpace(line)
		if strings.HasPrefix(line, "package ") {
			// 向上查找注释
			for j := i - 1; j >= 0; j-- {
				commentLine := strings.TrimSpace(lines[j])
				if strings.HasPrefix(commentLine, "//") {
					comment := strings.TrimSpace(strings.TrimPrefix(commentLine, "//"))
					if comment != "" && len(comment) > 5 {
						return comment
					}
				} else if commentLine != "" {
					break
				}
			}
			break
		}
	}

	// 查找结构体注释
	for i, line := range lines {
		line = strings.TrimSpace(line)
		if strings.HasPrefix(line, "type ") && strings.Contains(line, " struct") {
			// 向上查找注释
			for j := i - 1; j >= 0; j-- {
				commentLine := strings.TrimSpace(lines[j])
				if strings.HasPrefix(commentLine, "//") {
					comment := strings.TrimSpace(strings.TrimPrefix(commentLine, "//"))
					if comment != "" && len(comment) > 5 {
						return comment
					}
				} else if commentLine != "" {
					break
				}
			}
			break
		}
	}

	return fmt.Sprintf("预设计的模块：%s", moduleName)
}

// Handle 处理工具调用
func (t *AutomationModuleAnalyzer) Handle(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
	action, ok := request.GetArguments()["action"].(string)
	if !ok || action == "" {
		return nil, errors.New("参数错误：action 必须是非空字符串")
	}

	switch action {
	case "analyze":
		return t.handleAnalyze(ctx, request)
	case "confirm":
		return t.handleConfirm(ctx, request)
	case "execute":
		return t.handleExecute(ctx, request)
	default:
		return nil, errors.New("无效的操作：action 必须是 'analyze'、'confirm' 或 'execute'")
	}
}

// handleAnalyze 处理分析请求
func (t *AutomationModuleAnalyzer) handleAnalyze(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
	requirement, ok := request.GetArguments()["requirement"].(string)
	if !ok || requirement == "" {
		return nil, errors.New("参数错误：requirement 必须是非空字符串")
	}

	// 检测用户是否想要创建插件
	suggestedType, isPlugin, confidence := t.detectPluginIntent(requirement)
	pluginDetectionMsg := ""
	if isPlugin {
		pluginDetectionMsg = fmt.Sprintf("\n\n🔍 **插件检测结果**：检测到用户想要创建插件（置信度：%s）\n⚠️  **重要提醒**：当用户提到插件时，packageType和template字段都必须设置为 \"plugin\"，不能使用 \"package\"！", confidence)
	} else {
		pluginDetectionMsg = fmt.Sprintf("\n\n🔍 **类型检测结果**：建议使用 %s 类型", suggestedType)
	}

	// 从数据库获取所有自动化包信息
	var packages []model.SysAutoCodePackage
	if err := global.GVA_DB.Find(&packages).Error; err != nil {
		return nil, fmt.Errorf("获取包信息失败: %v", err)
	}

	// 从数据库获取所有历史记录
	var histories []model.SysAutoCodeHistory
	if err := global.GVA_DB.Find(&histories).Error; err != nil {
		return nil, fmt.Errorf("获取历史记录失败: %v", err)
	}

	// 转换包信息并检查空文件夹
	var moduleInfos []ModuleInfo
	var validPackages []model.SysAutoCodePackage
	var emptyPackageIDs []uint
	var emptyPackageNames []string

	for _, pkg := range packages {
		// 检查包对应的文件夹是否为空
		isEmpty, err := t.isPackageFolderEmpty(pkg.PackageName, pkg.Template)
		if err != nil {
			global.GVA_LOG.Warn(fmt.Sprintf("检查包 %s 文件夹失败: %v", pkg.PackageName, err))
			// 如果检查失败，仍然保留该包
			validPackages = append(validPackages, pkg)
			continue
		}

		if isEmpty {
			// 记录需要删除的包ID和包名
			emptyPackageIDs = append(emptyPackageIDs, pkg.ID)
			emptyPackageNames = append(emptyPackageNames, pkg.PackageName)
			global.GVA_LOG.Info(fmt.Sprintf("发现空包文件夹: %s，将删除数据库记录和文件夹", pkg.PackageName))

			// 删除空文件夹
			if err := t.removeEmptyPackageFolder(pkg.PackageName, pkg.Template); err != nil {
				global.GVA_LOG.Warn(fmt.Sprintf("删除空包文件夹 %s 失败: %v", pkg.PackageName, err))
			}
		} else {
			// 文件夹不为空，保留该包
			validPackages = append(validPackages, pkg)
		}
	}

	// 批量删除空包的数据库记录
	if len(emptyPackageIDs) > 0 {
		if err := global.GVA_DB.Where("id IN ?", emptyPackageIDs).Delete(&model.SysAutoCodePackage{}).Error; err != nil {
			global.GVA_LOG.Warn(fmt.Sprintf("删除空包数据库记录失败: %v", err))
		} else {
			global.GVA_LOG.Info(fmt.Sprintf("成功删除 %d 个空包的数据库记录", len(emptyPackageIDs)))
		}
	}

	// 转换有效的包信息
	for _, pkg := range validPackages {
		moduleInfos = append(moduleInfos, ModuleInfo{
			ID:          pkg.ID,
			PackageName: pkg.PackageName,
			Label:       pkg.Label,
			Desc:        pkg.Desc,
			Template:    pkg.Template,
			Module:      pkg.Module,
		})
	}

	// 删除与空包相关的历史记录
	var emptyHistoryIDs []uint
	if len(emptyPackageNames) > 0 {
		for _, history := range histories {
			for _, emptyPackageName := range emptyPackageNames {
				if history.Package == emptyPackageName {
					emptyHistoryIDs = append(emptyHistoryIDs, history.ID)
					break
				}
			}
		}

		// 清理相关的API和菜单记录
		if len(emptyHistoryIDs) > 0 {
			if err := t.cleanupRelatedApiAndMenus(emptyHistoryIDs); err != nil {
				global.GVA_LOG.Warn(fmt.Sprintf("清理空包相关API和菜单失败: %v", err))
			}
		}

		// 批量删除相关历史记录
		if len(emptyHistoryIDs) > 0 {
			if err := global.GVA_DB.Where("id IN ?", emptyHistoryIDs).Delete(&model.SysAutoCodeHistory{}).Error; err != nil {
				global.GVA_LOG.Warn(fmt.Sprintf("删除空包相关历史记录失败: %v", err))
			} else {
				global.GVA_LOG.Info(fmt.Sprintf("成功删除 %d 个空包相关的历史记录", len(emptyHistoryIDs)))
			}
		}
	}

	// 创建有效包名的映射，用于快速查找
	validPackageNames := make(map[string]bool)
	for _, pkg := range validPackages {
		validPackageNames[pkg.PackageName] = true
	}

	// 收集需要删除的脏历史记录ID（包名不在有效包列表中的历史记录）
	var dirtyHistoryIDs []uint
	for _, history := range histories {
		if !validPackageNames[history.Package] {
			dirtyHistoryIDs = append(dirtyHistoryIDs, history.ID)
		}
	}

	// 删除脏历史记录
	if len(dirtyHistoryIDs) > 0 {
		// 清理相关的API和菜单记录
		if err := t.cleanupRelatedApiAndMenus(dirtyHistoryIDs); err != nil {
			global.GVA_LOG.Warn(fmt.Sprintf("清理脏历史记录相关API和菜单失败: %v", err))
		}

		if err := global.GVA_DB.Where("id IN ?", dirtyHistoryIDs).Delete(&model.SysAutoCodeHistory{}).Error; err != nil {
			global.GVA_LOG.Warn(fmt.Sprintf("删除脏历史记录失败: %v", err))
		} else {
			global.GVA_LOG.Info(fmt.Sprintf("成功删除 %d 个脏历史记录（包名不在有效包列表中）", len(dirtyHistoryIDs)))
		}
	}

	// 转换有效的历史记录（只保留包名存在于有效包列表中的历史记录）
	var historyInfos []HistoryInfo
	for _, history := range histories {
		// 只保留包名存在于有效包列表中的历史记录
		if validPackageNames[history.Package] {
			historyInfos = append(historyInfos, HistoryInfo{
				ID:           history.ID,
				StructName:   history.StructName,
				TableName:    history.TableName(),
				PackageName:  history.Package,
				BusinessDB:   history.BusinessDB,
				Description:  history.Description,
				Abbreviation: history.Abbreviation,
				CreatedAt:    history.CreatedAt.Format("2006-01-02 15:04:05"),
			})
		}
	}

	// 扫描预设计的模块
	allPredesignedModules, err := t.scanPredesignedModules()
	if err != nil {
		global.GVA_LOG.Warn("扫描预设计模块失败" + err.Error())
		allPredesignedModules = []PredesignedModuleInfo{} // 确保不为nil
	}

	// 过滤掉与已删除包相关的预设计模块
	var predesignedModules []PredesignedModuleInfo
	for _, module := range allPredesignedModules {
		isDeleted := false
		for _, emptyPackageName := range emptyPackageNames {
			if module.PackageName == emptyPackageName {
				isDeleted = true
				break
			}
		}

		// 只保留未被删除包的预设计模块
		if !isDeleted {
			predesignedModules = append(predesignedModules, module)
		}
	}

	// 构建分析结果消息
	var message string
	var deletionDetails []string

	// 收集删除信息
	if len(emptyHistoryIDs) > 0 {
		deletionDetails = append(deletionDetails, fmt.Sprintf("%d个空包相关历史记录", len(emptyHistoryIDs)))
	}
	if len(dirtyHistoryIDs) > 0 {
		deletionDetails = append(deletionDetails, fmt.Sprintf("%d个脏历史记录", len(dirtyHistoryIDs)))
	}
	if len(allPredesignedModules) > len(predesignedModules) {
		deletionDetails = append(deletionDetails, fmt.Sprintf("%d个相关预设计模块", len(allPredesignedModules)-len(predesignedModules)))
	}

	if len(emptyPackageNames) > 0 || len(deletionDetails) > 0 {
		var cleanupInfo string
		if len(emptyPackageNames) > 0 {
			cleanupInfo = fmt.Sprintf("检测到存在 %s 包但内容为空，我已经删除这些包的文件夹（包括model、api、service、router目录）和数据库记录", strings.Join(emptyPackageNames, "、"))
		}

		deletionInfo := ""
		if len(deletionDetails) > 0 {
			if cleanupInfo != "" {
				deletionInfo = fmt.Sprintf("，同时删除了%s", strings.Join(deletionDetails, "、"))
			} else {
				deletionInfo = fmt.Sprintf("检测到脏数据，已删除%s", strings.Join(deletionDetails, "、"))
			}
		}

		if cleanupInfo != "" {
			message = fmt.Sprintf("分析完成：获取到 %d 个有效包、%d 个历史记录和 %d 个预设计模块。%s%s，如果需要使用这些包名，需要重新创建。请AI根据需求选择合适的包和模块", len(validPackages), len(historyInfos), len(predesignedModules), cleanupInfo, deletionInfo)
		} else {
			message = fmt.Sprintf("分析完成：获取到 %d 个有效包、%d 个历史记录和 %d 个预设计模块。%s。请AI根据需求选择合适的包和模块", len(validPackages), len(historyInfos), len(predesignedModules), deletionInfo)
		}
	} else {
		message = fmt.Sprintf("分析完成：获取到 %d 个有效包、%d 个历史记录和 %d 个预设计模块，请AI根据需求选择合适的包和模块", len(validPackages), len(historyInfos), len(predesignedModules))
	}

	// 构建分析结果
	analysisResult := AnalysisResponse{
		Packages:           moduleInfos,
		History:            historyInfos,
		PredesignedModules: predesignedModules,
		Message:            message,
	}

	resultJSON, err := json.MarshalIndent(analysisResult, "", "  ")
	if err != nil {
		return nil, fmt.Errorf("序列化结果失败: %v", err)
	}

	return &mcp.CallToolResult{
		Content: []mcp.Content{
			mcp.TextContent{
				Type: "text",
				Text: fmt.Sprintf(`分析结果：

%s

请AI根据用户需求：%s%s

%s

分析现有的包、历史记录和预设计模块，然后构建ExecutionPlan结构体调用execute操作。

**预设计模块说明**：
- 预设计模块是已经存在于autocode路径下的package或plugin
- 这些模块包含了预先设计好的代码结构，可以直接使用或作为参考
- 如果用户需求与某个预设计模块匹配，可以考虑直接使用该模块或基于它进行扩展

**字典选项生成说明**：
- 当字段需要使用字典类型时（dictType不为空），请使用 generate_dictionary_options 工具
- 该工具允许AI根据字段描述智能生成合适的字典选项
- 调用示例：
  {
    "dictType": "user_status",
    "fieldDesc": "用户状态",
    "options": [
      {"label": "正常", "value": "1", "sort": 1},
      {"label": "禁用", "value": "0", "sort": 2}
    ],
    "dictName": "用户状态字典",
    "description": "用于管理用户账户状态的字典"
  }
- 请在创建模块之前先创建所需的字典选项

重要提醒：ExecutionPlan必须严格按照以下格式（支持批量创建多个模块）：
{
  "packageName": "包名",
  "packageType": "package或plugin", // 当用户提到插件时必须是"plugin"
  "needCreatedPackage": true/false,
  "needCreatedModules": true/false,
  "packageInfo": {
    "desc": "描述",
    "label": "展示名",
    "template": "package或plugin", // 必须与packageType保持一致！
    "packageName": "包名"
  },
  "modulesInfo": [{
    "package": "包名",
    "tableName": "数据库表名",
    "businessDB": "",
    "structName": "结构体名",
    "packageName": "文件名称小驼峰模式 一般是结构体名的小驼峰",
    "description": "中文描述",
    "abbreviation": "简称 package和结构体简称不可同名 小驼峰模式",
    "humpPackageName": "一般是结构体名的下划线分割的小驼峰 例如：sys_user",
    "gvaModel": true,
    "autoMigrate": true,
    "autoCreateResource": true/false 用户不特地强调开启资源标识则为false,
    "autoCreateApiToSql": true,
    "autoCreateMenuToSql": true,
    "autoCreateBtnAuth": false/true 用户不特地强调创建按钮权限则为false,
    "onlyTemplate": false,
    "isTree": false,
    "treeJson": "",
    "isAdd": false,
    "generateWeb": true,
    "generateServer": true,
    "fields": [{
      "fieldName": "字段名（必须大写开头）",
      "fieldDesc": "字段描述",
      "fieldType": "字段类型支持：string（字符串）,richtext（富文本）,int（整型）,bool（布尔值）,float64（浮点型）,time.Time（时间）,enum（枚举）,picture（单图片，字符串）,pictures（多图片，json字符串）,video（视频，字符串）,file（文件，json字符串）,json（JSON）,array（数组）",
      "fieldJson": "json标签(string 必须是小驼峰命名，例:userName)",
      "dataTypeLong": "长度",
      "comment": "注释",
      "columnName": "数据库列名",
      "fieldSearchType": "=/!=/>/</>=/<=/LIKE等 可以为空",
      "fieldSearchHide": true/false,
      "dictType": "",
      "form": true/false 是否前端创建输入,
      "table": true/false 是否前端表格展示,
      "desc": true/false 是否前端详情展示,
      "excel": true/false 是否导出Excel,
      "require": true/false 是否必填,
      "defaultValue": "",
      "errorText": "错误提示",
      "clearable": true,
      "sort": false,
      "primaryKey": "当gvaModel=false时必须有一个字段设为true(bool)",
      "dataSource": null,
      "checkDataSource": false,
      "fieldIndexType": ""
    }]
  }, {
    "package": "包名",
    "tableName": "第二个模块的表名",
    "structName": "第二个模块的结构体名",
    "description": "第二个模块的描述",
    "...": "更多模块配置..."
  }]
}

**重要提醒**：ExecutionPlan必须严格按照以下格式和验证规则：

**插件类型检测规则（最重要）**：
1. 当用户需求中包含"插件"、"plugin"等关键词时，packageType和template都必须设置为"plugin"
2. packageType和template字段必须保持一致，不能一个是"package"另一个是"plugin"
3. 如果检测到插件意图但设置错误，会导致创建失败

**字段完整性要求**：
4. 所有字符串字段都不能为空（包括packageName、moduleName、structName、tableName、description等）
5. 所有布尔字段必须明确设置true或false，不能使用默认值

**主键设置规则（关键）**：
6. 当gvaModel=false时：fields数组中必须有且仅有一个字段的primaryKey=true
7. 当gvaModel=true时：系统自动创建ID主键，fields中所有字段的primaryKey都应为false
8. 主键设置错误会导致模板执行时PrimaryField为nil的严重错误！

**包和模块创建逻辑**：
9. 如果存在可用的package，needCreatedPackage应设为false
10. 如果存在可用的modules，needCreatedModules应设为false
11. 如果发现合适的预设计模块，可以考虑基于它进行扩展而不是从零创建

**字典创建流程**：
12. 如果字段需要字典类型，请先使用 generate_dictionary_options 工具创建字典
13. 字典创建成功后，再执行模块创建操作

`, string(resultJSON), requirement, pluginDetectionMsg,
					func() string {
						if len(emptyPackageNames) > 0 {
							return fmt.Sprintf("**重要提醒**：检测到 %s 包存在但内容为空，已自动删除相关文件夹和数据库记录。如果用户需求涉及这些包名，请设置 needCreatedPackage=true 重新创建。", strings.Join(emptyPackageNames, "、"))
						}
						return ""
					}()),
			},
		},
	}, nil
}

// handleConfirm 处理确认请求
func (t *AutomationModuleAnalyzer) handleConfirm(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
	executionPlanData, ok := request.GetArguments()["executionPlan"]
	if !ok {
		return nil, errors.New("参数错误：executionPlan 必须提供")
	}

	// 解析执行计划
	planJSON, err := json.Marshal(executionPlanData)
	if err != nil {
		return nil, fmt.Errorf("解析执行计划失败: %v", err)
	}

	var plan ExecutionPlan
	err = json.Unmarshal(planJSON, &plan)
	if err != nil {
		return nil, fmt.Errorf("解析执行计划失败: %v\n\n请确保ExecutionPlan格式正确，参考工具描述中的结构体格式要求", err)
	}

	// 验证执行计划的完整性
	if err := t.validateExecutionPlan(&plan); err != nil {
		return nil, fmt.Errorf("执行计划验证失败: %v", err)
	}

	// 构建确认响应
	var moduleNames []string
	for _, moduleInfo := range plan.ModulesInfo {
		moduleNames = append(moduleNames, moduleInfo.StructName)
	}
	moduleNamesStr := strings.Join(moduleNames, "_")

	confirmResponse := ConfirmationResponse{
		Message:         "请确认以下创建计划：",
		PackageConfirm:  plan.NeedCreatedPackage,
		ModulesConfirm:  plan.NeedCreatedModules,
		CanProceed:      true,
		ConfirmationKey: fmt.Sprintf("%s_%s_%d", plan.PackageName, moduleNamesStr, time.Now().Unix()),
	}

	// 构建详细的确认信息
	var confirmDetails strings.Builder
	confirmDetails.WriteString(fmt.Sprintf("包名: %s\n", plan.PackageName))
	confirmDetails.WriteString(fmt.Sprintf("包类型: %s\n", plan.PackageType))

	if plan.NeedCreatedPackage && plan.PackageInfo != nil {
		confirmDetails.WriteString("\n需要创建包:\n")
		confirmDetails.WriteString(fmt.Sprintf("  - 包名: %s\n", plan.PackageInfo.PackageName))
		confirmDetails.WriteString(fmt.Sprintf("  - 标签: %s\n", plan.PackageInfo.Label))
		confirmDetails.WriteString(fmt.Sprintf("  - 描述: %s\n", plan.PackageInfo.Desc))
		confirmDetails.WriteString(fmt.Sprintf("  - 模板: %s\n", plan.PackageInfo.Template))
	}

	if plan.NeedCreatedModules && len(plan.ModulesInfo) > 0 {
		confirmDetails.WriteString(fmt.Sprintf("\n需要创建模块 (共%d个):\n", len(plan.ModulesInfo)))
		for i, moduleInfo := range plan.ModulesInfo {
			confirmDetails.WriteString(fmt.Sprintf("\n模块 %d:\n", i+1))
			confirmDetails.WriteString(fmt.Sprintf("  - 结构体名: %s\n", moduleInfo.StructName))
			confirmDetails.WriteString(fmt.Sprintf("  - 表名: %s\n", moduleInfo.TableName))
			confirmDetails.WriteString(fmt.Sprintf("  - 描述: %s\n", moduleInfo.Description))
			confirmDetails.WriteString(fmt.Sprintf("  - 字段数量: %d\n", len(moduleInfo.Fields)))
			confirmDetails.WriteString("  - 字段列表:\n")
			for _, field := range moduleInfo.Fields {
				confirmDetails.WriteString(fmt.Sprintf("    * %s (%s): %s\n", field.FieldName, field.FieldType, field.FieldDesc))
			}
		}
	}

	resultJSON, err := json.MarshalIndent(confirmResponse, "", "  ")
	if err != nil {
		return nil, fmt.Errorf("序列化结果失败: %v", err)
	}

	return &mcp.CallToolResult{
		Content: []mcp.Content{
			mcp.TextContent{
				Type: "text",
				Text: fmt.Sprintf("确认信息：\n\n%s\n\n详细信息：\n%s\n\n请用户确认是否继续执行此计划。如果确认，请使用execute操作并提供相应的确认参数。", string(resultJSON), confirmDetails.String()),
			},
		},
	}, nil
}

// handleExecute 处理执行请求
func (t *AutomationModuleAnalyzer) handleExecute(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
	executionPlanData, ok := request.GetArguments()["executionPlan"]
	if !ok {
		return nil, errors.New("参数错误：executionPlan 必须提供")
	}

	// 解析执行计划
	planJSON, err := json.Marshal(executionPlanData)
	if err != nil {
		return nil, fmt.Errorf("解析执行计划失败: %v", err)
	}

	var plan ExecutionPlan
	err = json.Unmarshal(planJSON, &plan)
	if err != nil {
		return nil, fmt.Errorf("解析执行计划失败: %v\n\n请确保ExecutionPlan格式正确，参考工具描述中的结构体格式要求", err)
	}

	// 验证执行计划的完整性
	if err := t.validateExecutionPlan(&plan); err != nil {
		return nil, fmt.Errorf("执行计划验证失败: %v", err)
	}

	// 检查用户确认
	if plan.NeedCreatedPackage {
		packageConfirm, ok := request.GetArguments()["packageConfirm"].(string)
		if !ok || (packageConfirm != "yes" && packageConfirm != "no") {
			return nil, errors.New("参数错误：当需要创建包时，packageConfirm 必须是 'yes' 或 'no'")
		}
		if packageConfirm == "no" {
			return &mcp.CallToolResult{
				Content: []mcp.Content{
					mcp.TextContent{
						Type: "text",
						Text: "用户取消了包的创建操作",
					},
				},
			}, nil
		}
	}

	if plan.NeedCreatedModules {
		modulesConfirm, ok := request.GetArguments()["modulesConfirm"].(string)
		if !ok || (modulesConfirm != "yes" && modulesConfirm != "no") {
			return nil, errors.New("参数错误：当需要创建模块时，modulesConfirm 必须是 'yes' 或 'no'")
		}
		if modulesConfirm == "no" {
			return &mcp.CallToolResult{
				Content: []mcp.Content{
					mcp.TextContent{
						Type: "text",
						Text: "用户取消了模块的创建操作",
					},
				},
			}, nil
		}
	}

	// 执行创建操作
	result := t.executeCreation(ctx, &plan)

	resultJSON, err := json.MarshalIndent(result, "", "  ")
	if err != nil {
		return nil, fmt.Errorf("序列化结果失败: %v", err)
	}

	// 添加权限分配提醒
	permissionReminder := "\n\n⚠️ 重要提醒：\n" +
		"模块创建完成后，请前往【系统管理】->【角色管理】中为相关角色分配新创建的API和菜单权限，" +
		"以确保用户能够正常访问新功能。\n" +
		"具体步骤：\n" +
		"1. 进入角色管理页面\n" +
		"2. 选择需要授权的角色\n" +
		"3. 在API权限中勾选新创建的API接口\n" +
		"4. 在菜单权限中勾选新创建的菜单项\n" +
		"5. 保存权限配置"

	return &mcp.CallToolResult{
		Content: []mcp.Content{
			mcp.TextContent{
				Type: "text",
				Text: fmt.Sprintf("执行结果：\n\n%s%s", string(resultJSON), permissionReminder),
			},
		},
	}, nil
}

// isSystemFunction 判断是否为系统功能
func (t *AutomationModuleAnalyzer) isSystemFunction(requirement string) bool {
	systemKeywords := []string{
		"用户", "权限", "角色", "菜单", "系统", "配置", "字典", "参数",
		"user", "authority", "role", "menu", "system", "config", "dictionary",
		"认证", "授权", "登录", "注册", "JWT", "casbin",
	}

	requirementLower := strings.ToLower(requirement)
	for _, keyword := range systemKeywords {
		if strings.Contains(requirementLower, keyword) {
			return true
		}
	}
	return false
}

// buildDirectoryStructure 构建目录结构信息
func (t *AutomationModuleAnalyzer) buildDirectoryStructure(plan *ExecutionPlan) map[string]string {
	paths := make(map[string]string)

	// 获取配置信息
	autoCodeConfig := global.GVA_CONFIG.AutoCode

	// 构建基础路径
	rootPath := autoCodeConfig.Root
	serverPath := autoCodeConfig.Server
	webPath := autoCodeConfig.Web
	moduleName := autoCodeConfig.Module

	// 如果计划中有包名，使用计划中的包名，否则使用默认
	packageName := "example"
	if plan.PackageInfo != nil && plan.PackageInfo.PackageName != "" {
		packageName = plan.PackageInfo.PackageName
	}

	// 如果计划中有模块信息，获取第一个模块的结构名作为默认值
	structName := "ExampleStruct"
	if len(plan.ModulesInfo) > 0 && plan.ModulesInfo[0].StructName != "" {
		structName = plan.ModulesInfo[0].StructName
	}

	// 根据包类型构建不同的路径结构
	packageType := plan.PackageType
	if packageType == "" {
		packageType = "package" // 默认为package模式
	}

	// 构建服务端路径
	if serverPath != "" {
		serverBasePath := fmt.Sprintf("%s/%s", rootPath, serverPath)

		if packageType == "plugin" {
			// Plugin 模式：所有文件都在 /plugin/packageName/ 目录下
			pluginBasePath := fmt.Sprintf("%s/plugin/%s", serverBasePath, packageName)

			// API 路径
			paths["api"] = fmt.Sprintf("%s/api", pluginBasePath)

			// Service 路径
			paths["service"] = fmt.Sprintf("%s/service", pluginBasePath)

			// Model 路径
			paths["model"] = fmt.Sprintf("%s/model", pluginBasePath)

			// Router 路径
			paths["router"] = fmt.Sprintf("%s/router", pluginBasePath)

			// Request 路径
			paths["request"] = fmt.Sprintf("%s/model/request", pluginBasePath)

			// Response 路径
			paths["response"] = fmt.Sprintf("%s/model/response", pluginBasePath)

			// Plugin 特有文件
			paths["plugin_main"] = fmt.Sprintf("%s/main.go", pluginBasePath)
			paths["plugin_config"] = fmt.Sprintf("%s/plugin.go", pluginBasePath)
			paths["plugin_initialize"] = fmt.Sprintf("%s/initialize", pluginBasePath)
		} else {
			// Package 模式：传统的目录结构
			// API 路径
			paths["api"] = fmt.Sprintf("%s/api/v1/%s", serverBasePath, packageName)

			// Service 路径
			paths["service"] = fmt.Sprintf("%s/service/%s", serverBasePath, packageName)

			// Model 路径
			paths["model"] = fmt.Sprintf("%s/model/%s", serverBasePath, packageName)

			// Router 路径
			paths["router"] = fmt.Sprintf("%s/router/%s", serverBasePath, packageName)

			// Request 路径
			paths["request"] = fmt.Sprintf("%s/model/%s/request", serverBasePath, packageName)

			// Response 路径
			paths["response"] = fmt.Sprintf("%s/model/%s/response", serverBasePath, packageName)
		}
	}

	// 构建前端路径（两种模式相同）
	if webPath != "" {
		webBasePath := fmt.Sprintf("%s/%s", rootPath, webPath)

		// Vue 页面路径
		paths["vue_page"] = fmt.Sprintf("%s/view/%s", webBasePath, packageName)

		// API 路径
		paths["vue_api"] = fmt.Sprintf("%s/api/%s", webBasePath, packageName)
	}

	// 添加模块信息
	paths["module"] = moduleName
	paths["package_name"] = packageName
	paths["package_type"] = packageType
	paths["struct_name"] = structName
	paths["root_path"] = rootPath
	paths["server_path"] = serverPath
	paths["web_path"] = webPath

	return paths
}

// validateExecutionPlan 验证执行计划的完整性
func (t *AutomationModuleAnalyzer) validateExecutionPlan(plan *ExecutionPlan) error {
	// 验证基本字段
	if plan.PackageName == "" {
		return errors.New("packageName 不能为空")
	}
	if plan.PackageType != "package" && plan.PackageType != "plugin" {
		return errors.New("packageType 必须是 'package' 或 'plugin'")
	}

	// 验证packageType和template字段的一致性
	if plan.NeedCreatedPackage && plan.PackageInfo != nil {
		if plan.PackageType != plan.PackageInfo.Template {
			return errors.New("packageType 和 packageInfo.template 必须保持一致")
		}
	}

	// 验证包信息
	if plan.NeedCreatedPackage {
		if plan.PackageInfo == nil {
			return errors.New("当 needCreatedPackage=true 时，packageInfo 不能为空")
		}
		if plan.PackageInfo.PackageName == "" {
			return errors.New("packageInfo.packageName 不能为空")
		}
		if plan.PackageInfo.Template != "package" && plan.PackageInfo.Template != "plugin" {
			return errors.New("packageInfo.template 必须是 'package' 或 'plugin'")
		}
		if plan.PackageInfo.Label == "" {
			return errors.New("packageInfo.label 不能为空")
		}
		if plan.PackageInfo.Desc == "" {
			return errors.New("packageInfo.desc 不能为空")
		}
	}

	// 验证模块信息（批量验证）
	if plan.NeedCreatedModules {
		if len(plan.ModulesInfo) == 0 {
			return errors.New("当 needCreatedModules=true 时，modulesInfo 不能为空")
		}

		// 遍历验证每个模块
		for moduleIndex, moduleInfo := range plan.ModulesInfo {
			if moduleInfo.Package == "" {
				return fmt.Errorf("模块 %d 的 package 不能为空", moduleIndex+1)
			}
			if moduleInfo.StructName == "" {
				return fmt.Errorf("模块 %d 的 structName 不能为空", moduleIndex+1)
			}
			if moduleInfo.TableName == "" {
				return fmt.Errorf("模块 %d 的 tableName 不能为空", moduleIndex+1)
			}
			if moduleInfo.Description == "" {
				return fmt.Errorf("模块 %d 的 description 不能为空", moduleIndex+1)
			}
			if moduleInfo.Abbreviation == "" {
				return fmt.Errorf("模块 %d 的 abbreviation 不能为空", moduleIndex+1)
			}
			if moduleInfo.PackageName == "" {
				return fmt.Errorf("模块 %d 的 packageName 不能为空", moduleIndex+1)
			}
			if moduleInfo.HumpPackageName == "" {
				return fmt.Errorf("模块 %d 的 humpPackageName 不能为空", moduleIndex+1)
			}

			// 验证字段信息
			if len(moduleInfo.Fields) == 0 {
				return fmt.Errorf("模块 %d 的 fields 不能为空，至少需要一个字段", moduleIndex+1)
			}

			for i, field := range moduleInfo.Fields {
				if field.FieldName == "" {
					return fmt.Errorf("模块 %d 字段 %d 的 fieldName 不能为空", moduleIndex+1, i+1)
				}

				if field.FieldDesc == "" {
					return fmt.Errorf("模块 %d 字段 %d 的 fieldDesc 不能为空", moduleIndex+1, i+1)
				}
				if field.FieldType == "" {
					return fmt.Errorf("模块 %d 字段 %d 的 fieldType 不能为空", moduleIndex+1, i+1)
				}
				if field.FieldJson == "" {
					return fmt.Errorf("模块 %d 字段 %d 的 fieldJson 不能为空", moduleIndex+1, i+1)
				}
				if field.ColumnName == "" {
					return fmt.Errorf("模块 %d 字段 %d 的 columnName 不能为空", moduleIndex+1, i+1)
				}

				// 确保字段名首字母大写
				if len(field.FieldName) > 0 {
					firstChar := string(field.FieldName[0])
					if firstChar >= "a" && firstChar <= "z" {
						moduleInfo.Fields[i].FieldName = strings.ToUpper(firstChar) + field.FieldName[1:]
					}
				}

				// 确保FieldJson使用小驼峰命名
				if len(field.FieldJson) > 0 {
					// 处理下划线命名转小驼峰
					if strings.Contains(field.FieldJson, "_") {
						parts := strings.Split(field.FieldJson, "_")
						camelCase := strings.ToLower(parts[0])
						for j := 1; j < len(parts); j++ {
							if len(parts[j]) > 0 {
								camelCase += strings.ToUpper(string(parts[j][0])) + strings.ToLower(parts[j][1:])
							}
						}
						moduleInfo.Fields[i].FieldJson = camelCase
					} else {
						// 处理首字母大写转小写
						firstChar := string(field.FieldJson[0])
						if firstChar >= "A" && firstChar <= "Z" {
							moduleInfo.Fields[i].FieldJson = strings.ToLower(firstChar) + field.FieldJson[1:]
						}
					}
				}

				// 确保ColumnName使用下划线命名
				if len(field.ColumnName) > 0 {
					// 将驼峰命名转换为下划线命名
					var result strings.Builder
					for i, r := range field.ColumnName {
						if i > 0 && r >= 'A' && r <= 'Z' {
							result.WriteRune('_')
						}
						result.WriteRune(unicode.ToLower(r))
					}
					moduleInfo.Fields[i].ColumnName = result.String()
				}

				// 验证字段类型
				validFieldTypes := []string{"string", "int", "int64", "float64", "bool", "time.Time", "enum", "picture", "video", "file", "pictures", "array", "richtext", "json"}
				validType := false
				for _, validFieldType := range validFieldTypes {
					if field.FieldType == validFieldType {
						validType = true
						break
					}
				}
				if !validType {
					return fmt.Errorf("模块 %d 字段 %d 的 fieldType '%s' 不支持，支持的类型：%v", moduleIndex+1, i+1, field.FieldType, validFieldTypes)
				}

				// 验证搜索类型（如果设置了）
				if field.FieldSearchType != "" {
					validSearchTypes := []string{"=", "!=", ">", ">=", "<", "<=", "LIKE", "BETWEEN", "IN", "NOT IN"}
					validSearchType := false
					for _, validType := range validSearchTypes {
						if field.FieldSearchType == validType {
							validSearchType = true
							break
						}
					}
					if !validSearchType {
						return fmt.Errorf("模块 %d 字段 %d 的 fieldSearchType '%s' 不支持，支持的类型：%v", moduleIndex+1, i+1, field.FieldSearchType, validSearchTypes)
					}
				}
			}

			// 验证主键设置
			if !moduleInfo.GvaModel {
				// 当不使用GVA模型时，必须有且仅有一个字段设置为主键
				primaryKeyCount := 0
				for _, field := range moduleInfo.Fields {
					if field.PrimaryKey {
						primaryKeyCount++
					}
				}
				if primaryKeyCount == 0 {
					return fmt.Errorf("模块 %d：当 gvaModel=false 时，必须有一个字段的 primaryKey=true", moduleIndex+1)
				}
				if primaryKeyCount > 1 {
					return fmt.Errorf("模块 %d：当 gvaModel=false 时，只能有一个字段的 primaryKey=true", moduleIndex+1)
				}
			} else {
				// 当使用GVA模型时，所有字段的primaryKey都应该为false
				for i, field := range moduleInfo.Fields {
					if field.PrimaryKey {
						return fmt.Errorf("模块 %d：当 gvaModel=true 时，字段 %d 的 primaryKey 应该为 false，系统会自动创建ID主键", moduleIndex+1, i+1)
					}
				}
			}
		}
	}

	return nil
}

// executeCreation 执行创建操作
func (t *AutomationModuleAnalyzer) executeCreation(ctx context.Context, plan *ExecutionPlan) *ExecutionResult {
	result := &ExecutionResult{
		Success: false,
		Paths:   make(map[string]string),
	}

	// 无论如何都先构建目录结构信息，确保paths始终返回
	result.Paths = t.buildDirectoryStructure(plan)

	if !plan.NeedCreatedModules {
		result.Success = true
		result.Message += "已列出当前功能所涉及的目录结构信息; 请在paths中查看; 并且在对应指定文件中实现相关的业务逻辑; "
		return result
	}

	// 创建包（如果需要）
	if plan.NeedCreatedPackage && plan.PackageInfo != nil {
		packageService := service.ServiceGroupApp.SystemServiceGroup.AutoCodePackage
		err := packageService.Create(ctx, plan.PackageInfo)
		if err != nil {
			result.Message = fmt.Sprintf("创建包失败: %v", err)
			// 即使创建包失败，也要返回paths信息
			return result
		}
		result.Message += "包创建成功; "
	}

	// 批量创建字典和模块（如果需要）
	if plan.NeedCreatedModules && len(plan.ModulesInfo) > 0 {
		templateService := service.ServiceGroupApp.SystemServiceGroup.AutoCodeTemplate

		// 先批量创建所有模块需要的字典
		dictResult := t.createRequiredDictionaries(ctx, plan.ModulesInfo)
		result.Message += dictResult

		// 遍历所有模块进行创建
		for _, moduleInfo := range plan.ModulesInfo {

			// 创建模块
			err := moduleInfo.Pretreatment()
			if err != nil {
				result.Message += fmt.Sprintf("模块 %s 信息预处理失败: %v; ", moduleInfo.StructName, err)
				continue // 继续处理下一个模块
			}

			err = templateService.Create(ctx, *moduleInfo)
			if err != nil {
				result.Message += fmt.Sprintf("创建模块 %s 失败: %v; ", moduleInfo.StructName, err)
				continue // 继续处理下一个模块
			}
			result.Message += fmt.Sprintf("模块 %s 创建成功; ", moduleInfo.StructName)
		}

		result.Message += fmt.Sprintf("批量创建完成，共处理 %d 个模块; ", len(plan.ModulesInfo))

		// 添加重要提醒：不要使用其他MCP工具
		result.Message += "\n\n⚠️ 重要提醒：\n"
		result.Message += "模块创建已完成，API和菜单已自动生成。请不要再调用以下MCP工具：\n"
		result.Message += "- api_creator：API权限已在模块创建时自动生成\n"
		result.Message += "- menu_creator：前端菜单已在模块创建时自动生成\n"
		result.Message += "如需修改API或菜单，请直接在系统管理界面中进行配置。\n"
	}

	result.Message += "已构建目录结构信息; "
	result.Success = true

	if result.Message == "" {
		result.Message = "执行计划完成"
	}

	return result
}

// createRequiredDictionaries 创建所需的字典（批量处理）
func (t *AutomationModuleAnalyzer) createRequiredDictionaries(ctx context.Context, modulesInfoList []*request.AutoCode) string {
	var messages []string
	dictionaryService := service.ServiceGroupApp.SystemServiceGroup.DictionaryService
	createdDictTypes := make(map[string]bool) // 用于避免重复创建相同的字典

	// 遍历所有模块
	for moduleIndex, modulesInfo := range modulesInfoList {
		messages = append(messages, fmt.Sprintf("处理模块 %d (%s) 的字典: ", moduleIndex+1, modulesInfo.StructName))

		// 遍历当前模块的所有字段，查找使用字典的字段
		moduleHasDictFields := false
		for _, field := range modulesInfo.Fields {
			if field.DictType != "" {
				moduleHasDictFields = true

				// 如果这个字典类型已经在之前的模块中创建过，跳过
				if createdDictTypes[field.DictType] {
					messages = append(messages, fmt.Sprintf("字典 %s 已在前面的模块中创建，跳过; ", field.DictType))
					continue
				}

				// 检查字典是否存在
				exists, err := t.checkDictionaryExists(field.DictType)
				if err != nil {
					messages = append(messages, fmt.Sprintf("检查字典 %s 时出错: %v; ", field.DictType, err))
					continue
				}

				if !exists {
					// 字典不存在，创建字典
					dictionary := model.SysDictionary{
						Name:   t.generateDictionaryName(field.DictType, field.FieldDesc),
						Type:   field.DictType,
						Status: &[]bool{true}[0], // 默认启用
						Desc:   fmt.Sprintf("自动生成的字典，用于模块 %s 字段: %s (%s)", modulesInfo.StructName, field.FieldName, field.FieldDesc),
					}

					err = dictionaryService.CreateSysDictionary(dictionary)
					if err != nil {
						messages = append(messages, fmt.Sprintf("创建字典 %s 失败: %v; ", field.DictType, err))
					} else {
						messages = append(messages, fmt.Sprintf("成功创建字典 %s (%s); ", field.DictType, dictionary.Name))
						createdDictTypes[field.DictType] = true // 标记为已创建

						// 创建默认的字典详情项
						t.createDefaultDictionaryDetails(ctx, field.DictType, field.FieldDesc)
					}
				} else {
					messages = append(messages, fmt.Sprintf("字典 %s 已存在，跳过创建; ", field.DictType))
					createdDictTypes[field.DictType] = true // 标记为已存在
				}
			}
		}

		if !moduleHasDictFields {
			messages = append(messages, "无需创建字典; ")
		}
	}

	if len(messages) == 0 {
		return "未发现需要创建的字典; "
	}

	return strings.Join(messages, "")
}

// checkDictionaryExists 检查字典是否存在
func (t *AutomationModuleAnalyzer) checkDictionaryExists(dictType string) (bool, error) {
	var dictionary model.SysDictionary
	err := global.GVA_DB.Where("type = ?", dictType).First(&dictionary).Error
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return false, nil // 字典不存在
		}
		return false, err // 其他错误
	}
	return true, nil // 字典存在
}

// generateDictionaryName 生成字典名称
func (t *AutomationModuleAnalyzer) generateDictionaryName(dictType, fieldDesc string) string {
	if fieldDesc != "" {
		return fmt.Sprintf("%s字典", fieldDesc)
	}
	return fmt.Sprintf("%s字典", dictType)
}

// createDefaultDictionaryDetails 创建默认的字典详情项
func (t *AutomationModuleAnalyzer) createDefaultDictionaryDetails(ctx context.Context, dictType, fieldDesc string) {
	// 字典选项现在通过 generate_dictionary_options MCP工具由AI client传入
	// 这里不再创建默认选项，只是保留方法以保持兼容性
	global.GVA_LOG.Info(fmt.Sprintf("字典 %s 已创建，请使用 generate_dictionary_options 工具添加字典选项", dictType))
}

// DictionaryOption 字典选项结构
type DictionaryOption struct {
	Label string `json:"label"`
	Value string `json:"value"`
	Sort  int    `json:"sort"`
}

// generateSmartDictionaryOptions 通过MCP调用让AI生成字典选项
func (t *AutomationModuleAnalyzer) generateSmartDictionaryOptions(dictType, fieldDesc string) []struct {
	label string
	value string
	sort  int
} {
	// 返回空切片，不再使用预制选项
	// 字典选项将通过新的MCP工具由AI client传入
	return []struct {
		label string
		value string
		sort  int
	}{}
}

// detectPluginIntent 检测用户需求中是否包含插件相关的关键词
func (t *AutomationModuleAnalyzer) detectPluginIntent(requirement string) (suggestedType string, isPlugin bool, confidence string) {
	// 转换为小写进行匹配
	requirementLower := strings.ToLower(requirement)

	// 插件相关关键词
	pluginKeywords := []string{
		"插件", "plugin", "扩展", "extension", "addon", "模块插件",
		"功能插件", "业务插件", "第三方插件", "自定义插件",
	}

	// 包相关关键词（用于排除误判）
	packageKeywords := []string{
		"包", "package", "模块包", "业务包", "功能包",
	}

	// 检测插件关键词
	pluginMatches := 0
	for _, keyword := range pluginKeywords {
		if strings.Contains(requirementLower, keyword) {
			pluginMatches++
		}
	}

	// 检测包关键词
	packageMatches := 0
	for _, keyword := range packageKeywords {
		if strings.Contains(requirementLower, keyword) {
			packageMatches++
		}
	}

	// 决策逻辑
	if pluginMatches > 0 {
		if packageMatches == 0 || pluginMatches > packageMatches {
			return "plugin", true, "高"
		} else {
			return "plugin", true, "中"
		}
	}

	// 默认返回package
	return "package", false, "低"
}

// isPackageFolderEmpty 检查包对应的文件夹是否为空
func (t *AutomationModuleAnalyzer) isPackageFolderEmpty(packageName, template string) (bool, error) {
	// 根据模板类型确定基础路径
	var basePath string
	if template == "plugin" {
		basePath = filepath.Join(global.GVA_CONFIG.AutoCode.Root, global.GVA_CONFIG.AutoCode.Server, "plugin", packageName)
	} else {
		// package 类型
		basePath = filepath.Join(global.GVA_CONFIG.AutoCode.Root, global.GVA_CONFIG.AutoCode.Server, "model", packageName)
	}

	// 检查文件夹是否存在
	if _, err := os.Stat(basePath); os.IsNotExist(err) {
		// 文件夹不存在，认为是空的
		return true, nil
	} else if err != nil {
		return false, fmt.Errorf("检查文件夹状态失败: %v", err)
	}

	// 读取文件夹内容
	entries, err := os.ReadDir(basePath)
	if err != nil {
		return false, fmt.Errorf("读取文件夹内容失败: %v", err)
	}

	// 检查目录下是否有 .go 文件
	hasGoFiles := false
	for _, entry := range entries {
		name := entry.Name()
		// 跳过隐藏文件、.DS_Store 等系统文件
		if strings.HasPrefix(name, ".") {
			continue
		}
		// 如果是目录，递归检查子目录中的 .go 文件
		if entry.IsDir() {
			subPath := filepath.Join(basePath, name)
			subEntries, err := os.ReadDir(subPath)
			if err != nil {
				continue
			}
			for _, subEntry := range subEntries {
				if !subEntry.IsDir() && strings.HasSuffix(subEntry.Name(), ".go") {
					hasGoFiles = true
					break
				}
			}
			if hasGoFiles {
				break
			}
		} else if strings.HasSuffix(name, ".go") {
			// 如果是 .go 文件
			hasGoFiles = true
			break
		}
	}

	// 如果没有 .go 文件，认为是空包
	return !hasGoFiles, nil
}

// removeEmptyPackageFolder 删除空的包文件夹
func (t *AutomationModuleAnalyzer) removeEmptyPackageFolder(packageName, template string) error {
	var errors []string

	if template == "plugin" {
		// plugin 类型只删除 plugin 目录下的文件夹
		basePath := filepath.Join(global.GVA_CONFIG.AutoCode.Root, global.GVA_CONFIG.AutoCode.Server, "plugin", packageName)
		if err := t.removeDirectoryIfExists(basePath); err != nil {
			errors = append(errors, fmt.Sprintf("删除plugin文件夹失败: %v", err))
		}
	} else {
		// package 类型需要删除多个目录下的相关文件
		paths := []string{
			filepath.Join(global.GVA_CONFIG.AutoCode.Root, global.GVA_CONFIG.AutoCode.Server, "model", packageName),
			filepath.Join(global.GVA_CONFIG.AutoCode.Root, global.GVA_CONFIG.AutoCode.Server, "api", "v1", packageName),
			filepath.Join(global.GVA_CONFIG.AutoCode.Root, global.GVA_CONFIG.AutoCode.Server, "service", packageName),
			filepath.Join(global.GVA_CONFIG.AutoCode.Root, global.GVA_CONFIG.AutoCode.Server, "router", packageName),
		}

		for _, path := range paths {
			if err := t.removeDirectoryIfExists(path); err != nil {
				errors = append(errors, fmt.Sprintf("删除%s失败: %v", path, err))
			}
		}
	}

	if len(errors) > 0 {
		return fmt.Errorf("删除过程中出现错误: %s", strings.Join(errors, "; "))
	}

	return nil
}

// removeDirectoryIfExists 删除目录（如果存在）
func (t *AutomationModuleAnalyzer) removeDirectoryIfExists(dirPath string) error {
	// 检查文件夹是否存在
	if _, err := os.Stat(dirPath); os.IsNotExist(err) {
		// 文件夹不存在，无需删除
		return nil
	} else if err != nil {
		return fmt.Errorf("检查文件夹状态失败: %v", err)
	}

	// 删除文件夹及其所有内容
	if err := os.RemoveAll(dirPath); err != nil {
		return fmt.Errorf("删除文件夹失败: %v", err)
	}

	global.GVA_LOG.Info(fmt.Sprintf("成功删除目录: %s", dirPath))
	return nil
}

// cleanupRelatedApiAndMenus 清理与删除的模块相关的API和菜单记录
func (t *AutomationModuleAnalyzer) cleanupRelatedApiAndMenus(historyIDs []uint) error {
	if len(historyIDs) == 0 {
		return nil
	}

	// 获取要删除的历史记录信息
	var histories []model.SysAutoCodeHistory
	if err := global.GVA_DB.Where("id IN ?", historyIDs).Find(&histories).Error; err != nil {
		return fmt.Errorf("获取历史记录失败: %v", err)
	}

	var deletedApiCount, deletedMenuCount int

	for _, history := range histories {
		// 删除相关的API记录（使用存储的API IDs）
		if len(history.ApiIDs) > 0 {
			ids := make([]int, 0, len(history.ApiIDs))
			for _, id := range history.ApiIDs {
				ids = append(ids, int(id))
			}
			idsReq := common.IdsReq{Ids: ids}
			if err := systemService.ApiServiceApp.DeleteApisByIds(idsReq); err != nil {
				global.GVA_LOG.Warn(fmt.Sprintf("删除API记录失败 (模块: %s): %v", history.StructName, err))
			} else {
				deletedApiCount += len(ids)
				global.GVA_LOG.Info(fmt.Sprintf("成功删除API记录 (模块: %s, 数量: %d)", history.StructName, len(ids)))
			}
		}

		// 删除相关的菜单记录（使用存储的菜单ID）
		if history.MenuID != 0 {
			if err := systemService.BaseMenuServiceApp.DeleteBaseMenu(int(history.MenuID)); err != nil {
				global.GVA_LOG.Warn(fmt.Sprintf("删除菜单记录失败 (模块: %s, 菜单ID: %d): %v", history.StructName, history.MenuID, err))
			} else {
				deletedMenuCount++
				global.GVA_LOG.Info(fmt.Sprintf("成功删除菜单记录 (模块: %s, 菜单ID: %d)", history.StructName, history.MenuID))
			}
		}
	}

	if deletedApiCount > 0 || deletedMenuCount > 0 {
		global.GVA_LOG.Info(fmt.Sprintf("清理完成：删除了 %d 个API记录和 %d 个菜单记录", deletedApiCount, deletedMenuCount))
	}

	return nil
}