qiweimanager-master/helper/helper.go

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"os"
	"os/signal"
	"path/filepath"
	"reflect"
	"runtime"
	"strconv"
	"strings"
	"sync"
	"syscall"
	"time"
	"unsafe"

	"qiweimanager/config"
)

// 全局变量
var (
	// 全局clientId，用于socket回调处理
	globalClientId uint32
	clientIdMutex  sync.Mutex
)

func main() {
	// 首先隐藏控制台窗口
	hideConsoleWindow()

	// 确保在32位系统上运行
	if runtime.GOARCH != "386" && runtime.GOARCH != "amd64" {
		fmt.Fprintf(os.Stderr, "错误: 辅助程序必须在32位或64位系统上运行，当前系统架构: %s\n", runtime.GOARCH)
		exePath, _ := os.Executable()
		exeDir := filepath.Dir(exePath)
		errFile, _ := os.Create(filepath.Join(exeDir, "architecture_error.txt"))
		if errFile != nil {
			errFile.WriteString(fmt.Sprintf("Architecture error: %s\n", runtime.GOARCH))
			errFile.Close()
		}
		os.Exit(1)
	}

	// 初始化日志
	initLogger()
	if globalLogger == nil {
		fmt.Fprintf(os.Stderr, "[严重错误] 日志系统初始化失败，无法继续运行\n")
		exePath, _ := os.Executable()
		exeDir := filepath.Dir(exePath)
		errFile, _ := os.Create(filepath.Join(exeDir, "logger_init_failed.txt"))
		if errFile != nil {
			errFile.WriteString("Logger initialization failed\n")
			errFile.Close()
		}
		os.Exit(1)
	}

	// 记录启动日志
	globalLogger.Info("[辅助程序] 32位辅助程序已启动")

	// 初始化全局配置
	exeName := "helper"
	if err := config.InitGlobalConfig(exeName, globalLogger); err != nil {
		globalLogger.Error("[辅助程序] 初始化全局配置失败: %v", err)
	} else {
		globalLogger.Info("[辅助程序] 全局配置初始化成功")
	}

	// 尝试加载配置
	appConfig := config.GetGlobalConfig()
	if appConfig != nil {
		globalLogger.Info("[辅助程序] 成功加载全局配置，回调功能状态: %v", appConfig.CallbackConfig.EnableCallback)
	} else {
		globalLogger.Warn("[辅助程序] 未能加载全局配置，将使用默认值")
	}
	initAutoReplyEngine()
	initAfterSalesIssueEngine()
	startKingdeeMonitorFromConfig()

	// 获取程序路径
	exePath, err := os.Executable()
	if err == nil {
		exeDir := filepath.Dir(exePath)
		globalLogger.Info("[辅助程序] 程序路径: %s", exePath)
		globalLogger.Info("[辅助程序] 程序目录: %s", exeDir)

		// 定义DLL文件路径
		dllBundle := resolveDLLBundle()
		helperDLLPath := dllBundle.HelperPath
		loaderDLLPath := dllBundle.LoaderPath
		globalLogger.Info("[辅助程序] 企业微信版本: %s, 使用Helper: %s, 使用Loader: %s", dllBundle.WxWorkVersion, helperDLLPath, loaderDLLPath)
		if dllBundle.Message != "" {
			globalLogger.Warn("[辅助程序] DLL版本提示: %s", dllBundle.Message)
		}

		// 加载Helper DLL
		helperDLL, helperErr := loadDLL(helperDLLPath)
		if helperErr == nil {
			defer func() {
				if helperDLL != 0 {
					syscall.FreeLibrary(helperDLL)
					globalLogger.Info("[辅助程序] 已释放Helper DLL")
				}
			}()
		} else {
			globalLogger.Debug("[错误] 加载Helper DLL失败: %v", helperErr)
		}

		// 加载Loader DLL
		loaderDLL, loaderErr := loadDLL(loaderDLLPath)
		if loaderErr == nil {
			// 获取Loader DLL中的所有函数
			loaderFuncs, funcsErr := getLoaderFunctions(loaderDLL)

			// 保存到全局变量
			loaderFuncsMutex.Lock()
			globalLoaderFuncs = loaderFuncs
			loaderFuncsMutex.Unlock()

			if funcsErr == nil {
				// 尝试获取企业微信版本 - 增加额外的安全检查，暂时跳过此调用以避免崩溃
				globalLogger.Info("[辅助程序] 跳过获取企业微信版本，因为该操作可能导致崩溃")
				/*
					version, versionErr := getUserWxWorkVersion(loaderFuncs.GetUserWxWorkVersion)
					if versionErr == nil {
						globalLogger.Info("[辅助程序] 当前企业微信版本: %s", version)
					} else {
						globalLogger.Warn("[警告] 获取企业微信版本失败: %v", versionErr)
					}
				*/

				// 尝试使用UseUtf8函数
				globalLogger.Info("[辅助程序] 尝试设置UTF-8编码")
				ret, _, callErr := syscall.Syscall(
					loaderFuncs.UseUtf8,
					0,
					0,
					0,
					0,
				)
				if ret != 0 && callErr == 0 {
					globalLogger.Info("[辅助程序] 成功设置UTF-8编码")
				} else {
					globalLogger.Warn("[警告] 设置UTF-8编码失败: 返回值=%d, 错误=%v", ret, callErr)
				}

				// 尝试使用UseRecvJsUnicode函数
				globalLogger.Info("[辅助程序] 尝试设置接收JS Unicode编码")
				ret, _, callErr = syscall.Syscall(
					loaderFuncs.UseRecvJsUnicode,
					0,
					0,
					0,
					0,
				)
				if ret != 0 && callErr == 0 {
					globalLogger.Info("[辅助程序] 成功设置接收JS Unicode编码")
				} else {
					globalLogger.Warn("[警告] 设置接收JS Unicode编码失败: 返回值=%d, 错误=%v", ret, callErr)
				}

				// 尝试设置数据位置路径
				/*dataPath := filepath.Join(exeDir, "WXWorkData")
				globalLogger.Info("[辅助程序] 尝试设置数据位置路径: %s", dataPath)
				cDataPath := syscall.StringToUTF16Ptr(dataPath)
				ret, _, callErr = syscall.Syscall6(
					loaderFuncs.SetDataLocationPath,
					1,
					uintptr(unsafe.Pointer(cDataPath)),
					0,
					0,
					0,
					0,
					0,
				)
				if ret != 0 && callErr == 0 {
					globalLogger.Info("[辅助程序] 成功设置数据位置路径")
				} else {
					globalLogger.Warn("[警告] 设置数据位置路径失败: 返回值=%d, 错误=%v", ret, callErr)
				}*/

				// 初始化企业微信Socket连接并设置回调函数
				globalLogger.Info("[辅助程序] 尝试初始化企业微信Socket连接")
				success, initErr := InitWxWorkSocket()
				if initErr != nil {
					globalLogger.Warn("[警告] 初始化企业微信Socket连接失败: %v", initErr)
				} else if success {
					globalLogger.Info("[辅助程序] 成功初始化企业微信Socket连接")
				}

				// 创建完成通道
				/*doneChan := make(chan struct{})

				// 启动一个goroutine来定期搜索WXWork.exe进程并注入DLL
					go func() {
						ticker := time.NewTicker(5 * time.Second)
						defer ticker.Stop()

						injectedPIDs := make(map[uint32]bool) // 记录已注入的进程ID

						for {
							select {
							case <-doneChan:
								return
							case <-ticker.C:
								globalLogger.Info("[辅助程序] 搜索WXWork.exe进程")
								processIDs, processErr := findProcessByName("WXWork.exe")
								if processErr == nil {
									// 遍历所有找到的进程ID并注入DLL
									for _, pid := range processIDs {
										// 只向未注入过的进程注入DLL
										if !injectedPIDs[pid] {
											globalLogger.Info("[辅助程序] 找到未注入的WXWork进程，进程ID: %d", pid)
											if loaderFuncs != nil && loaderFuncs.InjectWxWorkPid != 0 {
												// 调用InjectWxWorkPid函数向进程注入DLL
												globalLogger.Info("[辅助程序] 尝试向进程ID %d 注入DLL", pid)
												injected, injectErr := injectIntoProcess(loaderFuncs.InjectWxWorkPid, pid, helperDLLPath)
												if injectErr != nil {
													globalLogger.Error("[错误] 向进程ID %d 注入DLL失败: %v", pid, injectErr)
												} else if injected {
													globalLogger.Info("[辅助程序] 成功向进程ID %d 注入DLL", pid)
													injectedPIDs[pid] = true
													// 注入成功后，停止搜索新的进程
													globalLogger.Info("[辅助程序] 已成功注入至少一个进程，停止搜索WXWork.exe进程")
													close(doneChan)
													return
												}
											} else {
												globalLogger.Error("[错误] 无法向进程ID %d 注入DLL，因为InjectWxWorkPid函数不可用", pid)
											}
										}
									}
								}
							}
						}
					}()*/

				// 在程序退出前调用DestroyWxWork函数释放资源
				defer func() {
					globalLogger.Info("[辅助程序] 正在调用DestroyWxWork释放资源...")
					ret, _, callErr := syscall.Syscall(
						loaderFuncs.DestroyWxWork,
						0,
						0,
						0,
						0,
					)
					if ret != 0 && callErr == 0 {
						globalLogger.Info("[辅助程序] 成功调用DestroyWxWork释放资源")
					} else {
						globalLogger.Warn("[警告] 调用DestroyWxWork失败: 返回值=%d, 错误=%v", ret, callErr)
					}
				}()
			} else {
				globalLogger.Error("[错误] 获取Loader函数失败: %v", funcsErr)
			}

			defer func() {
				if loaderDLL != 0 {
					syscall.FreeLibrary(loaderDLL)
					globalLogger.Info("[辅助程序] 已释放Loader DLL")
				}
			}()
		} else {
			globalLogger.Error("[错误] 加载Loader DLL失败: %v", loaderErr)
		}
	} else {
		globalLogger.Error("[错误] 获取程序路径失败: %v", err)
	}

	// 启动HTTP REST服务器
	go func() {
		maxRetries := 3
		retryInterval := 2 * time.Second
		var lastErr error

		for i := 0; i < maxRetries; i++ {
			globalLogger.Info("[辅助程序] 尝试启动HTTP REST服务器 (尝试 %d/%d)", i+1, maxRetries)
			err := startHTTPServer()
			if err == nil {
				globalLogger.Info("[辅助程序] HTTP REST服务器成功启动")
				// 启动成功后，定期检查服务器健康状态
				/*go func() {
					ticker := time.NewTicker(30 * time.Second)
					defer ticker.Stop()
					for {
						select {
						case <-ticker.C:
							// 执行简单的本地健康检查
							resp, err := http.Get("http://localhost:8888/api/health")
							if err != nil {
								globalLogger.Warn("[警告] HTTP服务器健康检查失败: %v", err)
							} else {
								resp.Body.Close()
								globalLogger.Debug("[辅助程序] HTTP服务器健康检查通过")
							}
						}
					}
				}()*/
				return
			}
			lastErr = err
			globalLogger.Error("[错误] HTTP REST服务器启动失败 (尝试 %d/%d): %v", i+1, maxRetries, err)

			// 如果不是最后一次尝试，等待一段时间后重试
			if i < maxRetries-1 {
				globalLogger.Info("[辅助程序] %d秒后重试...", retryInterval/time.Second)
				time.Sleep(retryInterval)
			}
		}

		// 所有重试都失败
		globalLogger.Error("[严重错误] HTTP REST服务器启动失败，已尝试所有重试: %v", lastErr)
		// 记录错误到文件以便排查
		/*exePath, _ := os.Executable()
		exeDir := filepath.Dir(exePath)
		errFile, _ := os.Create(filepath.Join(exeDir, "http_server_failed.txt"))
		if errFile != nil {
			errFile.WriteString(fmt.Sprintf("HTTP server failed: %v\n", lastErr))
			errFile.Close()
		}*/
	}()

	// 启动globalClientMap变化监测goroutine
	go monitorClientMapChanges()

	// 设置信号处理，等待中断信号
	sigChan := make(chan os.Signal, 1)
	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
	globalLogger.Info("[辅助程序] 等待退出信号...")
	<-sigChan

	globalLogger.Info("[辅助程序] 收到退出信号，开始清理资源...")
	// 清理资源
	cleanup()

	globalLogger.Info("[辅助程序] 32位辅助程序已退出")
}

// monitorClientMapChanges 监测globalClientMap变化并写入JSON文件
func monitorClientMapChanges() {
	// 获取exe路径
	exePath, err := os.Executable()
	if err != nil {
		globalLogger.Error("[监测器] 获取程序路径失败: %v", err)
		return
	}
	exeDir := filepath.Dir(exePath)
	configDir := filepath.Join(exeDir, "config")

	// 创建config目录（如果不存在）
	if err := os.MkdirAll(configDir, 0755); err != nil {
		globalLogger.Error("[监测器] 创建config目录失败: %v", err)
		return
	}

	jsonFile := filepath.Join(configDir, "client_status.json")

	globalLogger.Info("[监测器] 启动globalClientMap变化监测，状态文件: %s", jsonFile)

	// 记录上一次的状态用于比较
	lastStatus := make(map[string]int)

	// 首次启动只确保文件存在，不清空已有账号信息。
	if _, err := os.Stat(jsonFile); os.IsNotExist(err) {
		if err := os.WriteFile(jsonFile, []byte("{}"), 0644); err != nil {
			globalLogger.Error("[监测器] 初始化JSON文件失败: %v", err)
			return
		}
	}

	// 监测循环
	for {
		// 创建当前状态映射
		currentStatus := make(map[string]int)

		// 加锁读取globalClientMap
		clientIdMutex.Lock()
		for _, userID := range globalClientMap {
			if userID != "" {
				currentStatus[userID] = 1
			}
		}
		clientIdMutex.Unlock()

		// 检查状态是否发生变化
		if !mapsEqual(lastStatus, currentStatus) {
			// 找出新增的用户
			newUsers := findNewUsers(lastStatus, currentStatus)

			// 找出消失的用户
			removedUsers := findRemovedUsers(lastStatus, currentStatus)

			// 更新lastStatus记录当前状态
			lastStatus = make(map[string]int)
			for k, v := range currentStatus {
				lastStatus[k] = v
			}

			// 新增用户信息由11026/11179识别流程直接写入client_status.json。
			_ = newUsers

			// 如果有消失用户，更新其status为0
			if len(removedUsers) > 0 {
				go updateRemovedUsersStatus(removedUsers)
			}
		}

		// 每5秒检查一次变化
		time.Sleep(5 * time.Second)
	}
}

// mapsEqual 比较两个map是否相等
func mapsEqual(a, b map[string]int) bool {
	if len(a) != len(b) {
		return false
	}
	for k, v := range a {
		if b[k] != v {
			return false
		}
	}
	return true
}

// getLocalHTTPPort 获取本地HTTP服务器端口，避免与http_server.go冲突
func getLocalHTTPPort() int {
	// 获取全局配置
	appConfig := config.GetGlobalConfig()
	if appConfig != nil && appConfig.CallbackConfig.HTTPPort != "" {
		// 尝试将字符串端口转换为整数
		port, err := strconv.Atoi(appConfig.CallbackConfig.HTTPPort)
		if err == nil && port > 0 && port <= 65535 {
			return port
		}
	}
	// 使用默认值
	return 10001
}

// findNewUsers 找出新增的用户
func findNewUsers(oldStatus, newStatus map[string]int) []string {
	var newUsers []string
	for userID := range newStatus {
		if _, exists := oldStatus[userID]; !exists {
			newUsers = append(newUsers, userID)
		}
	}
	return newUsers
}

// findRemovedUsers 找出消失的用户
func findRemovedUsers(oldStatus, newStatus map[string]int) []string {
	var removedUsers []string
	for userID := range oldStatus {
		if _, exists := newStatus[userID]; !exists {
			removedUsers = append(removedUsers, userID)
		}
	}
	return removedUsers
}

// sendNewUsersToThirdParty 向第三方接口发送新增用户数据
func sendNewUsersToThirdParty(newUsers []string) {
	// 构建请求数据
	params := make(map[string]interface{})
	params["robotId"] = newUsers[0]
	params["instanceId"] = ""

	requestData := map[string]interface{}{
		"type":   "getCurrentAccountInfo",
		"params": params,
	}

	// 转换为JSON
	jsonData, err := json.Marshal(requestData)
	if err != nil {
		globalLogger.Error("[监测器] 构建第三方请求数据失败: %v", err)
		return
	}

	// 获取exe路径，构建完整URL
	exePath, err := os.Executable()
	if err != nil {
		globalLogger.Error("[监测器] 获取程序路径失败: %v", err)
		return
	}
	exeDir := filepath.Dir(exePath)

	// 构建完整的第三方接口URL
	// 使用与HTTP服务器相同的端口
	port := getLocalHTTPPort()
	thirdPartyURL := fmt.Sprintf("http://localhost:%d/api/third-party-request", port)

	// 发送POST请求
	resp, err := http.Post(thirdPartyURL, "application/json", bytes.NewBuffer(jsonData))
	if err != nil {
		globalLogger.Error("[监测器] 向第三方接口发送请求失败: %v", err)
		return
	}
	defer resp.Body.Close()

	// 读取响应
	responseBody, err := io.ReadAll(resp.Body)
	if err != nil {
		globalLogger.Error("[监测器] 读取第三方接口响应失败: %v", err)
		return
	}

	// 解析响应数据中的用户信息
	var apiResponse map[string]interface{}
	if err := json.Unmarshal(responseBody, &apiResponse); err != nil {
		globalLogger.Error("[监测器] 解析第三方接口响应失败: %v", err)
		return
	}

	// 提取用户信息数据
	var userData map[string]interface{}
	if data, ok := apiResponse["data"].(map[string]interface{}); ok {
		if userInfo, ok := data["data"].(map[string]interface{}); ok {
			userData = userInfo
		}
	}

	// 如果没有提取到用户信息，记录错误并返回
	if userData == nil {
		globalLogger.Error("[监测器] 无法从响应中提取用户信息")
		return
	}

	// 提取user_id作为key
	userID, ok := userData["user_id"].(string)
	if !ok || userID == "" {
		globalLogger.Error("[监测器] 响应中缺少user_id字段")
		return
	}

	// 添加status字段，默认值为1
	userData["status"] = 1

	// 构建client_status.json文件路径
	clientStatusFile := filepath.Join(exeDir, "config", "client_status.json")

	// 读取现有的client_status.json文件
	var clientStatus map[string]interface{}
	if data, err := os.ReadFile(clientStatusFile); err == nil {
		if err := json.Unmarshal(data, &clientStatus); err != nil {
			globalLogger.Error("[监测器] 读取client_status文件失败: %v", err)
			clientStatus = make(map[string]interface{})
		}
	} else {
		// 如果文件不存在，创建一个新的map
		clientStatus = make(map[string]interface{})
	}

	// 增量更新：添加或更新用户信息
	clientStatus[userID] = userData

	// 转换为格式化的JSON
	clientStatusJSON, err := json.MarshalIndent(clientStatus, "", "  ")
	if err != nil {
		globalLogger.Error("[监测器] 序列化client_status数据失败: %v", err)
		return
	}

	// 写入client_status.json文件（增量更新，不覆盖其他用户）
	if err := os.WriteFile(clientStatusFile, clientStatusJSON, 0644); err != nil {
		globalLogger.Error("[监测器] 写入client_status文件失败: %v", err)
		return
	}

	globalLogger.Info("[监测器] 已向第三方接口发送新增用户数据: %v, 用户信息已保存到: %s", newUsers[0], clientStatusFile)
}

// updateRemovedUsersStatus 更新消失用户的status为0
func updateRemovedUsersStatus(removedUsers []string) {
	// 获取exe路径
	exePath, err := os.Executable()
	if err != nil {
		globalLogger.Error("[监测器] 获取程序路径失败: %v", err)
		return
	}
	exeDir := filepath.Dir(exePath)
	clientStatusFile := filepath.Join(exeDir, "config", "client_status.json")
	if err := os.MkdirAll(filepath.Dir(clientStatusFile), 0755); err != nil {
		globalLogger.Error("[辅助程序] 创建client_status目录失败: %v", err)
		return
	}

	// 读取现有的client_status.json文件
	var clientStatus map[string]interface{}
	if data, err := os.ReadFile(clientStatusFile); err == nil {
		if err := json.Unmarshal(data, &clientStatus); err != nil {
			globalLogger.Error("[监测器] 读取client_status文件失败: %v", err)
			return
		}
	} else {
		// 如果文件不存在，创建一个新的map
		clientStatus = make(map[string]interface{})
	}

	// 更新消失用户的status为0
	updated := false
	for _, userID := range removedUsers {
		if userData, exists := clientStatus[userID]; exists {
			if userMap, ok := userData.(map[string]interface{}); ok {
				userMap["status"] = 0
				updated = true
				globalLogger.Info("[监测器] 用户 %s 已消失，status已更新为0", userID)
			}
		}
	}

	// 如果有更新，写入文件
	if updated {
		clientStatusJSON, err := json.MarshalIndent(clientStatus, "", "  ")
		if err != nil {
			globalLogger.Error("[监测器] 序列化client_status数据失败: %v", err)
			return
		}

		if err := os.WriteFile(clientStatusFile, clientStatusJSON, 0644); err != nil {
			globalLogger.Error("[监测器] 写入client_status文件失败: %v", err)
			return
		}

		globalLogger.Info("[监测器] 已更新消失用户的status，文件保存到: %s", clientStatusFile)
	}
}

// cleanup 清理资源
func cleanup() {
	globalLogger.Info("[辅助程序] 正在清理资源...")

	// 关闭HTTP服务器
	shutdownHTTPServer()
}

// handleSendWxWorkData 处理来自主程序的SendWxWorkData请求
func handleSendWxWorkData(params map[string]interface{}) (interface{}, error) {
	// 从参数中获取数据
	dataValue, exists := params["data"]
	if !exists {
		globalLogger.Error("[错误] 缺少data参数")
		return map[string]interface{}{"success": false, "error": "缺少data参数"}, nil
	}

	// 尝试将数据转换为字符串
	// 处理dataValue为字符串或JSON对象的情况
	var jsonData string

	// 检查是否为字符串类型
	if strValue, ok := dataValue.(string); ok {
		jsonData = strValue
	} else if objValue, ok := dataValue.(map[string]interface{}); ok {
		// 如果是JSON对象，将其转换为JSON字符串
		jsonBytes, err := json.Marshal(objValue)
		if err != nil {
			globalLogger.Error("[错误] 转换JSON对象失败: %v", err)
			return map[string]interface{}{"success": false, "error": "转换JSON对象失败"}, nil
		}
		jsonData = string(jsonBytes)
	} else {
		globalLogger.Error("[错误] data参数类型错误: %T", dataValue)
		return map[string]interface{}{"success": false, "error": "data参数类型错误，支持字符串和JSON对象"}, nil
	}

	globalLogger.Info("[辅助程序] 收到SendWxWorkData原请求，数据: %s", jsonData)
	// 处理网络资源（下载图片、视频等到本地）
	var rData map[string]interface{}
	var processedJsonData string
	if err := json.Unmarshal([]byte(jsonData), &rData); err == nil {
		if requestType, ok := rData["type"]; ok {
			if typeInt, ok := requestType.(float64); ok {
				if typeInt != 11171 {
					processedJsonData, err = processNetworkResources(jsonData)
					if err != nil {
						globalLogger.Warn("[辅助程序] 处理网络资源失败: %v，将使用原始数据", err)
						processedJsonData = jsonData
					} else {
						globalLogger.Info("[辅助程序] 网络资源处理完成")
					}

					// 记录请求日志
					globalLogger.Info("[辅助程序] 收到SendWxWorkData网络转本地请求，数据: %s", processedJsonData)
				} else {
					// 处理type=11171的数据
					processedJsonData, err = processType11171Data(jsonData)
					if err != nil {
						globalLogger.Warn("[辅助程序] 处理type=11171数据失败: %v，将使用原始数据", err)
						processedJsonData = jsonData
					} else {
						globalLogger.Info("[辅助程序] type=11171数据处理完成")
					}

					// 记录请求日志
					globalLogger.Info("[辅助程序] 收到SendWxWorkData type=11171请求，处理后数据: %s", processedJsonData)
				}
			}
		}
	}

	// 尝试通过Loader DLL发送数据到企业微信
	loaderFuncsMutex.Lock()
	loaderFuncs := globalLoaderFuncs
	loaderFuncsMutex.Unlock()

	// 获取clientId - 优先使用传入的clientId
	var clientId uint32
	// 检查params中是否有clientId参数
	if clientIdValue, ok := params["clientId"]; ok {
		globalLogger.Debug("[调试] 传入的clientId原始值: %v (类型: %T)", clientIdValue, clientIdValue)

		switch v := clientIdValue.(type) {
		case uint32:
			if v <= 0 {
				clientId = GetGlobalClientId()
				globalLogger.Warn("[辅助程序] 传入的clientId值无效: %d，使用全局clientId: %d", v, clientId)
			} else {
				clientId = v
				globalLogger.Info("[辅助程序] 使用传入的uint32 clientId: %d", clientId)
			}
		case int, int32, int64:
			intVal := reflect.ValueOf(v).Int()
			if intVal <= 0 || intVal < 0 || intVal > 2147483647 {
				clientId = GetGlobalClientId()
				globalLogger.Warn("[辅助程序] 传入的clientId值无效: %d，使用全局clientId: %d", intVal, clientId)
			} else {
				clientId = uint32(intVal)
				globalLogger.Info("[辅助程序] 使用传入的int clientId: %d", clientId)
			}
		case float32, float64:
			floatVal := reflect.ValueOf(v).Float()
			if floatVal <= 0 || floatVal < 0 || floatVal > 2147483647 {
				clientId = GetGlobalClientId()
				globalLogger.Warn("[辅助程序] 传入的clientId值无效: %.0f，使用全局clientId: %d", floatVal, clientId)
			} else {
				clientId = uint32(floatVal)
				globalLogger.Info("[辅助程序] 使用传入的float clientId: %d", clientId)
			}
		case string:
			if clientIdInt, err := strconv.Atoi(strings.TrimSpace(v)); err == nil {
				if clientIdInt <= 0 || clientIdInt > 2147483647 {
					clientId = GetGlobalClientId()
					globalLogger.Warn("[辅助程序] 传入的clientId值无效: %d，使用全局clientId: %d", clientIdInt, clientId)
				} else {
					clientId = uint32(clientIdInt)
					globalLogger.Info("[辅助程序] 使用传入的string clientId: %d", clientId)
				}
			} else {
				clientId = GetGlobalClientId()
				globalLogger.Warn("[辅助程序] 传入的clientId格式无效，使用全局clientId: %d", clientId)
			}
		default:
			clientId = GetGlobalClientId()
			globalLogger.Warn("[辅助程序] 传入的clientId类型无效(类型: %T)，使用全局clientId: %d", clientIdValue, clientId)
		}
	} else {
		// 没有传入clientId，使用全局clientId
		clientId = GetGlobalClientId()
		globalLogger.Info("[辅助程序] 使用全局clientId: %d", clientId)
	}

	// 检查是否是启动企微请求(type=11153)或需要回调的请求
	// 解析processedJsonData获取type字段
	var requestData map[string]interface{}
	//needCallback := true
	if err := json.Unmarshal([]byte(processedJsonData), &requestData); err == nil {
		if requestType, ok := requestData["type"]; ok {
			if typeInt, ok := requestType.(float64); ok {
				if typeInt == 10000 {
					// 这是点击启动企微按钮的请求，需要执行InjectWxWork而不是SendWxWorkData
					globalLogger.Info("[辅助程序] 检测到启动企微请求(type=10000)")
					if shouldStart, statusPayload := tryBeginWxWorkInjection(); !shouldStart {
						globalLogger.Info("[辅助程序] 跳过重复启动企微: %v", statusPayload["message"])
						return statusPayload, nil
					}

					// 获取程序路径
					exePath, err := os.Executable()
					if err != nil {
						globalLogger.Error("[错误] 获取程序路径失败: %v", err)
						setInjectionStatus(injectionStatusFailed, 0, "获取程序路径失败")
						return map[string]interface{}{"success": false, "error": "获取程序路径失败"}, nil
					}
					exeDir := filepath.Dir(exePath)
					_ = exeDir
					dllBundle := resolveDLLBundle()
					helperDLLPath := dllBundle.HelperPath
					if helperDLLPath == "" || dllBundle.LoaderPath == "" {
						setInjectionStatus(injectionStatusFailed, 0, dllBundle.Message)
						return map[string]interface{}{"success": false, "error": dllBundle.Message}, nil
					}
					if !dllBundle.Compatible {
						setInjectionStatus(injectionStatusFailed, 0, dllBundle.Message)
						return map[string]interface{}{"success": false, "error": dllBundle.Message}, nil
					}
					if dllBundle.Message != "" {
						globalLogger.Warn("[辅助程序] DLL版本提示: %s", dllBundle.Message)
					}

					// 执行InjectWxWork函数
					globalLogger.Info("[辅助程序] 执行InjectWxWork函数，DLL路径: %s", helperDLLPath)
					ret := InjectWxWork(helperDLLPath, "")

					if ret != 0 {
						globalLogger.Info("[辅助程序] InjectWxWork执行成功，返回进程ID: %d", ret)
						setInjectionStatus(injectionStatusConnected, ret, "")
						markPIDInjected(ret)
						go watchWxWorkConnectionTimeout(ret)
						go injectAllWxWorkProcesses(helperDLLPath, ret)
						payload := wxWorkStartStatusPayload("启动企微请求已发送，正在识别账号", true, false)
						payload["processId"] = ret
						return payload, nil
					} else {
						globalLogger.Error("[错误] 调用InjectWxWork失败")
						setInjectionStatus(injectionStatusFailed, 0, "调用InjectWxWork失败")
						return map[string]interface{}{"success": false, "error": "调用InjectWxWork失败"}, nil
					}
					/*} else if typeInt == 10001 {
					// 这是需要回调的请求类型
					needCallback = true
					globalLogger.Info("[辅助程序] 检测到配置回调的参数请求(type=10001)")
					return map[string]interface{}{"success": true}, nil*/
				} else if typeInt == 10002 {
					// 这是获取活跃客户端数量的请求
					globalLogger.Info("[辅助程序] 检测到获取活跃客户端数量请求(type=10002)")

					// 获取当前活跃的客户端数量
					activeCount := recognizedClientCount()
					globalLogger.Info("[辅助程序] 当前活跃客户端数量: %d", activeCount)

					// 构建响应数据
					response := map[string]interface{}{
						"success": true,
						"type":    10002,
						"data": map[string]interface{}{
							"count":                   activeCount,
							"recognizedClientCount":   activeCount,
							"unidentifiedClientCount": unidentifiedClientCount(),
							"connectionCount":         connectedClientCount(),
						},
					}

					return response, nil
				} else {
					globalLogger.Info("[辅助程序] 检测其他请求(type=%.0f)", typeInt)
				}
			}
		}
	}

	// 如果全局clientId为0，且不是需要回调的请求，尝试从进程中获取
	/*if clientId == 0 && !needCallback {
		// 查找WXWork.exe进程并获取其进程ID
		processIDs, err := findProcessByName("WXWork.exe")
		if err == nil && len(processIDs) > 0 {
			clientId = processIDs[0]
			globalLogger.Info("[辅助程序] 找到进程: WXWork.exe, 进程ID: %d，已设置为clientId", clientId)
		} else {
			globalLogger.Warn("[辅助程序] 未找到WXWork.exe进程，使用默认clientId: %d", clientId)
		}
	} else if clientId == 0 && needCallback {
		// 对于需要回调的请求，如果clientId为0，使用默认值1
		clientId = 1
		globalLogger.Info("[辅助程序] 对于需要回调的请求，使用默认clientId: %d", clientId)
	}*/
	// 检查Loader DLL函数是否可用
	if loaderFuncs != nil && loaderFuncs.SendWxWorkData != 0 {
		// 转换JSON数据为ANSI字符串
		cJsonData, err := syscall.BytePtrFromString(processedJsonData)
		if err != nil {
			globalLogger.Error("[错误] 转换JSON数据失败: %v", err)
			return map[string]interface{}{"success": false, "error": "转换JSON数据失败"}, nil
		}

		// 调用SendWxWorkData函数
		// 记录详细的参数信息到日志
		globalLogger.Info("[辅助程序] 调用SendWxWorkData函数参数详情：")
		globalLogger.Info("[辅助程序] - 函数地址: 0x%x", loaderFuncs.SendWxWorkData)
		globalLogger.Info("[辅助程序] - 参数数量: %d", 2)
		globalLogger.Info("[辅助程序] - 客户端ID(clientId): %d", clientId)
		globalLogger.Info("[辅助程序] - JSON数据指针(cJsonData): 0x%x", uintptr(unsafe.Pointer(cJsonData)))
		globalLogger.Info("[辅助程序] - 保留参数: %d", 0)

		ret, _, callErr := syscall.Syscall(
			loaderFuncs.SendWxWorkData,
			2,
			uintptr(clientId),
			uintptr(unsafe.Pointer(cJsonData)),
			0,
		)

		if ret != 0 && callErr == 0 {
			globalLogger.Info("[辅助程序] SendWxWorkData调用成功")
			return map[string]interface{}{"success": true}, nil
		} else {
			globalLogger.Error("[错误] 调用SendWxWorkData失败: 返回值=%d, 错误=%v", ret, callErr)
			return map[string]interface{}{"success": false, "error": "调用SendWxWorkData失败"}, nil
		}
	} else {
		globalLogger.Error("[错误] SendWxWorkData函数不可用")
		return map[string]interface{}{"success": false, "error": "SendWxWorkData函数不可用"}, nil
	}
}

// 注意：在handleSendWxWorkData函数中，对于type=11153的请求（点击启动企微按钮），
// 执行InjectWxWork函数而不是SendWxWorkData函数，并且在InjectWxWork执行成功后执行InitWxWorkSocket函数

// hideConsoleWindow 隐藏控制台窗口（仅Windows平台有效）
func hideConsoleWindow() {
	if runtime.GOOS == "windows" {
		// 定义Windows API常量和函数
		const (
			SW_HIDE = 0x00
		)

		// 获取kernel32.dll
		kernel32 := syscall.NewLazyDLL("kernel32.dll")
		// 获取GetConsoleWindow函数
		getConsoleWindow := kernel32.NewProc("GetConsoleWindow")
		// 获取ShowWindow函数
		showWindow := kernel32.NewProc("ShowWindow")

		// 调用GetConsoleWindow获取控制台窗口句柄
		hwnd, _, _ := getConsoleWindow.Call()
		if hwnd != 0 {
			// 调用ShowWindow隐藏窗口
			showWindow.Call(hwnd, uintptr(SW_HIDE))
		}
	}
}

// SetGlobalClientId 设置全局clientId
func SetGlobalClientId(clientId uint32) {
	clientIdMutex.Lock()
	globalClientId = clientId
	clientIdMutex.Unlock()
	globalLogger.Info("[辅助程序] 已设置全局clientId: %d", clientId)
}

// GetGlobalClientId 获取全局clientId
func GetGlobalClientId() uint32 {
	clientIdMutex.Lock()
	defer clientIdMutex.Unlock()
	return globalClientId
}

// MyConnectCallback 连接回调函数，在有新客户端加入时调用
// 函数原型: void __stdcall MyConnectCallback(int iClientId)
// 注意：为了兼容syscall.NewCallback，需要返回一个uintptr类型的值
//
//export MyConnectCallback
func MyConnectCallback(iClientId int32) uintptr {
	globalLogger.Info("[辅助程序] 收到新客户端连接，clientId: %d", iClientId)
	// 将clientId设置为全局clientId
	SetGlobalClientId(uint32(iClientId))
	registerClientConnected(uint32(iClientId))
	return 0
}

// MyRecvCallback 接收回调函数，在接收到新消息时调用
// 函数原型: void __stdcall MyRecvCallback(int iClientId, char* szJsonData, int iLen)
// 注意：为了兼容syscall.NewCallback，需要返回一个uintptr类型的值
//
//export MyRecvCallback
func MyRecvCallback(iClientId int32, szJsonData *int8, iLen int32) uintptr {
	// 转换数据指针为Go字符串
	jsonData := make([]byte, iLen)
	for i := 0; i < int(iLen); i++ {
		jsonData[i] = byte(*(*int8)(unsafe.Pointer(uintptr(unsafe.Pointer(szJsonData)) + uintptr(i))))
	}
	jsonStr := string(jsonData)
	globalLogger.Info("[辅助程序] 从客户端 %d 接收数据: %s", iClientId, jsonStr)

	// 尝试解析数据为JSON
	var responseData map[string]interface{}
	// 移除末尾的空字符
	cleanJsonStr := strings.TrimRight(jsonStr, "\x00")
	if err := json.Unmarshal([]byte(cleanJsonStr), &responseData); err != nil {
		// 如果解析失败，仍然创建一个包含原始字符串的数据结构
		responseData = map[string]interface{}{
			"rawData": cleanJsonStr,
		}
	}
	recordDashboardMessage(iClientId, "incoming", cleanJsonStr, nil, "recv-callback")
	recordClientProbeEvent(iClientId, responseData, cleanJsonStr)
	if autoReplyEngine != nil {
		autoReplyEngine.observeGroupNames(iClientId, responseData)
		autoReplyEngine.observeIdentityContacts(iClientId, responseData)
	}

	if typeVal, ok := responseData["type"]; ok && (typeVal == float64(11024)) {
		if data, ok := responseData["data"].(map[string]interface{}); ok {
			pid := uint32(intFromAny(data["pid"]))
			registerClientPID(uint32(iClientId), pid)
			startClientIdentification(uint32(iClientId))
		}
		return 0
	}

	if typeVal, ok := responseData["type"]; ok && typeVal == float64(11041) {
		markClientMessageReady(uint32(iClientId), responseData)
	}

	if data, ok := responseData["data"].(map[string]interface{}); ok {
		if createTime, ok := data["create_time"].(float64); ok {
			// 将时间戳转换为时间
			timeValue := time.Unix(int64(createTime), 0)
			// 获取今天和昨天的时间
			today := time.Now().Truncate(24 * time.Hour)
			yesterday := today.Add(-24 * time.Hour)
			// 截断时间到天
			timeValueDay := timeValue.Truncate(24 * time.Hour)
			// 判断是否是今天或昨天
			if timeValueDay != today && timeValueDay != yesterday {
				// 不是今天或昨天，结束处理
				return 0
			}
		}
		// 处理send_time字段，支持字符串和数字类型
		if sendTimeVal, ok := data["send_time"]; ok {
			var sendTime int64
			var err error

			// 根据类型进行处理
			switch v := sendTimeVal.(type) {
			case string:
				// 如果是字符串类型，尝试转换为int64
				sendTime, err = strconv.ParseInt(v, 10, 64)
			case float64:
				// 如果是float64类型，直接转换为int64
				sendTime = int64(v)
			}

			// 如果转换成功，执行日期判断
			if err == nil {
				// 将时间戳转换为时间
				timeValue := time.Unix(sendTime, 0)
				// 获取今天和昨天的时间
				today := time.Now().Truncate(24 * time.Hour)
				yesterday := today.Add(-24 * time.Hour)
				// 截断时间到天
				timeValueDay := timeValue.Truncate(24 * time.Hour)
				// 判断是否是今天或昨天
				if timeValueDay != today && timeValueDay != yesterday {
					// 不是今天或昨天，结束处理
					return 0
				}
			}
		}
	}

	observeAfterSalesEvent(iClientId, responseData)

	// 检查type是否为11026，如果是则提取user_id并更新client映射
	if typeVal, ok := responseData["type"]; ok && (typeVal == float64(11026) || typeVal == float64(11179)) {
		if userID, accountData := extractAccountIdentity(responseData); userID != "" {
			markClientIdentified(uint32(iClientId), userID, accountData)
			globalLogger.Info("[辅助程序] account event identified clientId=%d -> user_id=%s", iClientId, userID)
		}
	}

	if typeVal, ok := responseData["type"]; ok && (typeVal == float64(11026)) {
		if data, ok := responseData["data"].(map[string]interface{}); ok {
			if userID, ok := data["user_id"].(string); ok {
				// 更新客户端映射
				markClientIdentified(uint32(iClientId), userID, data)
				globalLogger.Info("[辅助程序] 11026更新客户端映射: clientId=%d -> user_id=%s", iClientId, userID)
			}
		}
	}

	// 检查type是否为11179，如果是则提取user_id并更新client映射
	if typeVal, ok := responseData["type"]; ok && (typeVal == float64(11179)) {
		if data, ok := responseData["data"].(map[string]interface{}); ok {
			if userID, ok := data["user_id"].(string); ok {
				// 更新客户端映射
				markClientIdentified(uint32(iClientId), userID, data)
				globalLogger.Info("[辅助程序] 11179更新客户端映射: clientId=%d -> user_id=%s", iClientId, userID)
			}
		}
	}

	// 检查是否有对应的响应通道
	// 记录当前ResponseMap中的所有clientId，用于调试
	responseMapMu.Lock()
	globalLogger.Info("[辅助程序] 当前ResponseMap中的clientId列表: %v", reflect.ValueOf(ResponseMap).MapKeys())
	responseMapMu.Unlock()

	if ch, exists := GetResponseChannel(iClientId); exists {

		// 使用TransformData函数转换数据
		jsonBytes, err := TransformData(responseData, uint32(iClientId))
		if err != nil {
			globalLogger.Error("[错误] 转换数据失败: %v", err)
			return 0
		}

		// 将jsonBytes转换为responseData格式
		var transformedData map[string]interface{}
		if err := json.Unmarshal(jsonBytes, &transformedData); err != nil {
			globalLogger.Error("[错误] 解析转换后的数据失败: %v", err)
			// 如果解析失败，仍然使用原始responseData
			transformedData = responseData
		}
		if autoReplyEngine != nil {
			autoReplyEngine.observeIdentityContacts(iClientId, transformedData)
		}

		// 发送数据到响应通道
		select {
		case ch <- ClientResponseData{
			ClientId: iClientId,
			Data:     transformedData,
		}:
			globalLogger.Info("[辅助程序] 已将数据发送到响应通道, clientId: %d", iClientId)
		default:
			globalLogger.Warn("[辅助程序] 响应通道已满，无法发送数据, clientId: %d", iClientId)
		}
	} else {
		globalLogger.Debug("[错误] 未找到对应的响应通道, clientId: %d", iClientId)
		autoReplyData := responseData
		if jsonBytes, err := TransformData(responseData, uint32(iClientId)); err == nil {
			var transformedData map[string]interface{}
			if err := json.Unmarshal(jsonBytes, &transformedData); err == nil {
				autoReplyData = transformedData
			} else {
				globalLogger.Error("[错误] 解析自动客服转换数据失败: %v", err)
			}
		} else {
			globalLogger.Error("[错误] 自动客服转换数据失败: %v", err)
		}
		enqueueAutoReplyEvent(iClientId, autoReplyData)
		// 尝试列出所有可用的响应通道，帮助调试
		responseMapMu.Lock()
		for id := range ResponseMap {
			globalLogger.Error("[错误] 可用的响应通道clientId: %d", id)
		}
		responseMapMu.Unlock()

		// 如果没有对应的响应通道，并且启用了回调功能，则将数据发送到配置的回调接口
		appConfig := config.GetGlobalConfig()
		if appConfig != nil && appConfig.CallbackConfig.EnableCallback && appConfig.CallbackConfig.CallbackURL != "" {
			globalLogger.Info("[辅助程序] 没有找到对应的响应通道，将数据发送到配置的回调接口: %s", appConfig.CallbackConfig.CallbackURL)

			// 使用TransformData函数转换数据
			jsonBytes, err := TransformData(responseData, uint32(iClientId))
			if err != nil {
				globalLogger.Error("[错误] 转换数据失败: %v", err)
			} else {
				// 发送HTTP POST请求到回调URL
				resp, err := http.Post(appConfig.CallbackConfig.CallbackURL, "application/json", bytes.NewBuffer(jsonBytes))
				if err != nil {
					globalLogger.Error("[错误] 发送数据到回调接口失败: %v", err)
				} else {
					defer resp.Body.Close()
					globalLogger.Info("[辅助程序] 数据已成功发送到回调接口，响应状态码: %d", resp.StatusCode)
				}
			}
		} else if appConfig != nil {
			globalLogger.Info("[辅助程序] 回调功能未启用或回调URL为空，不发送数据")
		} else {
			globalLogger.Info("[辅助程序] 全局配置不存在，不发送数据到回调接口")
		}
	}
	return 0
}

// MyCloseCallback 关闭回调函数，在客户端退出时调用
// 函数原型: void __stdcall MyCloseCallback(int iClientId)
// 注意：为了兼容syscall.NewCallback，需要返回一个uintptr类型的值
//
//export MyCloseCallback
func MyCloseCallback(iClientId int32) uintptr {
	globalLogger.Info("[辅助程序] 客户端 %d 已断开连接", iClientId)

	// 检查该客户端是否还存在响应通道
	if ch, exists := GetResponseChannel(iClientId); exists {
		// 发送客户端退出的信息到响应通道
		select {
		case ch <- ClientResponseData{
			ClientId: iClientId,
			Data: map[string]interface{}{
				"type":      99999,
				"message":   "客户端已退出",
				"client_id": iClientId,
				"status":    "disconnected",
				"timestamp": time.Now().Unix(),
			},
		}:
			globalLogger.Info("[辅助程序] 已向响应通道发送客户端退出信息, clientId: %d", iClientId)
		default:
			globalLogger.Warn("[辅助程序] 响应通道已满，无法发送客户端退出信息, clientId: %d", iClientId)
		}

		// 移除响应通道
		RemoveResponseChannel(iClientId)
		globalLogger.Info("[辅助程序] 已移除响应通道, clientId: %d", iClientId)
	} else {
		globalLogger.Debug("[辅助程序] 客户端 %d 不存在响应通道，无需发送退出信息", iClientId)
	}

	// 如果断开连接的是当前全局clientId，重置全局clientId
	removeClientState(uint32(iClientId))
	return 0
}

// InitWxWorkSocket 初始化企业微信Socket连接并设置回调函数
// 函数原型: BOOL __stdcall InitWxWorkSocket(IN DWORD dwConnectCallback, IN DWORD dwRecvCallback, IN DWORD dwCloseCallback)
func InitWxWorkSocket() (bool, error) {
	// 添加异常捕获机制
	doneChan := make(chan struct {
		success bool
		err     error
	}, 1)

	go func() {
		defer func() {
			if r := recover(); r != nil {
				// 捕获到panic，记录错误信息
				errorMsg := fmt.Sprintf("初始化企业微信Socket连接时发生panic: %v", r)
				globalLogger.Error("[严重错误] %s", errorMsg)

				// 记录到错误文件
				exePath, _ := os.Executable()
				exeDir := filepath.Dir(exePath)
				errFile, _ := os.Create(filepath.Join(exeDir, "socket_init_crash.txt"))
				if errFile != nil {
					timestamp := time.Now().Format("2006-01-02 15:04:05.000")
					fmt.Fprintf(errFile, "[%s] %s\n", timestamp, errorMsg)
					errFile.Close()
				}
				doneChan <- struct {
					success bool
					err     error
				}{false, fmt.Errorf("%s", errorMsg)}
			}
		}()

		loaderFuncsMutex.Lock()
		loaderFuncs := globalLoaderFuncs
		loaderFuncsMutex.Unlock()

		if loaderFuncs == nil || loaderFuncs.InitWxWorkSocket == 0 {
			globalLogger.Error("[错误] InitWxWorkSocket函数不可用")
			doneChan <- struct {
				success bool
				err     error
			}{false, fmt.Errorf("InitWxWorkSocket函数不可用")}
			return
		}

		// 获取回调函数地址
		connectCallback := syscall.NewCallback(MyConnectCallback)
		recvCallback := syscall.NewCallback(MyRecvCallback)
		closeCallback := syscall.NewCallback(MyCloseCallback)

		globalLogger.Info("[辅助程序] 调用InitWxWorkSocket函数")
		globalLogger.Info("[辅助程序] - 函数地址: 0x%x", loaderFuncs.InitWxWorkSocket)
		globalLogger.Info("[辅助程序] - 连接回调地址: 0x%x", connectCallback)
		globalLogger.Info("[辅助程序] - 接收回调地址: 0x%x", recvCallback)
		globalLogger.Info("[辅助程序] - 关闭回调地址: 0x%x", closeCallback)

		// 设置超时
		timeout := time.After(5 * time.Second)
		resultChan := make(chan struct {
			success bool
			err     error
		}, 1)

		go func() {
			// 调用InitWxWorkSocket函数
			ret, _, callErr := syscall.Syscall(
				loaderFuncs.InitWxWorkSocket,
				3,
				connectCallback,
				recvCallback,
				closeCallback,
			)

			if ret != 0 {
				globalLogger.Info("[辅助程序] InitWxWorkSocket调用成功")
				if callErr != 0 {
					globalLogger.Warn("[辅助程序] InitWxWorkSocket返回成功，但LastError非空，可忽略: %v", callErr)
				}
				resultChan <- struct {
					success bool
					err     error
				}{true, nil}
			} else {
				globalLogger.Error("[错误] 调用InitWxWorkSocket失败: 返回值=%d, 错误=%v", ret, callErr)
				resultChan <- struct {
					success bool
					err     error
				}{false, fmt.Errorf("调用InitWxWorkSocket失败: 返回值=%d, 错误=%v", ret, callErr)}
			}
		}()

		// 等待结果或超时
		select {
		case result := <-resultChan:
			doneChan <- result
		case <-timeout:
			globalLogger.Error("[严重错误] 调用InitWxWorkSocket超时")
			doneChan <- struct {
				success bool
				err     error
			}{false, fmt.Errorf("调用InitWxWorkSocket超时")}
		}
	}()

	// 等待goroutine执行完成
	result := <-doneChan
	return result.success, result.err
}

// updateClientStatusWithResponseData 根据响应数据补充client_status.json中缺少的字段
func updateClientStatusWithResponseData(userID string, responseData map[string]interface{}) {
	// 获取程序路径
	exePath, err := os.Executable()
	if err != nil {
		globalLogger.Error("[辅助程序] 获取程序路径失败: %v", err)
		return
	}
	exeDir := filepath.Dir(exePath)
	clientStatusFile := filepath.Join(exeDir, "config", "client_status.json")

	// 读取现有的client_status.json文件
	var clientStatus map[string]interface{}
	if data, err := os.ReadFile(clientStatusFile); err == nil {
		if err := json.Unmarshal(data, &clientStatus); err != nil {
			globalLogger.Error("[辅助程序] 读取client_status文件失败: %v", err)
			return
		}
	} else {
		// 如果文件不存在，创建一个新的map
		clientStatus = make(map[string]interface{})
	}

	// 检查用户数据是否存在
	userData, exists := clientStatus[userID]
	if !exists {
		// 如果用户不存在，创建新的用户数据
		userData = make(map[string]interface{})
		clientStatus[userID] = userData
	}

	// 将userData转换为map[string]interface{}类型
	userMap, ok := userData.(map[string]interface{})
	if !ok {
		if globalLogger != nil {
			globalLogger.Error("[辅助程序] client_status.json中用户数据格式错误")
		}
		return
	}

	// 定义需要补充的字段
	fieldsToUpdate := []string{
		"account", "acctid", "avatar", "corp_id", "corp_name",
		"corp_short_name", "email", "job_name", "mobile", "nickname",
		"position", "sex", "username",
	}

	// 补充缺少的字段
	updated := false
	for _, field := range fieldsToUpdate {
		if _, exists := userMap[field]; !exists {
			if value, ok := responseData[field]; ok {
				userMap[field] = value
				updated = true
				if globalLogger != nil {
					globalLogger.Info("[辅助程序] 补充用户 %s 的字段 %s: %v", userID, field, value)
				}
			}
		}
	}

	// 确保status字段存在且为1
	if _, exists := userMap["status"]; !exists || userMap["status"] != 1 {
		userMap["status"] = 1
		updated = true
		if globalLogger != nil {
			globalLogger.Info("[辅助程序] 补充用户 %s 的status字段: 1", userID)
		}
	}

	// 确保user_id字段存在
	if _, exists := userMap["user_id"]; !exists {
		userMap["user_id"] = userID
		updated = true
		if globalLogger != nil {
			globalLogger.Info("[辅助程序] 补充用户 %s 的user_id字段", userID)
		}
	}

	// 如果有更新，写入文件
	if updated {
		clientStatusJSON, err := json.MarshalIndent(clientStatus, "", "  ")
		if err != nil {
			if globalLogger != nil {
				globalLogger.Error("[辅助程序] 序列化client_status数据失败: %v", err)
			}
			return
		}

		if err := os.WriteFile(clientStatusFile, clientStatusJSON, 0644); err != nil {
			if globalLogger != nil {
				globalLogger.Error("[辅助程序] 写入client_status文件失败: %v", err)
			}
			return
		}

		if globalLogger != nil {
			globalLogger.Info("[辅助程序] 已更新client_status.json文件，补充了用户 %s 的字段", userID)
		}
	}
}

// processType11171Data 处理type=11171的数据，将URL中的斜杠转换为转义斜杠
func processType11171Data(jsonData string) (string, error) {
	var rData map[string]interface{}
	if err := json.Unmarshal([]byte(jsonData), &rData); err != nil {
		return jsonData, fmt.Errorf("解析JSON数据失败: %v", err)
	}

	// 检查是否有data字段
	if dataField, ok := rData["data"]; ok {
		if dataMap, ok := dataField.(map[string]interface{}); ok {
			// 检查是否有url字段
			if urlValue, ok := dataMap["url"]; ok {
				if urlStr, ok := urlValue.(string); ok {
					// 将URL中的斜杠转换为JSON兼容的转义斜杠
					processedURL := strings.ReplaceAll(urlStr, "/", "\\/")
					dataMap["url"] = processedURL
					//globalLogger.Info("[辅助程序] 处理type=11171的URL: %s -> %s", urlStr, processedURL)
				}
			}
		}
	}

	// 将处理后的数据转换回JSON字符串
	/* processedJSON, err := json.Marshal(rData)
	if err != nil {
		return jsonData, fmt.Errorf("转换处理后的数据失败: %v", err)
	} */

	var buf bytes.Buffer
	encoder := json.NewEncoder(&buf)
	encoder.SetEscapeHTML(false)
	err := encoder.Encode(rData)
	if err != nil {
		return jsonData, fmt.Errorf("转换处理后的数据失败: %v", err)
	}
	processedJSON := buf.Bytes()
	result := strings.ReplaceAll(string(processedJSON), "\\\\/", "\\/")

	return string(result), nil
}

// processNetworkResources 处理JSON数据中的网络资源（图片、视频、表情等）
// 下载网络资源到exe同级目录的temp文件夹，并替换为本地路径
func processNetworkResources(jsonData string) (string, error) {
	// 获取程序路径
	exePath, err := os.Executable()
	if err != nil {
		return jsonData, fmt.Errorf("获取程序路径失败: %v", err)
	}
	exeDir := filepath.Dir(exePath)
	parentDir := filepath.Dir(exeDir)
	tempDir := filepath.Join(parentDir, "temp")

	// 创建temp目录（如果不存在）
	if err := os.MkdirAll(tempDir, 0755); err != nil {
		return jsonData, fmt.Errorf("创建temp目录失败: %v", err)
	}

	// 清理temp目录中的旧文件（保留最近7天的文件）
	cleanOldFiles(tempDir, 3*24*time.Hour)

	// 解析JSON数据
	var data interface{}
	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
		return jsonData, fmt.Errorf("解析JSON数据失败: %v", err)
	}

	// 递归处理数据结构中的网络资源
	processedData := processDataRecursive(data, tempDir)

	// 将处理后的数据转换回JSON字符串
	processedJSON, err := json.Marshal(processedData)
	if err != nil {
		return jsonData, fmt.Errorf("转换处理后的数据失败: %v", err)
	}

	return string(processedJSON), nil
}

// processDataRecursive 递归处理数据结构中的网络资源
func processDataRecursive(data interface{}, tempDir string) interface{} {
	switch v := data.(type) {
	case map[string]interface{}:
		// 处理map类型
		result := make(map[string]interface{})
		for key, value := range v {
			// 检查是否为网络资源字段
			if isNetworkResourceField(key, value) {
				if strValue, ok := value.(string); ok {
					if isNetworkURL(strValue) {
						// 下载网络资源并获取本地路径
						localPath, err := downloadNetworkResource(strValue, tempDir)
						if err == nil {
							// 将本地路径赋值给相应的file字段
							fileKey := key
							result[fileKey] = localPath
							globalLogger.Info("[网络资源处理] 已下载网络资源: %s -> %s", strValue, localPath)
						} else {
							globalLogger.Warn("[网络资源处理] 下载网络资源失败: %s, 错误: %v", strValue, err)
							result[key] = value
						}
					} else {
						result[key] = value
					}
				} else {
					result[key] = processDataRecursive(value, tempDir)
				}
			} else {
				result[key] = processDataRecursive(value, tempDir)
			}
		}
		return result
	case []interface{}:
		// 处理数组类型
		result := make([]interface{}, len(v))
		for i, item := range v {
			result[i] = processDataRecursive(item, tempDir)
		}
		return result
	default:
		// 其他类型直接返回
		return data
	}
}

// isNetworkResourceField 判断是否为网络资源字段
func isNetworkResourceField(key string, value interface{}) bool {
	// 常见的网络资源字段名
	resourceFields := []string{"image", "img", "picture", "pic", "photo", "video", "media", "file", "url", "link", "src", "source", "path", "content"}

	keyLower := strings.ToLower(key)
	for _, field := range resourceFields {
		if strings.Contains(keyLower, field) {
			return true
		}
	}
	return false
}

// isNetworkURL 判断字符串是否为网络URL
func isNetworkURL(str string) bool {
	// 检查是否为HTTP/HTTPS URL
	return strings.HasPrefix(strings.ToLower(str), "http://") || strings.HasPrefix(strings.ToLower(str), "https://")
}

// downloadNetworkResource 下载网络资源到本地
func downloadNetworkResource(url, tempDir string) (string, error) {
	// 创建HTTP客户端
	client := &http.Client{
		Timeout: 30 * time.Second,
	}

	// 发送GET请求
	resp, err := client.Get(url)
	if err != nil {
		return "", fmt.Errorf("请求网络资源失败: %v", err)
	}
	defer resp.Body.Close()

	// 检查响应状态
	if resp.StatusCode != http.StatusOK {
		return "", fmt.Errorf("下载失败，状态码: %d", resp.StatusCode)
	}

	// 从URL中提取文件名
	fileName := extractFileNameFromURL(url)
	if fileName == "" {
		// 如果无法从URL提取文件名，使用当前时间戳
		fileName = fmt.Sprintf("resource_%d", time.Now().Unix())
	}

	// 生成本地文件路径
	localPath := filepath.Join(tempDir, fileName)

	// 使用安全文件创建方法处理文件占用问题
	file, actualPath, err := SafeCreateFile(localPath)
	if err != nil {
		return "", fmt.Errorf("创建本地文件失败: %v", err)
	}
	defer file.Close()

	// 将响应内容写入文件
	_, err = io.Copy(file, resp.Body)
	if err != nil {
		// 如果写入失败，删除已创建的文件
		os.Remove(actualPath)
		return "", fmt.Errorf("写入文件失败: %v", err)
	}

	return actualPath, nil
}

// extractFileNameFromURL 从URL中提取文件名
func extractFileNameFromURL(urlStr string) string {
	// 解析URL
	parsedURL, err := url.Parse(urlStr)
	if err != nil {
		return ""
	}

	// 从路径中提取文件名
	path := parsedURL.Path
	if path == "" || path == "/" {
		return ""
	}

	// 获取最后一个路径段
	segments := strings.Split(path, "/")
	fileName := segments[len(segments)-1]

	// 清理文件名中的特殊字符
	fileName = sanitizeFileNameWithLimit(fileName)

	// 如果文件名没有扩展名，尝试从Content-Type推断
	if filepath.Ext(fileName) == "" {
		ext := inferExtensionFromURL(urlStr)
		if ext != "" {
			fileName += ext
		}
	}

	return fileName
}

// sanitizeFileNameWithLimit 清理文件名中的特殊字符并限制长度
func sanitizeFileNameWithLimit(fileName string) string {
	// 移除或替换不合法的文件名字符
	invalidChars := []string{"<", ">", ":", "\"", "|", "?", "*", "\\", "/"}
	result := fileName
	for _, char := range invalidChars {
		result = strings.ReplaceAll(result, char, "_")
	}

	// 限制文件名长度
	if len(result) > 100 {
		result = result[:100]
	}

	return result
}

// inferExtensionFromURL 根据URL推断文件扩展名
func inferExtensionFromURL(url string) string {
	// 根据URL特征推断文件类型
	urlLower := strings.ToLower(url)

	// 图片类型
	if strings.Contains(urlLower, ".jpg") || strings.Contains(urlLower, ".jpeg") {
		return ".jpg"
	}
	if strings.Contains(urlLower, ".png") {
		return ".png"
	}
	if strings.Contains(urlLower, ".gif") {
		return ".gif"
	}
	if strings.Contains(urlLower, ".bmp") {
		return ".bmp"
	}
	if strings.Contains(urlLower, ".webp") {
		return ".webp"
	}
	if strings.Contains(urlLower, ".svg") {
		return ".svg"
	}
	if strings.Contains(urlLower, ".ico") {
		return ".ico"
	}
	if strings.Contains(urlLower, ".tiff") || strings.Contains(urlLower, ".tif") {
		return ".tiff"
	}
	if strings.Contains(urlLower, ".psd") {
		return ".psd"
	}
	if strings.Contains(urlLower, ".raw") {
		return ".raw"
	}
	if strings.Contains(urlLower, ".heic") {
		return ".heic"
	}
	if strings.Contains(urlLower, ".avif") {
		return ".avif"
	}

	// 视频类型
	if strings.Contains(urlLower, ".mp4") {
		return ".mp4"
	}
	if strings.Contains(urlLower, ".avi") {
		return ".avi"
	}
	if strings.Contains(urlLower, ".mov") {
		return ".mov"
	}
	if strings.Contains(urlLower, ".wmv") {
		return ".wmv"
	}
	if strings.Contains(urlLower, ".flv") {
		return ".flv"
	}
	if strings.Contains(urlLower, ".webm") {
		return ".webm"
	}
	if strings.Contains(urlLower, ".mkv") {
		return ".mkv"
	}
	if strings.Contains(urlLower, ".m4v") {
		return ".m4v"
	}
	if strings.Contains(urlLower, ".3gp") {
		return ".3gp"
	}
	if strings.Contains(urlLower, ".mpg") || strings.Contains(urlLower, ".mpeg") {
		return ".mpg"
	}
	if strings.Contains(urlLower, ".m2v") {
		return ".m2v"
	}
	if strings.Contains(urlLower, ".mts") {
		return ".mts"
	}
	if strings.Contains(urlLower, ".ogv") {
		return ".ogv"
	}
	if strings.Contains(urlLower, ".ts") {
		return ".ts"
	}
	if strings.Contains(urlLower, ".vob") {
		return ".vob"
	}

	// 音频类型
	if strings.Contains(urlLower, ".mp3") {
		return ".mp3"
	}
	if strings.Contains(urlLower, ".wav") {
		return ".wav"
	}
	if strings.Contains(urlLower, ".flac") {
		return ".flac"
	}
	if strings.Contains(urlLower, ".aac") {
		return ".aac"
	}
	if strings.Contains(urlLower, ".ogg") {
		return ".ogg"
	}
	if strings.Contains(urlLower, ".m4a") {
		return ".m4a"
	}
	if strings.Contains(urlLower, ".wma") {
		return ".wma"
	}
	if strings.Contains(urlLower, ".opus") {
		return ".opus"
	}
	if strings.Contains(urlLower, ".amr") {
		return ".amr"
	}
	if strings.Contains(urlLower, ".mid") || strings.Contains(urlLower, ".midi") {
		return ".mid"
	}
	if strings.Contains(urlLower, ".ape") {
		return ".ape"
	}
	if strings.Contains(urlLower, ".aiff") || strings.Contains(urlLower, ".aif") {
		return ".aiff"
	}

	// 文档类型
	if strings.Contains(urlLower, ".pdf") {
		return ".pdf"
	}
	if strings.Contains(urlLower, ".doc") {
		return ".doc"
	}
	if strings.Contains(urlLower, ".docx") {
		return ".docx"
	}
	if strings.Contains(urlLower, ".xls") {
		return ".xls"
	}
	if strings.Contains(urlLower, ".xlsx") {
		return ".xlsx"
	}
	if strings.Contains(urlLower, ".ppt") {
		return ".ppt"
	}
	if strings.Contains(urlLower, ".pptx") {
		return ".pptx"
	}
	if strings.Contains(urlLower, ".txt") {
		return ".txt"
	}
	if strings.Contains(urlLower, ".csv") {
		return ".csv"
	}
	if strings.Contains(urlLower, ".rtf") {
		return ".rtf"
	}
	if strings.Contains(urlLower, ".odt") {
		return ".odt"
	}
	if strings.Contains(urlLower, ".ods") {
		return ".ods"
	}
	if strings.Contains(urlLower, ".odp") {
		return ".odp"
	}

	// 压缩文件
	if strings.Contains(urlLower, ".zip") {
		return ".zip"
	}
	if strings.Contains(urlLower, ".rar") {
		return ".rar"
	}
	if strings.Contains(urlLower, ".7z") {
		return ".7z"
	}
	if strings.Contains(urlLower, ".tar") {
		return ".tar"
	}
	if strings.Contains(urlLower, ".gz") {
		return ".gz"
	}
	if strings.Contains(urlLower, ".bz2") {
		return ".bz2"
	}

	// 可执行文件
	if strings.Contains(urlLower, ".exe") {
		return ".exe"
	}
	if strings.Contains(urlLower, ".msi") {
		return ".msi"
	}
	if strings.Contains(urlLower, ".deb") {
		return ".deb"
	}
	if strings.Contains(urlLower, ".rpm") {
		return ".rpm"
	}
	if strings.Contains(urlLower, ".dmg") {
		return ".dmg"
	}

	// 网页相关
	if strings.Contains(urlLower, ".html") || strings.Contains(urlLower, ".htm") {
		return ".html"
	}
	if strings.Contains(urlLower, ".css") {
		return ".css"
	}
	if strings.Contains(urlLower, ".js") {
		return ".js"
	}
	if strings.Contains(urlLower, ".json") {
		return ".json"
	}
	if strings.Contains(urlLower, ".xml") {
		return ".xml"
	}

	// 字体文件
	if strings.Contains(urlLower, ".ttf") {
		return ".ttf"
	}
	if strings.Contains(urlLower, ".otf") {
		return ".otf"
	}
	if strings.Contains(urlLower, ".woff") {
		return ".woff"
	}
	if strings.Contains(urlLower, ".woff2") {
		return ".woff2"
	}

	// 数据库文件
	if strings.Contains(urlLower, ".sql") {
		return ".sql"
	}
	if strings.Contains(urlLower, ".db") {
		return ".db"
	}
	if strings.Contains(urlLower, ".sqlite") {
		return ".sqlite"
	}

	return ""
}

// cleanOldFiles 清理temp目录中的旧文件
func cleanOldFiles(tempDir string, maxAge time.Duration) {
	entries, err := os.ReadDir(tempDir)
	if err != nil {
		globalLogger.Warn("[网络资源处理] 读取temp目录失败: %v", err)
		return
	}

	cutoffTime := time.Now().Add(-maxAge)

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

		info, err := entry.Info()
		if err != nil {
			continue
		}

		// 删除超过最大年龄的文件
		if info.ModTime().Before(cutoffTime) {
			filePath := filepath.Join(tempDir, entry.Name())
			if err := os.Remove(filePath); err == nil {
				globalLogger.Debug("[网络资源处理] 删除旧文件: %s", filePath)
			}
		}
	}
}