manta/gofaster/app/plugins/route-mapping-plugin.js

const { resolve } = require('path')
const { readFileSync, existsSync, readdirSync } = require('fs')
const fs = require('fs')
const parser = require('@babel/parser')
const traverse = require('@babel/traverse').default
const { parse } = require('@vue/compiler-sfc')

// 第一阶段路由映射插件 - 收集直接映射关系
function routeMappingPlugin() {
  // 检查是否在静默模式下运行
  const isSilentMode = process.env.ROUTE_MAPPING_SILENT === 'true' || process.argv.includes('--silent')
  
  // 日志函数
  const log = (message) => {
    if (!isSilentMode) {
      console.log(message)
    }
  }
  
  return {
    name: 'route-mapping-phase1',
    
    // 防重复生成机制
    _lastGenerationTime: 0,
    _generationInProgress: false,
    _generationCooldown: 10000, // 10秒冷却时间，增加冷却时间
    _maxGenerationsPerMinute: 3, // 每分钟最多生成3次
    _generationCount: 0,
    _generationWindowStart: 0,
    
    // Webpack插件接口
    apply(compiler) {
      const self = this
      
      // 在编译开始前就生成映射文件
      compiler.hooks.beforeCompile.tapAsync('RouteMappingPlugin', (params, callback) => {
        if (self._shouldSkipGeneration()) {
          log('⏭️ 跳过路由映射生成（冷却期内）')
          callback()
          return
        }
        
        log('🔧 第一阶段：开始收集直接路由-API映射关系...')
        try {
          self.collectDirectMappings()
          callback()
        } catch (error) {
          console.error('❌ 路由映射插件执行失败:', error)
          callback(error)
        }
      })
      
      // 备用钩子，确保在beforeRun时也执行
      compiler.hooks.beforeRun.tapAsync('RouteMappingPlugin', (compilation, callback) => {
        if (self._shouldSkipGeneration()) {
          console.log('⏭️ 跳过路由映射生成（冷却期内）')
          callback()
          return
        }
        
        console.log('🔧 第一阶段：开始收集直接路由-API映射关系...')
        try {
          self.collectDirectMappings()
          callback()
        } catch (error) {
          console.error('❌ 路由映射插件执行失败:', error)
          callback(error)
        }
      })
    },
    
    // Vite插件接口
    buildStart() {
      console.log('🔧 第一阶段：开始收集直接路由-API映射关系...')
      this.collectDirectMappings()
    },
    
    // 在开发模式下也执行
    configureServer(server) {
      if (this._shouldSkipGeneration()) {
        console.log('⏭️ 跳过路由映射生成（冷却期内）')
        return
      }
      console.log('🔧 开发模式下收集直接映射关系...')
      this.collectDirectMappings()
    },
    
    // 检查是否应该跳过生成
    _shouldSkipGeneration() {
      const now = Date.now()
      
      // 如果正在生成中，跳过
      if (this._generationInProgress) {
        console.log('⏭️ 跳过生成：正在生成中')
        return true
      }
      
      // 如果在冷却期内，跳过
      if (now - this._lastGenerationTime < this._generationCooldown) {
        const remainingTime = Math.ceil((this._generationCooldown - (now - this._lastGenerationTime)) / 1000)
        console.log(`⏭️ 跳过生成：冷却期内，还需等待 ${remainingTime} 秒`)
        return true
      }
      
      // 检查每分钟生成次数限制
      if (now - this._generationWindowStart > 60000) {
        // 重置计数窗口
        this._generationCount = 0
        this._generationWindowStart = now
      }
      
      if (this._generationCount >= this._maxGenerationsPerMinute) {
        console.log(`⏭️ 跳过生成：已达到每分钟最大生成次数限制 (${this._maxGenerationsPerMinute} 次)`)
        return true
      }
      
      return false
    },
    
    // 检查是否需要重新生成文件
    _shouldRegenerateFile() {
      const outputPath = resolve(__dirname, '../src/renderer/modules/route-sync/direct-route-mappings.js')
      
      // 如果文件不存在，需要生成
      if (!existsSync(outputPath)) {
        console.log('📄 映射文件不存在，需要生成')
        return true
      }
      
      const outputStats = fs.statSync(outputPath)
      const currentTime = Date.now()
      const fileModifyTime = outputStats.mtime.getTime()
      const timeDifference = currentTime - fileModifyTime
      const thirtyMinutes = 30 * 60 * 1000 // 30分钟的毫秒数
      
      // 检查文件是否超过30分钟未更新
      if (timeDifference > thirtyMinutes) {
        console.log(`⏰ 映射文件已存在 ${Math.round(timeDifference / (60 * 1000))} 分钟，超过30分钟限制，需要重新生成`)
        return true
      }
      
      // 检查源文件是否比生成文件更新
      const sourceFiles = this._getSourceFiles()
      
      for (const sourceFile of sourceFiles) {
        if (existsSync(sourceFile)) {
          const sourceStats = fs.statSync(sourceFile)
          if (sourceStats.mtime > outputStats.mtime) {
            console.log(`📝 检测到源文件更新: ${sourceFile}`)
            return true
          }
        }
      }
      
      console.log(`✅ 映射文件无需重新生成 (文件年龄: ${Math.round(timeDifference / (60 * 1000))} 分钟)`)
      return false
    },
    
    // 获取需要监控的源文件列表
    _getSourceFiles() {
      const sourceFiles = []
      
      // 路由配置文件
      sourceFiles.push(resolve(__dirname, '../src/renderer/router/index.js'))
      
      // 模块配置文件
      sourceFiles.push(resolve(__dirname, '../src/renderer/modules/config.js'))
      
      // 页面组件文件
      const moduleDirs = this.readModuleNamesFromConfig()
      moduleDirs.forEach(moduleName => {
        // 页面组件
        const viewsPath = resolve(__dirname, `../src/renderer/modules/${moduleName}/views`)
        if (existsSync(viewsPath)) {
          const files = readdirSync(viewsPath).filter(f => f.endsWith('.vue'))
          files.forEach(file => {
            sourceFiles.push(resolve(viewsPath, file))
          })
        }
        
        // 弹窗组件
        const componentsPath = resolve(__dirname, `../src/renderer/modules/${moduleName}/components`)
        if (existsSync(componentsPath)) {
          const files = readdirSync(componentsPath).filter(f => 
            f.endsWith('.vue') && (f.toLowerCase().includes('modal') || f.toLowerCase().includes('dialog'))
          )
          files.forEach(file => {
            sourceFiles.push(resolve(componentsPath, file))
          })
        }
      })
      
      return sourceFiles
    },
    
    // 收集直接映射关系
    collectDirectMappings() {
      // 设置生成中标志
      this._generationInProgress = true
      
      try {
        // 检查文件是否需要重新生成
        if (this._shouldRegenerateFile()) {
          console.log('🔄 检测到需要重新生成路由映射文件')
          
          // 1. 分析路由配置
          const routes = this.analyzeRoutes()          
          
          // 2. 收集API信息（第一层）
          const apiMappings = this.collectApiMappings(routes)
          
          // 3. 关联页面与API（第三层） - 启用并调整逻辑
          const enhancedApiMappings = this.associatePagesWithApi(routes, apiMappings)
          
          // 4. 清理和优化API映射（第四层） - 启用并调整逻辑
          const optimizedApiMappings = this.optimizeApiMappings(routes, enhancedApiMappings)
          
                    
          // 5. 生成最终映射文件
          this.generateMappingFile(routes, optimizedApiMappings)
          
          console.log('✅ 第一阶段直接映射关系收集完成')
        } else {
          console.log('⏭️ 路由映射文件无需重新生成')
        }
      } catch (error) {
        console.error('❌ 直接映射关系收集失败:', error)
        throw error
      } finally {
        // 重置生成中标志并更新时间戳
        this._generationInProgress = false
        this._lastGenerationTime = Date.now()
        this._generationCount++
        
        if (this._generationWindowStart === 0) {
          this._generationWindowStart = Date.now()
        }
      }
    },

    // 分析路由配置
    analyzeRoutes() {
      const routerPath = resolve(__dirname, '../src/renderer/router/index.js')
      if (!existsSync(routerPath)) {
        throw new Error('Router file not found')
      }
      
      const routerContent = readFileSync(routerPath, 'utf-8')
      const ast = parser.parse(routerContent, {
        sourceType: 'module',
        plugins: ['jsx']
      })
      
      const routes = []
      
      const self = this
      traverse(ast, {
        ObjectExpression(path) {
          const properties = path.node.properties
          let route = {}
          
          properties.forEach(prop => {
            if (prop.key && prop.key.name === 'path' && prop.value && prop.value.value) {
              route.path = prop.value.value
            }
            if (prop.key && prop.key.name === 'name' && prop.value && prop.value.value) {
              route.name = prop.value.value
            }
            if (prop.key && prop.key.name === 'component' && prop.value) {
              route.component = self.extractComponentName(prop.value)
            }
          })
          
          if (route.path) {
            route.module = self.extractModuleFromPath(route.path)
            // 添加description属性
            route.description = self.getRouteDescription(route.module, route.path)
            routes.push(route)
          }
        }
      })
      
      return routes
    },


    // 分析单个服务文件的API映射
    analyzeServiceFileForApiMappings(servicePath, serviceName, moduleName) {
      try {
        const content = readFileSync(servicePath, 'utf-8')
        const ast = parser.parse(content, {
          sourceType: 'module',
          plugins: ['jsx'],
          attachComments: true
        })
        
        const apiMappings = []
        const self = this
        
        traverse(ast, {
          // 查找函数定义
          FunctionDeclaration(path) {
            const functionName = path.node.id?.name
            if (functionName) {
              // 分析函数内部的API调用
              const apiCalls = self.extractApiCallsFromFunction(path)
              apiCalls.forEach(apiCall => {
                apiMappings.push({
                  methodName: functionName,
                  method: apiCall.method,
                  path: apiCall.path,
                  line: apiCall.line
                })
              })
            }
          },
          
          // 查找箭头函数和函数表达式
          VariableDeclarator(path) {
            if (path.node.init && (path.node.init.type === 'ArrowFunctionExpression' || path.node.init.type === 'FunctionExpression')) {
              const functionName = path.node.id?.name
              if (functionName) {
                const functionPath = path.get('init')
                const apiCalls = self.extractApiCallsFromFunction(functionPath)
                apiCalls.forEach(apiCall => {
                  apiMappings.push({
                    methodName: functionName,
                    method: apiCall.method,
                    path: apiCall.path,
                    line: apiCall.line
                  })
                })
              }
            }
          },
          
          // 查找对象方法定义
          ObjectMethod(path) {
            const methodName = path.node.key?.name
            if (methodName) {
              const apiCalls = self.extractApiCallsFromFunction(path)
              apiCalls.forEach(apiCall => {
                apiMappings.push({
                  methodName: methodName,
                  method: apiCall.method,
                  path: apiCall.path,
                  line: apiCall.line
                })
              })
            }
          },
          
          // 查找对象属性中的函数
          ObjectProperty(path) {
            if (path.node.value && (path.node.value.type === 'ArrowFunctionExpression' || path.node.value.type === 'FunctionExpression')) {
              const methodName = path.node.key?.name
              if (methodName) {
                const apiCalls = self.extractApiCallsFromFunction(path.get('value'))
                apiCalls.forEach(apiCall => {
                  apiMappings.push({
                    methodName: methodName,
                    method: apiCall.method,
                    path: apiCall.path,
                    line: apiCall.line
                  })
                })
              }
            }
          }
        })
        
        return apiMappings
      } catch (error) {
        console.warn(`⚠️ 分析服务文件失败: ${servicePath}`, error.message)
        return []
      }
    },

    // 从函数中提取API调用
    extractApiCallsFromFunction(functionPath) {
      const apiCalls = []
      const self = this
      
      // 首先检查函数注释中是否有 @serverApiMethod 标记
      const commentApiInfo = self.extractApiFromComment(functionPath)
      if (commentApiInfo) {
        apiCalls.push(commentApiInfo)
        return apiCalls
      }
      
      // 如果没有注释信息，则使用原来的AST遍历方式
      if (functionPath.node) {
        traverse(functionPath.node, {
          CallExpression(path) {
            const callInfo = self.extractApiCall(path)
            if (callInfo && callInfo.path) {
              apiCalls.push(callInfo)
            }
          }
        }, functionPath.scope, functionPath)
      }
      
      return apiCalls
    },

    // 从注释中提取API信息
    extractApiFromComment(functionPath) {
      const node = functionPath.node
      
      // 首先检查 leadingComments
      if (node && node.leadingComments) {
        for (const comment of node.leadingComments) {
          const commentText = comment.value.trim()
          const match = commentText.match(/@serverApiMethod\s+(\w+)\s+(.+)/)
          if (match) {
            const method = match[1].toUpperCase()
            const path = match[2].trim()
            return {
              method,
              path,
              line: node.loc ? node.loc.start.line : 0,
              source: 'comment'
            }
          }
        }
      } else {
      }
      
      // 如果没有找到注释，尝试从函数名推断API信息
      // 这是一个备用方案，用于测试
      return null
    },

    // 第二步（第一层）：收集API信息
    collectApiMappings(routes) {
      const apiMappings = []
      const moduleDirs = this.readModuleNamesFromConfig()
      
      console.log('🔍 开始收集API映射，模块列表:', moduleDirs)
      
      moduleDirs.forEach(moduleName => {
        const servicesPath = resolve(__dirname, `../src/renderer/modules/${moduleName}/services`)
        
        if (existsSync(servicesPath)) {
          const serviceFiles = readdirSync(servicesPath).filter(f => f.endsWith('.js'))
          console.log(`🔍 模块 ${moduleName} 的service文件:`, serviceFiles)
          
          serviceFiles.forEach(serviceFile => {
            const serviceName = serviceFile.replace('.js', '')
            const servicePath = resolve(servicesPath, serviceFile)
            const serviceApiMappings = this.analyzeServiceFileForApiMappings(servicePath, serviceName, moduleName)
            
            console.log(`🔍 服务 ${serviceName} 的API映射数量:`, serviceApiMappings.length)
            
            if (serviceApiMappings.length > 0) {
              apiMappings.push({
                module: moduleName,
                serviceName: serviceName,
                servicePath: servicePath,
                apiMappings: serviceApiMappings
              })
            }
          })
        } else {
          console.warn(`⚠️ 模块 ${moduleName} 的services目录不存在: ${servicesPath}`)
        }
      })
      
      console.log('🔍 最终收集到的API映射数量:', apiMappings.length)
      return apiMappings
    },

    // 第三步：关联页面与API
    associatePagesWithApi(routes, apiMappings) {
      console.log('🔍 开始关联页面与API，输入API映射数量:', apiMappings.length)
      
      // 为每个API映射添加调用该API的页面信息和触发器信息
      const enhancedApiMappings = apiMappings.map(moduleMapping => {
        console.log(`🔍 处理模块 ${moduleMapping.module}，API映射数量:`, moduleMapping.apiMappings.length)
        
        const enhancedApiMappings = moduleMapping.apiMappings.map(apiMapping => {
          // 查找调用该API方法的组件，并收集triggerSources信息
          const triggerSources = this.findTriggerSourcesForApiMethod(
            routes, 
            moduleMapping.module, 
            moduleMapping.serviceName, 
            apiMapping.methodName
          )
          
          console.log(`🔍 API方法 ${apiMapping.methodName} 的触发器数量:`, triggerSources.length)
          
          return {
            ...apiMapping,
            triggerSources: triggerSources
          }
        })
        
        return {
          ...moduleMapping,
          apiMappings: enhancedApiMappings
        }
      })
      
      console.log('🔍 关联完成，输出API映射数量:', enhancedApiMappings.length)
      return enhancedApiMappings
    },

    // 查找API方法的触发器源 - 使用简化的方法
    findTriggerSourcesForApiMethod(routes, moduleName, serviceName, methodName) {
      const triggerSources = []
      
      console.log(`🔍 查找API方法 ${serviceName}.${methodName} 的触发器源，模块: ${moduleName}`)
      
      // 1. 遍历所有路由，查找调用该API方法的页面组件
      routes.forEach(route => {
        if (route.module === moduleName) {
          console.log(`🔍 检查路由组件: ${route.component}`)
          const triggerAnalysis = this.analyzeComponentForTriggerSourcesSimple(
            route.component, 
            route.path, 
            moduleName,
            serviceName,
            methodName
          )
          
          if (triggerAnalysis && triggerAnalysis.triggerSources.length > 0) {
            triggerSources.push(...triggerAnalysis.triggerSources)
            console.log(`✅ 在组件 ${route.component} 中找到 ${triggerAnalysis.triggerSources.length} 个触发器`)
          }
        }
      })
      
      // 2. 搜索模块的components目录，查找调用该API方法的组件
      const componentsInModule = this.findComponentsInModule(moduleName)
      console.log(`🔍 模块 ${moduleName} 的组件:`, componentsInModule)
      
      componentsInModule.forEach(componentName => {
        console.log(`🔍 检查模块组件: ${componentName}`)
        const triggerAnalysis = this.analyzeComponentForTriggerSourcesSimple(
          componentName, 
          null, // components目录中的组件没有路由路径
          moduleName,
          serviceName,
          methodName
        )
        
        if (triggerAnalysis && triggerAnalysis.triggerSources.length > 0) {
          triggerSources.push(...triggerAnalysis.triggerSources)
          console.log(`✅ 在组件 ${componentName} 中找到 ${triggerAnalysis.triggerSources.length} 个触发器`)
        }
      })
      
      // 去重
      const uniqueTriggerSources = []
      const seen = new Set()
      
      triggerSources.forEach(trigger => {
        const key = `${trigger.component}#${trigger.triggerName || 'default'}`
        if (!seen.has(key)) {
          seen.add(key)
          uniqueTriggerSources.push(trigger)
        }
      })
      
      console.log(`🔍 API方法 ${serviceName}.${methodName} 最终触发器数量:`, uniqueTriggerSources.length)
      return uniqueTriggerSources
    },

    // 简化的组件触发器源分析方法
    analyzeComponentForTriggerSourcesSimple(componentName, componentPath, moduleName, serviceName, methodName) {
      try {
        let filePath = componentPath
        
        console.log(`🔍 简化分析组件 ${componentName}，查找服务 ${serviceName}.${methodName}`)
        
        // 如果是组件名，需要找到对应的文件
        if (!filePath || !existsSync(filePath)) {
          filePath = this.findComponentFile(componentName)
        }
        
        if (!filePath || !existsSync(filePath)) {
          console.warn(`⚠️ 组件文件未找到: ${componentName}`)
          return { triggerSources: [] }
        }
        
        console.log(`🔍 找到组件文件: ${filePath}`)
        const content = readFileSync(filePath, 'utf-8')
        
        // 使用简化的文本搜索方法
        return this.analyzeComponentWithTextSearch(content, componentName, serviceName, methodName)
        
      } catch (error) {
        console.warn(`⚠️ 简化分析组件触发器源失败: ${componentName}`, error.message)
        return { triggerSources: [] }
      }
    },

    // 使用文本搜索分析组件
    analyzeComponentWithTextSearch(content, componentName, serviceName, methodName) {
      const triggerSources = []

      console.log(`🔍 文本搜索组件 ${componentName}，查找 ${serviceName}.${methodName}`)

      // 1. 检查组件的authType属性，如果是public则跳过
      // 支持两种格式：<template authType="public"> 和 authType: 'public'
      const authTypeMatch = content.match(/authType\s*[=:]\s*["']([^"']+)["']/)
      if (authTypeMatch) {
        const authType = authTypeMatch[1]
        console.log(`🔍 组件 ${componentName} 的authType: ${authType}`)
        if (authType === 'public') {
          console.log(`⏭️ 跳过公开组件 ${componentName}，不记录triggerSource`)
          return { triggerSources: [] }
        }
      }

      // 2. 检查是否包含服务调用
      const serviceCallPattern = new RegExp(`${serviceName}\\.${methodName}\\s*\\(`, 'g')
      if (!serviceCallPattern.test(content)) {
        console.log(`⚠️ 组件 ${componentName} 中没有找到 ${serviceName}.${methodName} 调用`)
        return { triggerSources: [] }
      }

      console.log(`✅ 组件 ${componentName} 中包含 ${serviceName}.${methodName} 调用`)

      // 3. 查找调用该API方法的具体方法名
      const callingMethods = this.findMethodsCallingServiceInText(content, serviceName, methodName)
      console.log(`🔍 找到调用 ${serviceName}.${methodName} 的方法:`, callingMethods)

      // 4. 先查找Vue模板中调用这些方法的按钮和控件
      if (content.includes('<template>') && callingMethods.length > 0) {
        const templateMatch = content.match(/<template>([\s\S]*?)<\/template>/)
        if (templateMatch) {
          const templateContent = templateMatch[1]
          const templateTriggers = this.findTriggersInTemplateForMethods(templateContent, componentName, callingMethods)
          triggerSources.push(...templateTriggers)
        }
      }

      // 5. 如果没有找到具体的按钮触发器，才记录页面级别的调用
      if (triggerSources.length === 0) {
        triggerSources.push({
          component: componentName,
          triggerName: null,
          triggerType: 'page'
        })
        console.log(`✅ 没有找到按钮触发器，记录页面级触发器: ${componentName}`)
      } else {
        console.log(`✅ 找到 ${triggerSources.length} 个按钮触发器`)
      }

      console.log(`🔍 组件 ${componentName} 最终触发器数量:`, triggerSources.length)
      return { triggerSources: triggerSources }
    },

    // 在模板中查找触发器 - 简化版本
    findTriggersInTemplateSimple(templateContent, componentName) {
      const triggerSources = []
      
      console.log(`🔍 在模板中查找触发器，组件: ${componentName}`)
      
      // 查找有name属性的button元素
      const buttonWithNameRegex = /<button[^>]*name\s*=\s*["']([^"']+)["'][^>]*@click\s*=\s*["']([^"']+)["'][^>]*>/g
      let match
      
      while ((match = buttonWithNameRegex.exec(templateContent)) !== null) {
        const buttonName = match[1]
        const clickHandler = match[2]
        
        console.log(`🔍 找到按钮: ${buttonName}, 点击处理器: ${clickHandler}`)
        
        triggerSources.push({
          component: componentName,
          triggerName: buttonName,
          triggerType: 'button'
        })
        console.log(`✅ 匹配到按钮触发器: ${buttonName}`)
      }
      
      // 查找没有name属性的button元素
      const buttonNoNameRegex = /<button[^>]*@click\s*=\s*["']([^"']+)["'][^>]*>/g
      
      while ((match = buttonNoNameRegex.exec(templateContent)) !== null) {
        const clickHandler = match[1]
        
        console.log(`🔍 找到无name按钮，点击处理器: ${clickHandler}`)
        
        triggerSources.push({
          component: componentName,
          triggerName: null,
          triggerType: 'page'
        })
        console.log(`✅ 匹配到无name按钮触发器: ${clickHandler}`)
      }
      
      // 查找表单提交
      const formSubmitRegex = /<form[^>]*@submit\s*=\s*["']([^"']+)["'][^>]*>/g
      
      while ((match = formSubmitRegex.exec(templateContent)) !== null) {
        const submitHandler = match[1]
        
        console.log(`🔍 找到表单提交，处理器: ${submitHandler}`)
        
        triggerSources.push({
          component: componentName,
          triggerName: 'form-submit',
          triggerType: 'form'
        })
        console.log(`✅ 匹配到表单触发器: ${submitHandler}`)
      }
      
      return triggerSources
    },

    // 分析组件中的触发器源
    analyzeComponentForTriggerSources(componentName, componentPath, moduleName, serviceName, methodName) {
      try {
        let filePath = componentPath
        
        console.log(`🔍 分析组件 ${componentName}，查找服务 ${serviceName}.${methodName}`)
        
        // 如果是组件名，需要找到对应的文件
        if (!filePath || !existsSync(filePath)) {
          filePath = this.findComponentFile(componentName)
        }
        
        if (!filePath || !existsSync(filePath)) {
          console.warn(`⚠️ 组件文件未找到: ${componentName}`)
          return { triggerSources: [] }
        }
        
        console.log(`🔍 找到组件文件: ${filePath}`)
        const content = readFileSync(filePath, 'utf-8')
        
        if (filePath.endsWith('.vue')) {
          return this.analyzeVueComponentForTriggerSources(content, componentName, moduleName, serviceName, methodName)
        } else {
          return this.analyzeJavaScriptComponentForTriggerSources(content, componentName, moduleName, serviceName, methodName)
        }
      } catch (error) {
        console.warn(`⚠️ 分析组件触发器源失败: ${componentName}`, error.message)
        return { triggerSources: [] }
      }
    },

    // 分析Vue组件中的触发器源
    analyzeVueComponentForTriggerSources(content, componentName, moduleName, serviceName, methodName) {
      const { descriptor } = parse(content)
      const scriptContent = descriptor.script?.content || ''
      const templateContent = descriptor.template?.content || ''
      
      console.log(`🔍 分析Vue组件 ${componentName}，script长度: ${scriptContent.length}, template长度: ${templateContent.length}`)
      
      if (!scriptContent) {
        console.log(`⚠️ 组件 ${componentName} 没有script部分`)
        return { triggerSources: [] }
      }
      
      // 解析script部分，找到调用指定service方法的方法
      const ast = parser.parse(scriptContent, {
        sourceType: 'module',
        plugins: ['jsx']
      })
      
      const callingMethods = this.findMethodsCallingService(ast, serviceName, methodName)
      console.log(`🔍 在组件 ${componentName} 中找到调用 ${serviceName}.${methodName} 的方法:`, callingMethods)
      
      if (callingMethods.length === 0) {
        return { triggerSources: [] }
      }
      
      // 解析template部分，找到调用这些方法的控件
      const triggerSources = this.findTriggerSourcesInTemplate(templateContent, callingMethods, componentName)
      
      return { triggerSources: triggerSources }
    },

    // 分析JavaScript组件中的触发器源
    analyzeJavaScriptComponentForTriggerSources(content, componentName, moduleName, serviceName, methodName) {
      const ast = parser.parse(content, {
        sourceType: 'module',
        plugins: ['jsx']
      })
      
      const callingMethods = this.findMethodsCallingService(ast, serviceName, methodName)
      
      if (callingMethods.length === 0) {
        return { triggerSources: [] }
      }
      
      // 对于JS组件，我们假设方法名就是触发器
      const triggerSources = callingMethods.map(method => ({
        component: componentName,
        triggerName: method,
        triggerType: 'method'
      }))
      
      return { triggerSources: triggerSources }
    },

    // 在模板中查找触发器源
    findTriggerSourcesInTemplate(templateContent, methodNames, componentName) {
      const triggerSources = []
      
      console.log(`🔍 在组件 ${componentName} 中查找触发器，方法名:`, methodNames)
      
      // 查找button元素 - 改进正则表达式
      const buttonRegex = /<button[^>]*name\s*=\s*["']([^"']+)["'][^>]*@click\s*=\s*["']([^"']+)["'][^>]*>/g
      let match
      
      while ((match = buttonRegex.exec(templateContent)) !== null) {
        const buttonName = match[1]
        const clickHandler = match[2]
        
        console.log(`🔍 找到按钮: ${buttonName}, 点击处理器: ${clickHandler}`)
        
        // 检查clickHandler是否在methodNames中
        if (methodNames.includes(clickHandler)) {
          triggerSources.push({
            component: componentName,
            triggerName: buttonName,
            triggerType: 'button'
          })
          console.log(`✅ 匹配到触发器: ${buttonName} -> ${clickHandler}`)
        }
      }
      
      // 查找没有name属性的button元素
      const buttonNoNameRegex = /<button[^>]*@click\s*=\s*["']([^"']+)["'][^>]*>/g
      
      while ((match = buttonNoNameRegex.exec(templateContent)) !== null) {
        const clickHandler = match[1]
        
        console.log(`🔍 找到无name按钮，点击处理器: ${clickHandler}`)
        
        // 检查clickHandler是否在methodNames中
        if (methodNames.includes(clickHandler)) {
          triggerSources.push({
            component: componentName,
            triggerName: null,
            triggerType: 'button'
          })
          console.log(`✅ 匹配到无name触发器: ${clickHandler}`)
        }
      }
      
      // 查找其他可能的响应式控件（如input、select等）
      const inputRegex = /<(input|select|textarea)[^>]*name\s*=\s*["']([^"']+)["'][^>]*@(change|input|blur)\s*=\s*["']([^"']+)["'][^>]*>/g
      
      while ((match = inputRegex.exec(templateContent)) !== null) {
        const elementType = match[1]
        const elementName = match[2]
        const eventType = match[3]
        const eventHandler = match[4]
        
        console.log(`🔍 找到控件: ${elementName}, 事件处理器: ${eventHandler}`)
        
        // 检查eventHandler是否在methodNames中
        if (methodNames.includes(eventHandler)) {
          triggerSources.push({
            component: componentName,
            triggerName: elementName,
            triggerType: `${elementType}_${eventType}`
          })
          console.log(`✅ 匹配到控件触发器: ${elementName} -> ${eventHandler}`)
        }
      }
      
      // 如果没有找到具体的控件，但有调用方法，则记录组件名
      if (triggerSources.length === 0 && methodNames.length > 0) {
        triggerSources.push({
          component: componentName,
          triggerName: null,
          triggerType: 'component'
        })
        console.log(`✅ 记录组件级触发器: ${componentName}`)
      }
      
      console.log(`🔍 组件 ${componentName} 最终触发器数量:`, triggerSources.length)
      return triggerSources
    },




    // 查找模块中的所有组件
    findComponentsInModule(moduleName) {
      const components = []
      
      try {
        // 查找views目录中的组件
        const viewsPath = resolve(__dirname, `../src/renderer/modules/${moduleName}/views`)
        if (existsSync(viewsPath)) {
          const viewFiles = readdirSync(viewsPath).filter(f => f.endsWith('.vue'))
          viewFiles.forEach(file => {
            components.push(file.replace('.vue', ''))
          })
        }
        
        // 查找components目录中的组件
        const componentsPath = resolve(__dirname, `../src/renderer/modules/${moduleName}/components`)
        if (existsSync(componentsPath)) {
          const componentFiles = readdirSync(componentsPath).filter(f => f.endsWith('.vue'))
          componentFiles.forEach(file => {
            components.push(file.replace('.vue', ''))
          })
        }
      } catch (error) {
        console.warn(`⚠️ 查找模块组件失败: ${moduleName}`, error.message)
      }
      
      return components
    },

    // 第四步：清理和优化API映射
    optimizeApiMappings(routes, apiMappings) {
      console.log('🔍 开始清理和优化API映射，输入API映射数量:', apiMappings.length)
      
      const optimizedApiMappings = apiMappings.map(moduleMapping => {
        console.log(`🔍 处理模块 ${moduleMapping.module}，原始API映射数量:`, moduleMapping.apiMappings.length)
        
        // 过滤掉triggerSources为空的API映射
        const filteredApiMappings = moduleMapping.apiMappings.filter(apiMapping => {
          const hasTriggers = apiMapping.triggerSources && apiMapping.triggerSources.length > 0
          if (!hasTriggers) {
            console.log(`🗑️ 删除无触发器的API映射: ${apiMapping.methodName}`)
          }
          return hasTriggers
        })
        
        console.log(`🔍 模块 ${moduleMapping.module} 过滤后API映射数量:`, filteredApiMappings.length)
        
        return {
          ...moduleMapping,
          apiMappings: filteredApiMappings
        }
      }).filter(moduleMapping => moduleMapping.apiMappings.length > 0) // 过滤掉没有API映射的模块
      
      const totalRemoved = apiMappings.reduce((sum, module) => 
        sum + module.apiMappings.length, 0) - optimizedApiMappings.reduce((sum, module) => 
        sum + module.apiMappings.length, 0)
      
      console.log(`🔍 清理完成，删除了 ${totalRemoved} 个无触发器的API映射`)
      console.log(`🔍 输出API映射数量:`, optimizedApiMappings.length)
      
      return optimizedApiMappings
    },



    // 分析组件中的服务调用
    analyzeComponentForServiceCalls(componentName, componentPath, moduleName) {
      try {
        let filePath = componentPath
        
        // 如果是组件名，需要找到对应的文件
        if (!filePath || !existsSync(filePath)) {
          filePath = this.findComponentFile(componentName)
        }
        
        if (!filePath || !existsSync(filePath)) {
          console.warn(`⚠️ 组件文件未找到: ${componentName}`)
          return null
        }
        
        const content = readFileSync(filePath, 'utf-8')
        
        if (filePath.endsWith('.vue')) {
          return this.analyzeVueComponentForServiceCalls(content, componentName, moduleName)
        } else {
          return this.analyzeJavaScriptComponentForServiceCalls(content, componentName, moduleName)
        }
      } catch (error) {
        console.warn(`⚠️ 分析组件失败: ${componentName}`, error.message)
        return null
      }
    },

    // 分析组件中调用特定API方法的服务调用和触发器
    analyzeComponentForServiceCallsWithTriggers(componentName, componentPath, moduleName, serviceName, methodName) {
      try {
        let filePath = componentPath
        
        // 如果是组件名，需要找到对应的文件
        if (!filePath || !existsSync(filePath)) {
          filePath = this.findComponentFile(componentName)
        }
        
        if (!filePath || !existsSync(filePath)) {
          console.warn(`⚠️ 组件文件未找到: ${componentName}`)
          return { hasServiceCall: false, triggerSources: [] }
        }
        
        const content = readFileSync(filePath, 'utf-8')
        
        if (filePath.endsWith('.vue')) {
          return this.analyzeVueComponentForServiceCallsWithTriggers(content, componentName, moduleName, serviceName, methodName)
        } else {
          return this.analyzeJavaScriptComponentForServiceCallsWithTriggers(content, componentName, moduleName, serviceName, methodName)
        }
      } catch (error) {
        console.warn(`⚠️ 分析组件服务调用和触发器失败: ${componentName}`, error.message)
        return { hasServiceCall: false, triggerSources: [] }
      }
    },

    // 分析Vue组件中的服务调用和触发器
    analyzeVueComponentForServiceCallsWithTriggers(content, componentName, moduleName, serviceName, methodName) {
      const { descriptor } = parse(content)
      const scriptContent = descriptor.script?.content || ''
      const templateContent = descriptor.template?.content || ''
      
      if (!scriptContent) {
        return { hasServiceCall: false, triggerSources: [] }
      }
      
      // 解析script部分，找到调用指定service方法的方法
      const ast = parser.parse(scriptContent, {
        sourceType: 'module',
        plugins: ['jsx']
      })
      
      const callingMethods = this.findMethodsCallingService(ast, serviceName, methodName)
      
      if (callingMethods.length === 0) {
        return { hasServiceCall: false, triggerSources: [] }
      }
      
      // 解析template部分，找到调用这些方法的button
      const triggerSources = this.findButtonsCallingMethods(templateContent, callingMethods, componentName)
      
      return { 
        hasServiceCall: true, 
        triggerSources: triggerSources 
      }
    },

    // 分析JavaScript组件中的服务调用和触发器
    analyzeJavaScriptComponentForServiceCallsWithTriggers(content, componentName, moduleName, serviceName, methodName) {
      const ast = parser.parse(content, {
        sourceType: 'module',
        plugins: ['jsx']
      })
      
      const callingMethods = this.findMethodsCallingService(ast, serviceName, methodName)
      
      if (callingMethods.length === 0) {
        return { hasServiceCall: false, triggerSources: [] }
      }
      
      // 对于JS组件，我们假设方法名就是触发器
      const triggerSources = callingMethods.map(method => `${componentName}#${method}`)
      
      return { 
        hasServiceCall: true, 
        triggerSources: triggerSources 
      }
    },


    // 查找调用指定service方法的方法
    findMethodsCallingService(ast, serviceName, methodName) {
      const callingMethods = []
      const self = this
      
      traverse(ast, {
        ObjectMethod(path) {
          const methodName = path.node.key?.name
          if (methodName) {
            const hasServiceCall = self.checkMethodCallsService(path, serviceName, methodName)
            if (hasServiceCall) {
              callingMethods.push(methodName)
            }
          }
        },
        
        ObjectProperty(path) {
          if (path.node.value && (path.node.value.type === 'ArrowFunctionExpression' || path.node.value.type === 'FunctionExpression')) {
            const methodName = path.node.key?.name
            if (methodName) {
              const hasServiceCall = self.checkMethodCallsService(path.get('value'), serviceName, methodName)
              if (hasServiceCall) {
                callingMethods.push(methodName)
              }
            }
          }
        }
      })
      
      return callingMethods
    },

    // 检查方法是否调用了指定的service方法
    checkMethodCallsService(methodPath, serviceName, methodName) {
      let hasServiceCall = false
      
      traverse(methodPath.node, {
        CallExpression(path) {
          const node = path.node
          if (node.callee && node.callee.type === 'MemberExpression') {
            const object = node.callee.object
            const property = node.callee.property
            
            if (object && property && 
                object.name === serviceName && 
                property.name === methodName) {
              hasServiceCall = true
            }
          }
        }
      }, methodPath.scope, methodPath)
      
      return hasServiceCall
    },

    // 在template中查找调用指定方法的button
    findButtonsCallingMethods(templateContent, methodNames, componentName) {
      const triggerSources = []
      
      // 使用正则表达式查找button元素
      const buttonRegex = /<button[^>]*name\s*=\s*["']([^"']+)["'][^>]*@click\s*=\s*["']([^"']+)["'][^>]*>/g
      let match
      
      while ((match = buttonRegex.exec(templateContent)) !== null) {
        const buttonName = match[1]
        const clickHandler = match[2]
        
        // 检查clickHandler是否在methodNames中
        if (methodNames.includes(clickHandler)) {
          triggerSources.push(`${componentName}#${buttonName}`)
        }
      }
      
      return triggerSources
    },

    // 分析Vue组件中的服务调用
    analyzeVueComponentForServiceCalls(content, componentName, moduleName) {
      const { descriptor } = parse(content)
      const scriptContent = descriptor.script?.content || ''
      
      if (!scriptContent) {
        return { serviceCalls: [], methods: [] }
      }
      
      const ast = parser.parse(scriptContent, {
        sourceType: 'module',
        plugins: ['jsx']
      })
      
      return this.extractServiceCallsFromAST(ast, componentName, moduleName)
    },

    // 分析JavaScript组件中的服务调用
    analyzeJavaScriptComponentForServiceCalls(content, componentName, moduleName) {
      const ast = parser.parse(content, {
        sourceType: 'module',
        plugins: ['jsx']
      })
      
      return this.extractServiceCallsFromAST(ast, componentName, moduleName)
    },

    // 从AST中提取服务调用
    extractServiceCallsFromAST(ast, componentName, moduleName) {
      const serviceCalls = []
      const methods = []
      
      const self = this
      traverse(ast, {
        // 查找方法定义
        FunctionDeclaration(path) {
          if (path.node.id) {
            methods.push(path.node.id.name)
          }
        },
        
        // 查找箭头函数
        ArrowFunctionExpression(path) {
          if (path.parent && path.parent.type === 'VariableDeclarator' && path.parent.id) {
            methods.push(path.parent.id.name)
          }
        },
        
        // 查找服务调用
        CallExpression(path) {
          const callInfo = self.extractServiceCall(path)
          if (callInfo) {
            serviceCalls.push(callInfo)
          }
        }
      })
      
      return { serviceCalls, methods }
    },

    // 提取服务调用信息
    extractServiceCall(path) {
      const node = path.node
      
      // 检查是否是服务调用 (service.method())
      if (node.callee && node.callee.type === 'MemberExpression') {
        const object = node.callee.object
        const property = node.callee.property
        
        if (object && property && object.name && property.name) {
          // 检查是否是服务调用
          if (object.name.endsWith('Service') || object.name === 'api' || object.name === 'axios') {
            return {
              type: 'service',
              service: object.name,
              method: property.name,
              arguments: node.arguments.map(arg => this.extractArgumentValue(arg)),
              line: node.loc?.start?.line || 0
            }
          }
        }
      }
      
      return null
    },

  








    // 提取API调用信息
    extractApiCall(path) {
      const node = path.node
      const self = this
      
      // 检查是否是直接的API调用 (api.get, api.post等)
      if (node.callee && node.callee.type === 'MemberExpression') {
        const object = node.callee.object
        const property = node.callee.property
        
        if (object && property) {
          // 支持多种API调用方式
          const apiObjects = ['api', 'axios', 'http', 'request']
          const httpMethods = ['get', 'post', 'put', 'delete', 'patch', 'head', 'options']
          
          // 检查对象名称（可能是Identifier或StringLiteral）
          let objectName = ''
          if (object.type === 'Identifier') {
            objectName = object.name
          } else if (object.type === 'StringLiteral') {
            objectName = object.value
          }
          
          // 检查属性名称
          let propertyName = ''
          if (property.type === 'Identifier') {
            propertyName = property.name
          } else if (property.type === 'StringLiteral') {
            propertyName = property.value
          }
          
          if (apiObjects.includes(objectName) && httpMethods.includes(propertyName)) {
            const method = propertyName
            const args = node.arguments
            
            // 提取API路径
            let apiPath = ''
            if (args.length > 0) {
              if (args[0].type === 'StringLiteral') {
                apiPath = args[0].value
              } else if (args[0].type === 'TemplateLiteral') {
                // 处理模板字符串
                apiPath = self.extractTemplateLiteral(args[0])
              }
            }
            
            if (apiPath) {
              return {
                method: method.toUpperCase(),
                path: apiPath,
                line: node.loc?.start?.line || 0
              }
            }
          }
        }
      }
      
      // 检查是否是服务调用 (service.method())
      if (node.callee && node.callee.type === 'MemberExpression') {
        const object = node.callee.object
        const property = node.callee.property
        
        if (object && property) {
          let objectName = ''
          let propertyName = ''
          
          if (object.type === 'Identifier') {
            objectName = object.name
          } else if (object.type === 'StringLiteral') {
            objectName = object.value
          }
          
          if (property.type === 'Identifier') {
            propertyName = property.name
          } else if (property.type === 'StringLiteral') {
            propertyName = property.value
          }
          
          // 检查是否是服务调用
          if (objectName && propertyName && 
              (objectName.endsWith('Service') || objectName === 'api' || objectName === 'axios')) {
            return {
              method: propertyName,
              service: objectName,
              line: node.loc?.start?.line || 0
            }
          }
        }
      }
      
      return null
    },

    // 提取参数值
    extractArgumentValue(node) {
      if (node.type === 'StringLiteral') {
        return node.value
      } else if (node.type === 'NumericLiteral') {
        return node.value
      } else if (node.type === 'Identifier') {
        return node.name
      }
      return null
    },

    // 提取模板字符串内容
    extractTemplateLiteral(templateLiteral) {
      if (templateLiteral.type !== 'TemplateLiteral') {
        return ''
      }
      
      let result = ''
      templateLiteral.quasis.forEach((quasi, index) => {
        result += quasi.value.raw
        if (index < templateLiteral.expressions.length) {
          // 对于表达式，我们使用实际的变量名作为占位符
          const expression = templateLiteral.expressions[index]
          const variableName = this.extractArgumentValue(expression)
          
          if (variableName) {
            result += `{${variableName}}`
          } else {
            // 如果无法提取变量名，使用节点类型作为后备
            result += `{${expression.type}}`
          }
        }
      })
      
      return result
    },

    // 从模块配置中读取模块名称
    readModuleNamesFromConfig() {
      try {
        const configPath = resolve(__dirname, '../src/renderer/modules/config.js')
        if (!existsSync(configPath)) {
          console.warn('⚠️ 模块配置文件不存在:', configPath)
          return []
        }

        const code = readFileSync(configPath, 'utf-8')
        const ast = parser.parse(code, { sourceType: 'module' })
        const modules = []

        traverse(ast, {
          ExportNamedDeclaration(path) {
            const decl = path.node.declaration
            if (decl && decl.type === 'VariableDeclaration') {
              decl.declarations.forEach(d => {
                if (
                  d.id && d.id.name === 'MODULE_CONFIG' &&
                  d.init && d.init.type === 'ObjectExpression'
                ) {
                  d.init.properties.forEach(prop => {
                    if (prop.type === 'ObjectProperty') {
                      if (prop.key.type === 'Identifier') {
                        modules.push(prop.key.name)
                      } else if (prop.key.type === 'StringLiteral') {
                        modules.push(prop.key.value)
                      }
                    }
                  })
                }
              })
            }
          }
        })

        return modules
      } catch (e) {
        console.warn('⚠️ 读取 MODULE_CONFIG 失败，使用默认模块集合: ', e.message)
        return []
      }
    },
    

    // 查找组件文件
    findComponentFile(componentName) {
      // 跳过MainLayout等特殊组件，或者返回正确的路径
      if (componentName === 'MainLayout') {
        // MainLayout在core模块中
        const mainLayoutPath = resolve(__dirname, '../src/renderer/modules/core/components/MainLayout.vue')
        if (existsSync(mainLayoutPath)) {
          return mainLayoutPath
        }
        return null
      }
      
      const moduleDirs = this.readModuleNamesFromConfig()
      
      for (const moduleName of moduleDirs) {
        // 查找views目录
        const viewsPath = resolve(__dirname, `../src/renderer/modules/${moduleName}/views`)
        if (existsSync(viewsPath)) {
          const files = readdirSync(viewsPath).filter(f => f.endsWith('.vue'))
          const matchingFile = files.find(f => f.replace('.vue', '') === componentName)
          if (matchingFile) {
            return resolve(viewsPath, matchingFile)
          }
        }
        
        // 查找components目录
        const componentsPath = resolve(__dirname, `../src/renderer/modules/${moduleName}/components`)
        if (existsSync(componentsPath)) {
          const files = readdirSync(componentsPath).filter(f => f.endsWith('.vue'))
          const matchingFile = files.find(f => f.replace('.vue', '') === componentName)
          if (matchingFile) {
            return resolve(componentsPath, matchingFile)
          }
        }
      }
      
      return null
    },

    // 生成最终映射文件
    generateMappingFile(routes, apiMappings) {
      const outputPath = resolve(__dirname, '../src/renderer/modules/route-sync/direct-route-mappings.js')
      
      console.log('🔍 生成映射文件，API映射数量:', apiMappings.length)
      console.log('🔍 API映射内容:', JSON.stringify(apiMappings, null, 2))
      
      // 如果文件已存在，先删除文件内容（清空文件）
      if (existsSync(outputPath)) {
        console.log('🗑️ 检测到已存在的映射文件，正在清空文件内容...')
        fs.writeFileSync(outputPath, '', 'utf-8')
      }
      
      const testContent = `// 直接路由映射文件
// 此文件由 route-mapping-plugin 在构建时生成
// 包含路由配置分析结果和API收集结果
// 请勿手动修改

export const directRouteMappings = {
  // 路由配置分析结果
  routes: ${JSON.stringify(routes, null, 2)},
  
  // API收集结果（包含页面关联和路径完善）
  apiMappings: ${JSON.stringify(apiMappings, null, 2)}
}

export default directRouteMappings
`
      
      fs.writeFileSync(outputPath, testContent, 'utf-8')
      
      console.log(`✅ 映射文件已生成: ${outputPath}`)
      console.log(`📊 统计信息:`)
      console.log(`   - 路由数量: ${routes.length} 个`)
      console.log(`   - 模块数量: ${apiMappings.length} 个`)
      console.log(`   - 总API调用: ${apiMappings.reduce((sum, module) => sum + module.apiMappings.length, 0)} 个`)
      console.log(`   - 总组件关联: ${apiMappings.reduce((sum, module) => 
        sum + module.apiMappings.reduce((apiSum, api) => apiSum + (api.callingComponents ? api.callingComponents.length : 0), 0), 0)} 个`)
    },

    

    
    // 提取组件名称
    extractComponentName(node) {
      if (node.type === 'Identifier') {
        return node.name
      } else if (node.type === 'StringLiteral') {
        return node.value
      }
      return null
    },
    
    
    // 从路径提取模块名
    extractModuleFromPath(path) {
      if (path === '/' || path === '') return 'home'
      
      const segments = path.split('/').filter(Boolean)
      if (segments.length === 0) return 'home'
      
      // 特殊处理：user-profile路径对应user-management模块
      if (segments[0] === 'user-profile') {
        return 'user-management'
      }
      
      return segments[0]
    },

    // 获取路由描述
    getRouteDescription(module, path) {
      try {
        // 读取RouteConfig文件
        const routeConfigPath = resolve(__dirname, '../src/renderer/modules/route-sync/RouteConfig.js')
        if (!existsSync(routeConfigPath)) {
          console.warn(`⚠️ RouteConfig文件不存在: ${routeConfigPath}`)
          return `${module}页面`
        }
        
        const routeConfigContent = readFileSync(routeConfigPath, 'utf-8')
        
        // 解析RouteConfig文件，提取descriptions对象
        const descriptions = this.extractDescriptionsFromRouteConfig(routeConfigContent)
        
        // 查找对应的描述
        if (descriptions && descriptions[module]) {
          return descriptions[module]
        } else {
          // 特殊处理：如果是user-profile路径，使用user-profile的描述
          if (path === '/user-profile' && descriptions && descriptions['user-profile']) {
            return descriptions['user-profile']
          }
          
          // 如果找不到对应的key，输出错误日志但不影响运行
          console.error(`❌ RouteConfig.descriptions中缺少模块 "${module}" 的配置，路径: ${path}`)
          return `${module}页面`
        }
      } catch (error) {
        console.warn(`⚠️ 获取路由描述失败: ${error.message}`)
        return `${module}页面`
      }
    },

    // 从RouteConfig文件中提取descriptions对象
    extractDescriptionsFromRouteConfig(content) {
      try {
        const ast = parser.parse(content, {
          sourceType: 'module',
          plugins: ['jsx']
        })
        
        let descriptions = null
        
        traverse(ast, {
          ObjectExpression(path) {
            // 查找descriptions属性
            const properties = path.node.properties
            const descriptionsProp = properties.find(prop => 
              prop.key && prop.key.name === 'descriptions'
            )
            
            if (descriptionsProp && descriptionsProp.value && descriptionsProp.value.type === 'ObjectExpression') {
              // 解析descriptions对象
              descriptions = {}
              descriptionsProp.value.properties.forEach(prop => {
                if (prop.key && prop.key.type === 'StringLiteral' && prop.value && prop.value.type === 'StringLiteral') {
                  descriptions[prop.key.value] = prop.value.value
                }
              })
            }
          }
        })
        
        return descriptions
      } catch (error) {
        console.warn(`⚠️ 解析RouteConfig失败: ${error.message}`)
        return null
      }
    },

    // 在文本中查找调用指定service方法的方法名
    findMethodsCallingServiceInText(content, serviceName, methodName) {
      const callingMethods = []
      
      try {
        // 解析script部分
        const scriptMatch = content.match(/<script[^>]*>([\s\S]*?)<\/script>/)
        if (!scriptMatch) {
          return callingMethods
        }
        
        const scriptContent = scriptMatch[1]
        
        // 使用更简单的方法：先找到所有const方法定义，然后检查每个方法
        const constMethodMatches = scriptContent.match(/const\s+(\w+)\s*=\s*(?:async\s+)?\([^)]*\)\s*=>\s*\{/g)
        if (constMethodMatches) {
          for (const methodMatch of constMethodMatches) {
            const methodNameMatch = methodMatch.match(/const\s+(\w+)\s*=/)
            if (methodNameMatch) {
              const componentMethodName = methodNameMatch[1]
              
              // 找到该方法的完整定义（从const开始到对应的}结束）
              const methodStart = scriptContent.indexOf(methodMatch)
              let braceCount = 0
              let methodEnd = methodStart
              let inMethod = false
              
              for (let i = methodStart; i < scriptContent.length; i++) {
                const char = scriptContent[i]
                if (char === '{') {
                  braceCount++
                  inMethod = true
                } else if (char === '}') {
                  braceCount--
                  if (inMethod && braceCount === 0) {
                    methodEnd = i + 1
                    break
                  }
                }
              }
              
              const methodContent = scriptContent.substring(methodStart, methodEnd)
              
              // 检查该方法是否调用了指定的API
              const apiCallPattern = new RegExp(`${serviceName}\\.${methodName}\\s*\\(`, 'g')
              if (apiCallPattern.test(methodContent)) {
                callingMethods.push(componentMethodName)
                console.log(`✅ 找到调用 ${serviceName}.${methodName} 的const方法: ${componentMethodName}`)
              }
            }
          }
        }
        
        // 查找Vue 2 Options API的方法定义：methods: { methodName() { ... } }
        const methodsObjectRegex = /methods\s*:\s*\{([\s\S]*?)\}/g
        while ((match = methodsObjectRegex.exec(scriptContent)) !== null) {
          const methodsContent = match[1]
          const methodDefRegex = /(\w+)\s*\([^)]*\)\s*\{[\s\S]*?\}/g
          let methodMatch
          
          while ((methodMatch = methodDefRegex.exec(methodsContent)) !== null) {
            const componentMethodName = methodMatch[1]
            const methodStart = methodMatch.index
            const methodEnd = methodStart + methodMatch[0].length
            const methodContent = methodsContent.substring(methodStart, methodEnd)
            
            const apiCallPattern = new RegExp(`${serviceName}\\.${methodName}\\s*\\(`, 'g')
            if (apiCallPattern.test(methodContent)) {
              callingMethods.push(componentMethodName)
              console.log(`✅ 找到调用 ${serviceName}.${methodName} 的methods方法: ${componentMethodName}`)
            }
          }
        }
        
      } catch (error) {
        console.warn(`⚠️ 查找方法调用失败: ${error.message}`)
      }
      
      return callingMethods
    },

    // 在模板中查找调用指定方法的触发器
    findTriggersInTemplateForMethods(templateContent, componentName, methodNames) {
      const triggerSources = []
      
      console.log(`🔍 在模板中查找调用方法 ${methodNames.join(', ')} 的触发器`)
      
      // 查找有name属性的button元素
      const buttonWithNameRegex = /<button[^>]*name\s*=\s*["']([^"']+)["'][^>]*@click\s*=\s*["']([^"']+)["'][^>]*>/g
      let match
      
      while ((match = buttonWithNameRegex.exec(templateContent)) !== null) {
        const buttonName = match[1]
        const clickHandler = match[2]
        
        console.log(`🔍 找到按钮: ${buttonName}, 点击处理器: ${clickHandler}`)
        
        // 检查clickHandler是否在methodNames中
        if (methodNames.includes(clickHandler)) {
          triggerSources.push({
            component: componentName,
            triggerName: buttonName,
            triggerType: 'button'
          })
          console.log(`✅ 匹配到按钮触发器: ${buttonName} -> ${clickHandler}`)
        }
      }
      
      // 查找没有name属性的button元素
      const buttonNoNameRegex = /<button[^>]*@click\s*=\s*["']([^"']+)["'][^>]*>/g
      
      while ((match = buttonNoNameRegex.exec(templateContent)) !== null) {
        const clickHandler = match[1]
        
        console.log(`🔍 找到无name按钮，点击处理器: ${clickHandler}`)
        
        // 检查clickHandler是否在methodNames中
        if (methodNames.includes(clickHandler)) {
          triggerSources.push({
            component: componentName,
            triggerName: "", // 设置为空字符串，提示用户需要补充name属性
            triggerType: 'button'
          })
          console.log(`✅ 匹配到无name按钮触发器: ${clickHandler} (需要补充name属性)`)
        }
      }
      
      // 查找表单提交
      const formSubmitRegex = /<form[^>]*@submit(?:\.prevent)?\s*=\s*["']([^"']+)["'][^>]*>/g
      
      while ((match = formSubmitRegex.exec(templateContent)) !== null) {
        const submitHandler = match[1]
        const formStart = match.index
        const formEnd = formStart + match[0].length
        
        console.log(`🔍 找到表单提交，处理器: ${submitHandler}`)
        
        // 检查submitHandler是否在methodNames中
        if (methodNames.includes(submitHandler)) {
          // 查找该表单内的提交按钮
          const formContent = this.extractFormContent(templateContent, formStart)
          const submitButtons = this.findSubmitButtonsInForm(formContent)
          
          if (submitButtons.length > 0) {
            // 如果有提交按钮，关联到具体的按钮
            submitButtons.forEach(button => {
              triggerSources.push({
                component: componentName,
                triggerName: button.name || 'form-submit',
                triggerType: 'button'
              })
              console.log(`✅ 匹配到表单提交按钮触发器: ${button.name || 'form-submit'} -> ${submitHandler}`)
            })
          } else {
            // 如果没有找到提交按钮，记录为表单提交
            triggerSources.push({
              component: componentName,
              triggerName: 'form-submit',
              triggerType: 'form'
            })
            console.log(`✅ 匹配到表单触发器: ${submitHandler}`)
          }
        }
      }
      
      return triggerSources
    },

    // 提取表单内容（从form标签开始到对应的</form>结束）
    extractFormContent(templateContent, formStart) {
      let braceCount = 0
      let formEnd = formStart
      let inForm = false
      
      for (let i = formStart; i < templateContent.length; i++) {
        const char = templateContent[i]
        if (char === '<') {
          // 检查是否是form标签的开始或结束
          const remaining = templateContent.substring(i)
          if (remaining.startsWith('<form')) {
            braceCount++
            inForm = true
          } else if (remaining.startsWith('</form>')) {
            braceCount--
            if (inForm && braceCount === 0) {
              formEnd = i + 7 // 7是'</form>'的长度
              break
            }
          }
        }
      }
      
      return templateContent.substring(formStart, formEnd)
    },

    // 在表单内容中查找提交按钮
    findSubmitButtonsInForm(formContent) {
      const submitButtons = []
      
      // 查找type="submit"的按钮
      const submitButtonRegex = /<button[^>]*type\s*=\s*["']submit["'][^>]*>/g
      let match
      
      while ((match = submitButtonRegex.exec(formContent)) !== null) {
        const buttonTag = match[0]
        
        // 提取按钮的name属性
        const nameMatch = buttonTag.match(/name\s*=\s*["']([^"']+)["']/)
        const buttonName = nameMatch ? nameMatch[1] : null
        
        submitButtons.push({
          name: buttonName,
          tag: buttonTag
        })
        
        console.log(`🔍 找到表单提交按钮: ${buttonName || 'unnamed'}`)
      }
      
      // 如果没有找到type="submit"的按钮，查找没有type属性或type="button"的按钮
      // 这些按钮可能通过@click事件触发表单提交
      if (submitButtons.length === 0) {
        const buttonRegex = /<button[^>]*>/g
        while ((match = buttonRegex.exec(formContent)) !== null) {
          const buttonTag = match[0]
          
          // 检查是否有@click事件
          if (buttonTag.includes('@click')) {
            const nameMatch = buttonTag.match(/name\s*=\s*["']([^"']+)["']/)
            const buttonName = nameMatch ? nameMatch[1] : null
            
            submitButtons.push({
              name: buttonName,
              tag: buttonTag
            })
            
            console.log(`🔍 找到可能的表单提交按钮: ${buttonName || 'unnamed'}`)
          }
        }
      }
      
      return submitButtons
    }
  }
}

module.exports = { routeMappingPlugin }