package main

import "C"

///*
//#include <stdlib.h>
//
//// proxyConfig.dll 函数声明
//extern char* ProxyTypeManager(char* proxyType, char* username, char* password, char* machineCode);
//extern void FreeCString(char* str);
//*/
//import "C"
//import (
//	"context"
//	"encoding/json"
//	"fmt"
//	"io"
//	"log"
//	"net/http"
//	"os"
//	"path/filepath"
//	"regexp"
//	"strconv"
//	"strings"
//	"sync"
//	"syscall"
//	"time"
//	"unsafe"
//
//	"github.com/PuerkitoBio/goquery"
//	"github.com/chromedp/chromedp"
//	"github.com/parnurzeal/gorequest"
//)
//
//const (
//	UseProxy = "proxy"  // 使用代理
//	NotProxy = "direct" // 不用代理代理
//)
//
//type Config struct {
//	App struct {
//		MaxRetryTimes    int           `ini:"app.max_retry_times" json:"max_retry_times" default:"3"`
//		RateLimitDelay   time.Duration `ini:"app.rate_limit_delay" json:"rate_limit_delay" default:"500ms"`
//		Size             int           `ini:"app.size" json:"size" default:"5"`
//		DefaultUserAgent string        `ini:"app.default_user_agent" json:"default_user_agent" default:"Mozilla/5.0"`
//	} `ini:"app" json:"app"`
//
//	API struct {
//		LoginURL         string `ini:"api.login_url" json:"login_url" default:"https://login.kongfz.com/Pc/Login/account"`
//		BookSearchURL    string `ini:"api.book_search_url" json:"book_search_url" default:"https://search.kongfz.com/pc-gw/search-web/client/pc/bookLib/keyword/list"`
//		ProductSearchURL string `ini:"api.product_search_url" json:"product_search_url" default:"https://search.kongfz.com/pc-gw/search-web/client/pc/product/keyword/list"`
//	} `ini:"api" json:"api"`
//
//	Proxy struct {
//		Servers         string `ini:"proxy.servers" json:"servers" default:"http-dynamic.xiaoxiangdaili.com,http-dynamic-S02.xiaoxiangdaili.com,http-dynamic-S03.xiaoxiangdaili.com,http-dynamic-S04.xiaoxiangdaili.com"`
//		Username        string `ini:"proxy.username" json:"username" default:"1297757178467602432"`
//		Password        string `ini:"proxy.password" json:"password" default:"QgQBvP7f"`
//		TailMachineCode string `ini:"proxy.tail_machine_code" json:"tail_machine_code" default:"b7bf22a237ec692f13fcc2c43ee63252"`
//		TailCardKey     string `ini:"proxy.tail_card_key" json:"tail_card_key" default:"DL_20_YK_1920acb2129844c2aabade3896560a9b"`
//		ProxyFilePath   string `ini:"proxy.proxy_file_path" json:"proxy_file_path" default:"dll/proxyConfig.dll"`
//	} `ini:"proxy" json:"proxy"`
//}
//
//// 条目详情结构体
//type BookInfo struct {
//	BookName           string `json:"book_name"`            // 书名
//	Author             string `json:"author"`               // 作者
//	Publisher          string `json:"publisher"`            // 出版社
//	ISBN               string `json:"isbn"`                 // ISBN
//	PublicationTime    int64  `json:"publication_time"`     // 出版时间
//	Edition            string `json:"edition"`              // 版次
//	PrintTime          string `json:"print_time"`           // 印刷时间
//	FixPrice           string `json:"fix_price"`            // 定价
//	BindingLayout      string `json:"binding_layout"`       // 装帧
//	Format             string `json:"format"`               // 开本
//	Paper              string `json:"paper"`                // 纸张
//	Pages              string `json:"pages"`                // 页数
//	Wordage            string `json:"wordage"`              // 字数
//	Languages          string `json:"languages"`            // 语种
//	Era                string `json:"era"`                  // 年代
//	EngravingMethod    string `json:"engraving_method"`     // 刻印方式
//	Dimensions         string `json:"dimensions"`           // 尺寸
//	VolumeNumber       string `json:"volume_number"`        // 册数
//	BookPic            string `json:"book_pic"`             // 图书封面图(官图)
//	BookPicS           string `json:"book_pic_s"`           // 图书封面图(实拍图)
//	SellingPrice       string `json:"selling_price"`        // 售价
//	Condition          string `json:"condition"`            // 品相
//	ExpressDeliveryFee string `json:"express_delivery_fee"` // 快递费
//	Editor             string `json:"editor"`               // 编辑
//	Category           string `json:"category"`             // 分类
//	BuyCount           string `json:"buy_count"`            // 买过
//	SellCount          string `json:"sell_count"`           // 在卖
//	Content            string `json:"content"`              // 内容
//	Mid                int64  `json:"mid"`                  // 商家id
//	ItemId             int64  `json:"item_id"`              // 商品id
//	ShopId             int64  `json:"shop_id"`              // 店铺id
//}
//
//// API响应结构
//type APIResponse struct {
//	Success  bool        `json:"success"`
//	Message  string      `json:"message,omitempty"`
//	GoodsNum string      `json:"goods_num,omitempty"`
//	PNum     string      `json:"pnum,omitempty"`
//	Data     interface{} `json:"data,omitempty"`
//	Error    string      `json:"error,omitempty"`
//}
//
//// 全局变量
//var (
//	cf             Config     // 配置信息
//	tailProxyMu    sync.Mutex // 互斥锁
//	proxyFailCount int
//
//	// 全局代理管理器
//	globalProxyManager  *ProxyConfigManager
//	proxyManagerOnce    sync.Once
//	proxyManagerInitErr error
//)
//
//// ProductInfo 商品信息结构
//type ProductInfo struct {
//	ItemID      string `json:"itemId"`
//	BookName    string `json:"bookName"`
//	Price       string `json:"price"`
//	ShippingFee string `json:"shippingFee"`
//}
//
//// ProductResponse 响应结构
//type ProductResponse struct {
//	Success bool          `json:"success"`
//	Message string        `json:"message,omitempty"`
//	Data    []ProductInfo `json:"data,omitempty"`
//}
//
//// 并行获取详情的结果结构
//type DetailResult struct {
//	URL   string
//	Doc   *goquery.Document
//	Error error
//	Index int
//}
//
//// 第一阶段：收集基本信息并识别需要详情的项目
//type BookItem struct {
//	Book      BookInfo
//	Selection *goquery.Selection
//	HasDetail bool
//	DetailURL string
//	Index     int
//}
//
//// 销量榜目录分类列表响应结构体
//type SalesCategoryResponse struct {
//	Status     bool            `json:"status"`
//	Result     []SalesCategory `json:"result"`
//	ErrMessage string          `json:"errMessage"`
//	ErrCode    int             `json:"errCode"`
//}
//
//// 分类项结构体
//type SalesCategory struct {
//	Key   string `json:"key"`
//	Value int    `json:"value"`
//}
//
//// 图书详情响应结构体
//type BookDetailResponse struct {
//	Status     bool     `json:"status"`
//	Result     BookList `json:"result"`
//	ErrMessage string   `json:"errMessage"`
//	ErrCode    int      `json:"errCode"`
//}
//
//// 图书列表结构体
//type BookList struct {
//	Current int               `json:"current"`
//	Data    []BookInformation `json:"data"`
//	Total   int               `json:"total"`
//}
//
//// 图书信息结构体
//type BookInformation struct {
//	Author              string       `json:"author"`
//	BookName            string       `json:"bookName"`
//	ContentIntroduction string       `json:"contentIntroduction"`
//	ImgUrl              string       `json:"imgUrl"`
//	Isbn                string       `json:"isbn"`
//	ItemUrls            ItemUrls     `json:"itemUrls"`
//	Mid                 int          `json:"mid"`
//	NewMinPrice         string       `json:"newMinPrice"`
//	OldMinPrice         string       `json:"oldMinPrice"`
//	Press               string       `json:"press"`
//	Price               string       `json:"price"`
//	PubDate             string       `json:"pubDate"`
//	RiseTag             string       `json:"riseTag"`
//	AuthorArr           []AuthorInfo `json:"authorArr"`
//	PressUrl            string       `json:"pressUrl"`
//}
//
//// 作者信息结构体
//type AuthorInfo struct {
//	Name        string `json:"name"`
//	OriName     string `json:"oriName"`
//	Nationality string `json:"nationality"`
//	Role        string `json:"role"`
//	Url         string `json:"url"`
//}
//
//// 商品链接结构体
//type ItemUrls struct {
//	AppUrl  string `json:"appUrl"`
//	MUrl    string `json:"mUrl"`
//	MiniUrl string `json:"miniUrl"`
//	PcUrl   string `json:"pcUrl"`
//}
//
//// ProxyConfigManager 代理配置DLL管理器
//type ProxyConfigManager struct {
//	dll *syscall.DLL
//}
//
//func NewProxyConfigManager(dllPath string) (*ProxyConfigManager, error) {
//	dll, err := syscall.LoadDLL(dllPath)
//	if err != nil {
//		return nil, fmt.Errorf("加载代理配置DLL失败: %v", err)
//	}
//	return &ProxyConfigManager{dll: dll}, nil
//}
//
//func (m *ProxyConfigManager) Close() {
//	if m.dll != nil {
//		m.dll.Release()
//	}
//}
//
//// ProxyTypeManager 调用代理类型管理器
//func (m *ProxyConfigManager) ProxyTypeManager(proxyType, username, password, machineCode string) (string, error) {
//	proc, err := m.dll.FindProc("ProxyTypeManager")
//	if err != nil {
//		return "", fmt.Errorf("找不到函数 ProxyTypeManager: %v", err)
//	}
//
//	// 准备参数
//	proxyTypePtr, _ := syscall.BytePtrFromString(proxyType)
//	usernamePtr, _ := syscall.BytePtrFromString(username)
//	passwordPtr, _ := syscall.BytePtrFromString(password)
//	machineCodePtr, _ := syscall.BytePtrFromString(machineCode)
//
//	// 调用函数
//	r1, _, err := proc.Call(
//		uintptr(unsafe.Pointer(proxyTypePtr)),
//		uintptr(unsafe.Pointer(usernamePtr)),
//		uintptr(unsafe.Pointer(passwordPtr)),
//		uintptr(unsafe.Pointer(machineCodePtr)),
//	)
//
//	if err != nil && err.Error() != "The operation completed successfully." {
//		return "", fmt.Errorf("调用 ProxyTypeManager 失败: %v", err)
//	}
//
//	// 转换结果
//	result := (*byte)(unsafe.Pointer(r1))
//	var resultBytes []byte
//	for i := 0; ; i++ {
//		bytePtr := (*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(result)) + uintptr(i)))
//		if *bytePtr == 0 {
//			break
//		}
//		resultBytes = append(resultBytes, *bytePtr)
//	}
//
//	// 释放内存
//	freeProc, _ := m.dll.FindProc("FreeCString")
//	if freeProc != nil {
//		freeProc.Call(r1)
//	}
//
//	return string(resultBytes), nil
//}
//
//// 获取销量榜所有分类中图书的isbn
//func GetAllCategoryBooks() ([]string, error) {
//	// 1. 获取分类列表
//	categories, err := GetSalesBookInfo()
//	if err != nil {
//		return nil, fmt.Errorf("获取分类列表失败: %v", err)
//	}
//	// 初始化返回的ISBN数组
//	var allISBNs []string
//
//	for i, category := range categories {
//		fmt.Printf("\n=== 正在处理分类 %d/%d: %s (ID: %d) ===\n", i+1, len(categories), category.Key, category.Value)
//		// 根据分类ID获取图书详情
//		bookDetails, err := GetBookDetailsByCategory(category.Value)
//		if err != nil {
//			fmt.Printf("获取分类 %s 的图书信息失败: %v\n", category.Key, err)
//			continue
//		}
//		// 将当前分类的图书数据添加到结果map中
//		if bookDetails != nil && bookDetails.Result.Data != nil {
//			for _, book := range bookDetails.Result.Data {
//				if book.Isbn != "" {
//					allISBNs = append(allISBNs, book.Isbn)
//					fmt.Printf("添加到ISBN列表: %s\n", book.Isbn)
//				}
//			}
//			fmt.Printf("分类 %s 获取到 %d 本图书\n", category.Key, len(bookDetails.Result.Data))
//		} else {
//			fmt.Printf("分类 %s 没有获取到图书数据\n", category.Key)
//		}
//		time.Sleep(500 * time.Microsecond)
//	}
//	// 去重处理（可选）
//	allISBNs = removeDuplicateISBNs(allISBNs)
//	// 打印统计信息
//	fmt.Printf("\n=== 总计: %d 个分类, %d 个唯一ISBN ===\n", len(categories), len(allISBNs))
//	return allISBNs, nil
//}
//
//// 辅助函数：去除重复的ISBN
//func removeDuplicateISBNs(isbns []string) []string {
//	seen := make(map[string]bool)
//	var result []string
//
//	for _, isbn := range isbns {
//		if !seen[isbn] {
//			seen[isbn] = true
//			result = append(result, isbn)
//		}
//	}
//
//	return result
//}
//
//// 获取销量榜的图书信息
//func GetSalesBookInfo() ([]SalesCategory, error) {
//	// 构建请求URL
//	url := "https://item.kongfz.com/api/Pc/getSellWellCatList"
//	// 创建HTTP客户端
//	client := &http.Client{
//		Timeout: 30 * time.Second,
//	}
//	// 创建请求
//	req, err := http.NewRequest("GET", url, nil)
//	if err != nil {
//		return nil, fmt.Errorf("创建请求失败: %v", err)
//	}
//	// 设置请求头，模拟浏览器请求
//	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36")
//	req.Header.Set("Accept", "application/json, text/plain, */*")
//	req.Header.Set("Accept-Language", "zh-CN,zh;q=0.9,en;q=0.8")
//	req.Header.Set("Referer", "https://item.kongfz.com/")
//	// 发送请求
//	resp, err := client.Do(req)
//	if err != nil {
//		return nil, fmt.Errorf("请求失败: %v", err)
//	}
//	defer resp.Body.Close()
//	// 检查HTTP状态码
//	if resp.StatusCode != http.StatusOK {
//		return nil, fmt.Errorf("HTTP错误: %s", resp.Status)
//	}
//	// 读取响应体
//	body, err := io.ReadAll(resp.Body)
//	if err != nil {
//		return nil, fmt.Errorf("读取响应失败: %v", err)
//	}
//	// 解析JSON响应
//	var salesCategoryResponse SalesCategoryResponse
//	err = json.Unmarshal(body, &salesCategoryResponse)
//	if err != nil {
//		return nil, fmt.Errorf("解析JSON失败: %v", err)
//	}
//	return salesCategoryResponse.Result, nil
//}
//
//// 根据分类ID获取图书详情
//func GetBookDetailsByCategory(catId int) (*BookDetailResponse, error) {
//	// 构建请求URL
//	url := fmt.Sprintf("https://item.kongfz.com/api/pc/getSellWellListDetail?page=1&pageSize=100&timeRank=2&catId=%d", catId)
//	// 创建HTTP客户端
//	client := &http.Client{
//		Timeout: 30 * time.Second,
//	}
//	// 创建请求
//	req, err := http.NewRequest("GET", url, nil)
//	if err != nil {
//		return nil, fmt.Errorf("创建请求失败: %v", err)
//	}
//	// 设置请求头，模拟浏览器请求
//	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36")
//	req.Header.Set("Accept", "application/json, text/plain, */*")
//	req.Header.Set("Accept-Language", "zh-CN,zh;q=0.9,en;q=0.8")
//	req.Header.Set("Referer", "https://item.kongfz.com/")
//	// 发送请求
//	resp, err := client.Do(req)
//	if err != nil {
//		return nil, fmt.Errorf("请求失败: %v", err)
//	}
//	defer resp.Body.Close()
//	// 检查HTTP状态码
//	if resp.StatusCode != http.StatusOK {
//		return nil, fmt.Errorf("HTTP错误: %s", resp.Status)
//	}
//	// 读取响应体
//	body, err := io.ReadAll(resp.Body)
//	if err != nil {
//		return nil, fmt.Errorf("读取响应失败: %v", err)
//	}
//	var bookDetailResponse BookDetailResponse
//	err = json.Unmarshal(body, &bookDetailResponse)
//	if err != nil {
//		return nil, fmt.Errorf("解析JSON失败: %v", err)
//	}
//	if !bookDetailResponse.Status {
//		return nil, fmt.Errorf("API返回错误: %s (代码: %d)", bookDetailResponse.ErrMessage, bookDetailResponse.ErrCode)
//	}
//	return &bookDetailResponse, nil
//}
//
//// 通过店铺ID获取孔网实拍图和条目信息
//func getKFZShopBookInfo(fetchMode, proxyType, username, password, machineCode, shopId, isImage, bookNum, pageNum, sortType, sort, priceDown, priceUp string) (books []BookInfo, goodsNum string, pNum string, err error) {
//	// 判断店铺ID
//	if shopId == "" {
//		return nil, "", "", fmt.Errorf("店铺编码为空!")
//	}
//	// 判断是否有图片，设置默认值0
//	if isImage == "" {
//		isImage = "0"
//	} else {
//		_, isImageErr := strconv.Atoi(isImage)
//		if isImageErr != nil {
//			return nil, "", "", fmt.Errorf("是否有图片输入必须是数字!", isImageErr)
//		}
//	}
//	// 判断一页图书数量，设置默认值100
//	if bookNum == "" {
//		bookNum = "100"
//	} else {
//		isBookNum, bookNumErr := strconv.Atoi(bookNum)
//		if bookNumErr != nil {
//			return nil, "", "", fmt.Errorf("图书数量输入必须是数字!", bookNumErr)
//		}
//		if isBookNum < 0 && isBookNum > 100 {
//			return nil, "", "", fmt.Errorf("图书数量输入错误:只能出入(0~100区间)")
//		}
//	}
//	// 判断页数，设置默认值1
//	if pageNum == "" {
//		pageNum = "1"
//	} else {
//		_, pageNumErr := strconv.Atoi(pageNum)
//		if pageNumErr != nil {
//			return nil, "", "", fmt.Errorf("页数输入必须是数字!", pageNumErr)
//		}
//	}
//	// 判断排序类型，设置默认值sort
//	if sortType == "" {
//		sortType = "sort"
//	} else {
//		validSortTypes := map[string]bool{
//			"sort":    true,
//			"putDate": true,
//			"newItem": true,
//			"price":   true,
//		}
//		if !validSortTypes[sortType] {
//			return nil, "", "", fmt.Errorf("无效的排序类型: %s，可选值: sort, putDate, newItem, price", sortType)
//		}
//	}
//	// 判断排序，设置默认值desc
//	if sort == "" {
//		sort = "desc"
//	} else {
//		validSorts := map[string]bool{
//			"desc": true,
//			"asc":  true,
//		}
//		if !validSorts[sort] {
//			return nil, "", "", fmt.Errorf("无效的排序类型: %s，可选值: desc, asc", sort)
//		}
//	}
//	// 判断价格下限，设置默认值0
//	if priceDown == "" {
//		priceDown = "0"
//	} else {
//		_, priceDownErr := strconv.ParseFloat(priceDown, 64)
//		if priceDownErr != nil {
//			return nil, "", "", fmt.Errorf("价格输入必须是数字!", priceDownErr)
//		}
//	}
//	// 判断价格上限，设置默认值0
//	if priceUp == "" {
//		priceUp = "0"
//	} else {
//		_, priceUpErr := strconv.ParseFloat(priceUp, 64)
//		if priceUpErr != nil {
//			return nil, "", "", fmt.Errorf("价格输入必须是数字!", priceUpErr)
//		}
//	}
//	// 调用的url
//	url := fmt.Sprintf("https://shop.kongfz.com/%s/all/%s_%s_0_0_%s_%s_%s_%s_%s",
//		shopId, isImage, bookNum, pageNum, sortType, sort, priceDown, priceUp)
//	log.Printf("调用的URL: %s", url)
//	// 并行获取商品信息（使用优化后的Chromedp）
//	response, err := FetchProductInfoWithChromedp(url)
//	if err != nil {
//		fmt.Printf("❌ 获取商品信息失败: %v", err)
//	}
//	// 发送请求
//	doc, err := fetchDocument(fetchMode, proxyType, username, password, machineCode, url)
//
//	// 全部商品数量
//	num := doc.Find("div.crumbs-nav-main.clearfix").Find("span")
//	if match := regexp.MustCompile(`\d+`).FindString(num.Text()); match != "" {
//		goodsNum = match
//	}
//	// 商品页数
//	pg := doc.Find("li.pull-right.page_num").Find("span")
//	_, split, found := strings.Cut(strings.TrimSpace(pg.Text()), "/")
//	if found {
//		pNum = split
//	} else {
//		log.Printf("未找到页数！")
//	}
//
//	infoDiv := doc.Find("div.list-content")
//	if infoDiv.Length() > 0 {
//		item := infoDiv.Find("div.item.clearfix")
//		var bookItems []BookItem
//
//		for i := 0; i < item.Length(); i++ {
//			s := item.Eq(i)
//			book := BookInfo{}
//			// 书名
//			book.BookName = strings.TrimSpace(s.Find("div.title a.link").Text())
//			// 作者
//			book.Author = extractNormalText(s, "作者")
//			// 出版社
//			book.Publisher = extractNormalText(s, "出版社")
//			// 出版时间，提取出版时间并转换为时间戳
//			pubTimeStr := extractNormalText(s, "出版时间")
//			if pubTimeStr != "" {
//				// 尝试不同的时间格式
//				formats := []string{"2006-01", "2006-01-02", "2006"}
//				for _, format := range formats {
//					if t, err := time.Parse(format, pubTimeStr); err == nil {
//						book.PublicationTime = t.Unix()
//						break
//					}
//				}
//			}
//			// 提取ISBN
//			book.ISBN = strings.TrimSpace(s.AttrOr("isbn", ""))
//			// 版次
//			book.Edition = extractNormalText(s, "版次")
//			// 印刷时间
//			book.PrintTime = extractNormalText(s, "印刷时间")
//			// 装帧
//			book.BindingLayout = extractNormalText(s, "装帧")
//			// 开本
//			book.Format = extractNormalText(s, "开本")
//			// 纸张
//			book.Paper = extractNormalText(s, "纸张")
//			// 字数
//			book.Wordage = extractNormalText(s, "字数")
//			// 售价，提取价格（优先从元素属性获取）
//			book.SellingPrice = s.AttrOr("price", "")
//			if book.SellingPrice == "" {
//				book.SellingPrice = strings.TrimSpace(s.Find("div.price span.bold").Text())
//			}
//			// 提取图片
//			if img, exists := s.Find("div.item-img img").Attr("src"); exists {
//				book.BookPicS = img
//			}
//			// 快递费
//			val, exists := s.Attr("itemid")
//			for in, p := range response.Data {
//				if exists {
//					if val == p.ItemID {
//						book.ExpressDeliveryFee = p.ShippingFee
//						in = in + 1
//					}
//				}
//			}
//			// 提取品相
//			book.Condition = strings.TrimSpace(s.Find("div.quality").Text())
//
//			// 检查是否需要获取详情
//			hasDetail := s.Find("div.zl-isbn-info").Length() > 0
//			detailURl := ""
//			if hasDetail {
//				detailURl = s.Find("a.img-box").AttrOr("href", "")
//			}
//
//			bookItems = append(bookItems, BookItem{
//				Book:      book,
//				Selection: s,
//				HasDetail: hasDetail,
//				DetailURL: detailURl,
//				Index:     i,
//			})
//		}
//
//		detailResults := fetchAllDetailsParallel(fetchMode, proxyType, username, password, machineCode, bookItems)
//		books = mergeBookDetails(bookItems, detailResults)
//	}
//	return books, goodsNum, pNum, nil
//}
//
//// 并行获取所有详情
//func fetchAllDetailsParallel(fetchMode, proxyType, username, password, machineCode string, bookItems []BookItem) map[string]*DetailResult {
//	// 收集所有需要获取详情的URL
//	var detailTasks []struct {
//		URL   string
//		Index int
//	}
//
//	for _, item := range bookItems {
//		if item.HasDetail && item.DetailURL != "" {
//			detailTasks = append(detailTasks, struct {
//				URL   string
//				Index int
//			}{
//				URL:   item.DetailURL,
//				Index: item.Index,
//			})
//		}
//	}
//
//	if len(detailTasks) == 0 {
//		return make(map[string]*DetailResult)
//	}
//
//	type taskResult struct {
//		URL   string
//		Doc   *goquery.Document
//		Error error
//		Index int
//	}
//
//	ch := make(chan taskResult, len(detailTasks))
//	var wg sync.WaitGroup
//
//	// 限制并发数，避免过多连接
//	sem := make(chan struct{}, 5) // 最大5个并发
//
//	for _, task := range detailTasks {
//		wg.Add(1)
//		go func(url string, index int) {
//			defer wg.Done()
//			sem <- struct{}{}        // 获取信号量
//			defer func() { <-sem }() // 释放信号量
//
//			doc, err := fetchDocument(fetchMode, proxyType, username, password, machineCode, url)
//			ch <- taskResult{
//				URL:   url,
//				Doc:   doc,
//				Error: err,
//				Index: index,
//			}
//		}(task.URL, task.Index)
//	}
//
//	wg.Wait()
//	close(ch)
//
//	results := make(map[string]*DetailResult)
//	for res := range ch {
//		results[res.URL] = &DetailResult{
//			URL:   res.URL,
//			Doc:   res.Doc,
//			Error: res.Error,
//			Index: res.Index,
//		}
//	}
//
//	return results
//}
//
//// 获取Document文档(带重试机制)
//func fetchDocument(fetchMode, proxyType, username, password, machineCode, url string) (*goquery.Document, error) {
//	log.Printf("调用的URL: %s", url)
//	maxRetries := cf.App.MaxRetryTimes
//	var detailsResp *http.Response
//	var errors []error
//	var detailsBody []byte
//	for attempt := 0; attempt < maxRetries; attempt++ {
//		if attempt > 0 {
//			log.Printf("第 %d 次重试请求...", attempt)
//			// 重试前等待，使用指数退避策略
//			waitTime := time.Duration(attempt*attempt) * cf.App.RateLimitDelay // 平方退避
//			log.Printf("等待 %v 后重试", waitTime)
//			time.Sleep(waitTime)
//		}
//		if fetchMode == NotProxy {
//			detailsResp, _, errors = gorequest.New().
//				Get(url).
//				Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36").
//				Set("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8").
//				Set("Accept-Language", "zh-CN,zh;q=0.9,en;q=0.8").
//				Timeout(120 * time.Second).
//				End()
//		} else if fetchMode == UseProxy {
//			detailsReq := XxProxyRequest(proxyType, username, password, machineCode).
//				Get(url).
//				Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36").
//				Set("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8").
//				Set("Accept-Language", "zh-CN,zh;q=0.9,en;q=0.8").
//				Set("Connection", "close") // 每次请求关闭连接
//			detailsResp, _, errors = detailsReq.End()
//		} else {
//			errors = append(errors, fmt.Errorf("请求失败，选择模式错误！"))
//		}
//		// 检查是否需要重试
//		shouldRetry := false
//		if len(errors) > 0 {
//			shouldRetry = true
//			log.Printf("请求失败 (尝试 %d/%d): %v", attempt+1, maxRetries+1, errors)
//		} else if detailsResp == nil {
//			shouldRetry = true
//			log.Printf("响应为空 (尝试 %d/%d)", attempt+1, maxRetries+1)
//		} else if detailsResp.StatusCode != http.StatusOK {
//			// 只对服务器错误进行重试，不对客户端错误重试
//			if detailsResp.StatusCode >= 500 {
//				shouldRetry = true
//			}
//			log.Printf("HTTP状态码 %d,HTTP请求失败: %s (尝试 %d/%d)", detailsResp.StatusCode, detailsResp.Body, attempt+1, maxRetries+1)
//		}
//		// 如果不需要重试，跳出循环
//		if !shouldRetry {
//			break
//		}
//		// 如果是最后一次尝试，不继续重试
//		if attempt == maxRetries {
//			break
//		}
//		// 关闭响应体（如果存在）
//		if detailsResp != nil && detailsResp.Body != nil {
//			detailsResp.Body.Close()
//		}
//	}
//	// 检测请求是否错误
//	if len(errors) > 0 {
//		var proxyAuthFailed bool
//		var timeoutError bool
//		var connectionError bool
//		for _, e := range errors {
//			errStr := e.Error()
//			if strings.Contains(errStr, "Proxy Authentication Required") {
//				proxyAuthFailed = true
//			}
//			if strings.Contains(errStr, "timeout") || strings.Contains(errStr, "i/o timeout") {
//				timeoutError = true
//			}
//			if strings.Contains(errStr, "connection") || strings.Contains(errStr, "connect") {
//				connectionError = true
//			}
//		}
//		if proxyAuthFailed {
//			return nil, fmt.Errorf("代理认证失败")
//		}
//		if timeoutError {
//			return nil, fmt.Errorf("请求超时，经过 %d 次尝试，超时网址:%s", maxRetries+1, url)
//		}
//		if connectionError {
//			return nil, fmt.Errorf("网络连接错误，经过 %d 次尝试，错误网址:%s", maxRetries+1, url)
//		}
//		return nil, fmt.Errorf("查询请求失败，经过 %d 次尝试: %v，失败网址:%s", maxRetries+1, errors, url)
//	}
//	if detailsResp.StatusCode != http.StatusOK {
//		return nil, fmt.Errorf("HTTP错误: %s", detailsResp.Status)
//	}
//
//	detailsBody, err := io.ReadAll(detailsResp.Body)
//	if err != nil {
//		return nil, err
//	}
//
//	return goquery.NewDocumentFromReader(strings.NewReader(string(detailsBody)))
//}
//
//// 合并基本信息和详情
//func mergeBookDetails(bookItems []BookItem, detailResults map[string]*DetailResult) []BookInfo {
//	var books []BookInfo
//
//	for _, item := range bookItems {
//		book := item.Book
//
//		// 如果有详情且获取成功，补充详细信息
//		if item.HasDetail && item.DetailURL != "" {
//			if result, exists := detailResults[item.DetailURL]; exists && result.Error == nil && result.Doc != nil {
//				detailsDiv := result.Doc.Find("div.detail-lists.clear-fix")
//				if detailsDiv.Length() > 0 {
//					selection := detailsDiv.Find("li")
//					book.Author = extractNormalDetails(selection, "作者")
//					book.Publisher = extractNormalDetails(selection, "出版社")
//					detailsTime := extractNormalDetails(selection, "出版时间")
//					if detailsTime != "" {
//						formats := []string{"2006-01", "2006-01-02", "2006"}
//						for _, format := range formats {
//							if t, err := time.Parse(format, detailsTime); err == nil {
//								book.PublicationTime = t.Unix()
//								break
//							}
//						}
//					}
//					book.ISBN = extractNormalDetails(selection, "ISBN")
//					book.Edition = extractNormalDetails(selection, "版次")
//					book.FixPrice = extractNormalDetails(selection, "定价")
//					book.BindingLayout = extractNormalDetails(selection, "装帧")
//					book.Format = extractNormalDetails(selection, "开本")
//					book.Pages = extractNormalDetails(selection, "页数")
//					book.Wordage = extractNormalDetails(selection, "字数")
//				}
//			}
//		}
//
//		books = append(books, book)
//	}
//	return books
//}
//
//// 根据url获取单个图书详情信息
//func getUrlBookDetails(fetchMode, proxyType, username, password, machineCode, url string) (books []BookInfo, err error) {
//	document, err := fetchDocument(fetchMode, proxyType, username, password, machineCode, url)
//	if err != nil {
//		return nil, err
//	}
//
//	fee, err := FetchBookDetailsShippingFee(url)
//	if err != nil {
//		return nil, err
//	}
//	book := BookInfo{}
//	//书名
//	book.BookName = strings.TrimSpace(document.Find("h1.title").Text())
//
//	//作者等信息
//	topDiv := document.Find("div.keywords-define.keywords-define-1000.clear-fix")
//	if topDiv.Length() > 0 {
//		topDiv.Find("li").Each(func(i int, li *goquery.Selection) {
//			titleSpan := li.Find("span.keywords-define-title")
//			contentSpan := li.Find("span.keywords-define-txt")
//			if contentSpan.Length() == 0 {
//				fmt.Printf("未找到指定的contentSpan信息")
//			}
//			titleText := strings.TrimSpace(titleSpan.Text())
//			contentText := strings.TrimSpace(contentSpan.Text())
//			titleText = strings.TrimSpace(titleText)
//			if strings.Contains(titleText, "作者") {
//				book.Author = cleanString(contentText)
//			}
//			if strings.Contains(titleText, "出版社") {
//				book.Publisher = contentText
//			}
//			if strings.Contains(titleText, "出版人") {
//				book.Publisher = contentText
//			}
//			if strings.Contains(titleText, "ISBN") {
//				book.ISBN = contentText
//			}
//			if strings.Contains(titleText, "出版时间") {
//				book.PublicationTime = validateDateFormat(contentText)
//			}
//			if strings.Contains(titleText, "版次") {
//				book.Edition = contentText
//			}
//			if strings.Contains(titleText, "装帧") {
//				book.BindingLayout = contentText
//			}
//			if strings.Contains(titleText, "开本") {
//				book.Format = contentText
//			}
//			if strings.Contains(titleText, "页数") {
//				book.Pages = contentText
//			}
//			if strings.Contains(titleText, "字数") {
//				book.Wordage = contentText
//			}
//			if strings.Contains(titleText, "纸张") {
//				book.Paper = contentText
//			}
//			if strings.Contains(titleText, "年代") {
//				book.Era = contentText
//			}
//			if strings.Contains(titleText, "刻印方式") {
//				book.EngravingMethod = contentText
//			}
//			if strings.Contains(titleText, "尺寸") {
//				book.Dimensions = contentText
//			}
//			if strings.Contains(titleText, "册数") {
//				book.VolumeNumber = contentText
//			}
//		})
//	} else {
//		botDiv := document.Find("div.detail-lists.clear-fix")
//		botDiv.Find("li").Each(func(i int, li *goquery.Selection) {
//			spanText := strings.TrimSpace(li.Find("span").Text())
//			spanText = strings.TrimSpace(spanText)
//			if strings.Contains(li.Text(), "作者") {
//				book.Author = cleanString(li.Text())
//				book.Author = strings.ReplaceAll(book.Author, "作者:", "")
//				book.Author = strings.ReplaceAll(book.Author, "著", "")
//			}
//			if strings.Contains(li.Text(), "出版社") {
//				book.Publisher = spanText
//			}
//			if strings.Contains(li.Text(), "出版时间") {
//				book.PublicationTime = validateDateFormat(spanText)
//			}
//			if strings.Contains(li.Text(), "ISBN") {
//				book.ISBN = spanText
//			}
//			if strings.Contains(li.Text(), "装帧") {
//				book.BindingLayout = spanText
//			}
//			if strings.Contains(li.Text(), "开本") {
//				book.Format = spanText
//			}
//			if strings.Contains(li.Text(), "纸张") {
//				book.Paper = spanText
//			}
//			if strings.Contains(li.Text(), "版次") {
//				book.Edition = spanText
//			}
//			if strings.Contains(li.Text(), "页数") {
//				book.Pages = spanText
//			}
//			if strings.Contains(li.Text(), "字数") {
//				book.Wordage = spanText
//			}
//		})
//	}
//
//	//图片
//	var imgUrls []string
//	tpUl := document.Find("ul.lg-list")
//	tpUl.Find("img").Each(func(i int, s *goquery.Selection) {
//		dataImgUrl, exists := s.Attr("data-imgurl")
//		if exists && dataImgUrl != "" {
//			imgUrls = append(imgUrls, dataImgUrl)
//		}
//	})
//	book.BookPicS = strings.Join(imgUrls, ",")
//	// 售价
//	price := document.Find("i.now-price-text").Text()
//	priceN := regexp.MustCompile(`(\d+\.?\d*)`)
//	if match := priceN.FindStringSubmatch(price); len(match) > 0 {
//		book.SellingPrice = match[1]
//	}
//	// 定价价
//	fixPrice := document.Find("span.origin-price-text.clearfix").Text()
//	fixPriceN := regexp.MustCompile(`(\d+\.?\d*)`)
//	if match := fixPriceN.FindStringSubmatch(fixPrice); len(match) > 0 {
//		book.FixPrice = match[1]
//	}
//	// 品相
//	text := document.Find("span.quality-text-cot.clearfix i").Text()
//	book.Condition = strings.TrimSpace(text)
//	// 快递费
//	if fee != "" {
//		if fee == "包邮" {
//			book.ExpressDeliveryFee = "0"
//		} else {
//			book.ExpressDeliveryFee = fee
//		}
//	}
//	books = append(books, book)
//	return books, nil
//}
//
//// 获取店铺页面的所有快递费用
//func FetchProductInfoWithChromedp(url string) (*ProductResponse, error) {
//	// 创建上下文
//	opts := append(chromedp.DefaultExecAllocatorOptions[:],
//		chromedp.Flag("headless", true),
//		chromedp.Flag("disable-gpu", true),
//		chromedp.Flag("no-sandbox", true),
//		chromedp.Flag("disable-dev-shm-usage", true),
//		chromedp.UserAgent("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"),
//		// 禁用图片加载，加快速度
//		chromedp.Flag("blink-settings", "imagesEnabled=false"),
//	)
//	// 启动浏览器
//	allocCtx, cancel := chromedp.NewExecAllocator(context.Background(), opts...)
//	defer cancel()
//	// 创建浏览器上下文
//	ctx, cancel := chromedp.NewContext(allocCtx)
//	defer cancel()
//	// 设置超时
//	ctx, cancel = context.WithTimeout(ctx, 60*time.Second)
//	defer cancel()
//	log.Printf("[CHROMEDP] 开始导航到URL: %s", url)
//	// 第一步：先导航到页面并等待完全加载
//	err := chromedp.Run(ctx,
//		// 导航到目标页面
//		chromedp.Navigate(url),
//
//		// 等待页面初步加载
//		chromedp.WaitReady("body", chromedp.ByQuery),
//		chromedp.Sleep(3*time.Second),
//
//		// 第二步：刷新页面，重新加载动态内容
//		chromedp.Reload(),
//
//		// 等待刷新后页面加载
//		chromedp.WaitReady("body", chromedp.ByQuery),
//		chromedp.Sleep(5*time.Second),
//
//		// 等待关键元素出现
//		chromedp.WaitVisible(".item.clearfix", chromedp.ByQuery),
//
//		// 滚动页面以触发动态加载
//		chromedp.Evaluate(`window.scrollTo(0, document.body.scrollHeight / 3)`, nil),
//		chromedp.Sleep(2*time.Second),
//		chromedp.Evaluate(`window.scrollTo(0, document.body.scrollHeight / 2)`, nil),
//		chromedp.Sleep(2*time.Second),
//		chromedp.Evaluate(`window.scrollTo(0, document.body.scrollHeight)`, nil),
//		chromedp.Sleep(3*time.Second),
//		chromedp.Evaluate(`window.scrollTo(0, 0)`, nil),
//		chromedp.Sleep(1*time.Second),
//	)
//	if err != nil {
//		log.Printf("[CHROMEDP] 页面导航失败: %v", err)
//		return nil, fmt.Errorf("页面导航失败: %v", err)
//	}
//	log.Printf("[CHROMEDP] 页面导航完成，开始提取数据")
//	var evalResult map[string]interface{}
//	// 执行任务
//	err = chromedp.Run(ctx,
//		// 导航到目标页面
//		chromedp.Navigate(url),
//
//		// 执行 JavaScript 来提取商品信息
//		chromedp.Evaluate(`(function() {
//			console.log("开始提取商品信息...");
//			try {
//				let productData = [];
//				// 查找所有商品项 - 针对孔夫子旧书网的特定选择器
//				const itemSelectors = [
//					'.item.clearfix',
//					'.list-item',
//					'.product-item',
//					'.goods-item',
//					'[class*="item"]'
//				];
//				let items = [];
//				for (let selector of itemSelectors) {
//					const found = document.querySelectorAll(selector);
//					if (found.length > 0) {
//						items = found;
//						console.log("使用选择器:", selector, "找到项目数:", items.length);
//						break;
//					}
//				}
//
//				if (items.length === 0) {
//					// 如果没有找到特定选择器，尝试查找任何看起来像商品的项目
//					items = document.querySelectorAll('div[class*="item"], li[class*="item"]');
//					console.log("使用通用选择器找到项目数:", items.length);
//				}
//				console.log("总共找到商品项:", items.length);
//				// 遍历每个商品项
//				items.forEach((item, index) => {
//					// 提取 itemid
//					let itemId = '';
//
//					// 方法1: 从元素属性获取
//					if (item.hasAttribute('itemid')) {
//						itemId = item.getAttribute('itemid');
//					}
//
//					// 方法2: 从数据属性获取
//					if (!itemId && item.hasAttribute('data-itemid')) {
//						itemId = item.getAttribute('data-itemid');
//					}
//
//					// 方法3: 从ID属性获取
//					if (!itemId && item.hasAttribute('id')) {
//						const id = item.getAttribute('id');
//						if (id.includes('item') || id.includes('product')) {
//							itemId = id;
//						}
//					}
//
//					// 方法4: 从链接中提取itemid
//					if (!itemId) {
//						const links = item.querySelectorAll('a[href*="item"], a[href*="product"]');
//						for (let link of links) {
//							const href = link.getAttribute('href');
//							if (href) {
//								const itemMatch = href.match(/(?:item|product)[_-]?(\d+)/i);
//								if (itemMatch) {
//									itemId = itemMatch[1];
//									break;
//								}
//							}
//						}
//					}
//
//					// 方法5: 从子元素中查找itemid
//					if (!itemId) {
//						const childWithItemId = item.querySelector('[itemid], [data-itemid]');
//						if (childWithItemId) {
//							if (childWithItemId.hasAttribute('itemid')) {
//								itemId = childWithItemId.getAttribute('itemid');
//							} else if (childWithItemId.hasAttribute('data-itemid')) {
//								itemId = childWithItemId.getAttribute('data-itemid');
//							}
//						}
//					}
//
//					// 提取书名
//					let bookName = '';
//					const titleSelectors = [
//						'.title a',
//						'.book-title',
//						'.item-title',
//						'.name a',
//						'h3 a',
//						'h4 a',
//						'.link',
//						'a[title]'
//					];
//
//					for (let selector of titleSelectors) {
//						const titleEl = item.querySelector(selector);
//						if (titleEl) {
//							bookName = titleEl.textContent.trim();
//							if (bookName && bookName.length > 1) {
//								break;
//							}
//						}
//					}
//
//					// 如果没找到，尝试在item内查找任何文本作为书名
//					if (!bookName) {
//						const textContent = item.textContent;
//						// 尝试提取看起来像书名的文本（较长的文本块）
//						const lines = textContent.split('\n').map(line => line.trim()).filter(line => line.length > 5);
//						if (lines.length > 0) {
//							bookName = lines[0];
//						}
//					}
//
//					// 提取价格
//					let price = '';
//					const priceSelectors = [
//						'.price span',
//						'.price .bold',
//						'.current-price',
//						'.sell-price',
//						'.cost',
//						'.money',
//						'[class*="price"]',
//						'strong'
//					];
//
//					for (let selector of priceSelectors) {
//						const priceEl = item.querySelector(selector);
//						if (priceEl) {
//							let priceText = priceEl.textContent.trim();
//							// 清理价格文本，保留数字和小数点
//							priceText = priceText.replace(/[^\d\.]/g, '');
//							if (priceText && !isNaN(parseFloat(priceText))) {
//								price = '¥' + priceText;
//								break;
//							}
//						}
//					}
//
//					// 如果没找到价格，尝试在文本中查找价格模式
//					if (!price) {
//						const itemText = item.textContent;
//						const priceMatch = itemText.match(/[¥￥]?\s*(\d+\.?\d*)/);
//						if (priceMatch) {
//							price = '¥' + priceMatch[1];
//						}
//					}
//
//					// 提取快递费用
//					let shippingFee = '';
//					const shippingSelectors = [
//						'.ship-fee',
//						'.shipping-fee',
//						'.express-fee',
//						'.freight',
//						'.postage',
//						'[class*="fee"]',
//						'[class*="快递"]',
//						'[class*="运费"]'
//					];
//
//					for (let selector of shippingSelectors) {
//						const shippingEl = item.querySelector(selector);
//						if (shippingEl) {
//							shippingFee = shippingEl.textContent.trim();
//							if (shippingFee) break;
//						}
//					}
//
//					// 如果没找到运费元素，尝试在文本中查找运费关键词
//					if (!shippingFee) {
//						const itemText = item.textContent;
//						const feeMatches = itemText.match(/(运费[：:]\s*[^\s\n]+)|(快递[：:]\s*[^\s\n]+)|(邮费[：:]\s*[^\s\n]+)/);
//						if (feeMatches) {
//							shippingFee = feeMatches[0];
//						} else if (itemText.includes('包邮') || itemText.includes('免运费')) {
//							shippingFee = '包邮';
//						} else {
//							shippingFee = '运费待确认';
//						}
//					}
//
//					// 清理书名（移除过长的文本）
//					if (bookName && bookName.length > 100) {
//						bookName = bookName.substring(0, 100) + '...';
//					}
//
//					// 如果还没有itemid，生成一个基于索引的ID
//					if (!itemId) {
//						itemId = 'item_' + (index + 1);
//					}
//
//					// 添加到数据中
//					productData.push({
//						itemId: itemId,
//						bookName: bookName || '商品${index + 1}',
//						price: price || '价格待确认',
//						shippingFee: shippingFee
//					});
//				});
//
//				// 过滤掉明显无效的数据
//				productData = productData.filter(item =>
//					(item.bookName !== '商品1' || item.price !== '价格待确认') &&
//					item.bookName && item.bookName.length > 0
//				);
//
//				console.log("处理后商品数量:", productData.length);
//				if (productData.length > 0) {
//					console.log("前3个商品示例:", productData.slice(0, 3));
//				}
//
//				return {
//					success: true,
//					message: "成功提取商品信息",
//					data: productData
//				};
//
//			} catch(error) {
//				console.error("提取商品信息时出错:", error);
//				return {
//					success: false,
//					message: "提取商品信息时出错: " + error.message,
//					data: []
//				};
//			}
//		})()`, &evalResult),
//	)
//
//	if err != nil {
//		return nil, fmt.Errorf("chromedp执行失败: %v", err)
//	}
//
//	// 处理 JavaScript 执行结果
//	response := &ProductResponse{}
//
//	// 转换结果数据
//	if success, ok := evalResult["success"].(bool); ok {
//		response.Success = success
//	}
//	if message, ok := evalResult["message"].(string); ok {
//		response.Message = message
//	}
//	if data, ok := evalResult["data"].([]interface{}); ok {
//		for _, item := range data {
//			if productMap, ok := item.(map[string]interface{}); ok {
//				product := ProductInfo{}
//				if itemId, ok := productMap["itemId"].(string); ok {
//					product.ItemID = itemId
//				}
//				if bookName, ok := productMap["bookName"].(string); ok {
//					product.BookName = bookName
//				}
//				if price, ok := productMap["price"].(string); ok {
//					product.Price = price
//				}
//				if shippingFee, ok := productMap["shippingFee"].(string); ok {
//					info := extractShippingInfo(shippingFee)
//					product.ShippingFee = info
//				}
//				response.Data = append(response.Data, product)
//			}
//		}
//	}
//
//	return response, nil
//}
//
//// 获取详情页的快递费用
//func FetchBookDetailsShippingFee(url string) (string, error) {
//	// 创建上下文
//	opts := append(chromedp.DefaultExecAllocatorOptions[:],
//		chromedp.Flag("headless", true),
//		chromedp.Flag("disable-gpu", true),
//		chromedp.Flag("no-sandbox", true),
//		chromedp.Flag("disable-dev-shm-usage", true),
//		chromedp.UserAgent("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"),
//		// 禁用图片加载，加快速度
//		chromedp.Flag("blink-settings", "imagesEnabled=false"),
//	)
//	// 启动浏览器
//	allocCtx, cancel := chromedp.NewExecAllocator(context.Background(), opts...)
//	defer cancel()
//	// 创建浏览器上下文
//	ctx, cancel := chromedp.NewContext(allocCtx)
//	defer cancel()
//	// 设置超时
//	ctx, cancel = context.WithTimeout(ctx, 60*time.Second)
//	defer cancel()
//	log.Printf("[CHROMEDP] 开始导航到URL: %s", url)
//	var result string
//
//	// 增强的 JavaScript 脚本
//	enhancedJSScript := `
//		(function() {
//			// 查找包含快递费用的元素
//			const elements = document.querySelectorAll('*');
//			let shippingFee = null;
//
//			elements.forEach(element => {
//				if (element.textContent.includes('快递￥')) {
//					const match = element.textContent.match(/快递￥(\d+\.\d{2})/);
//					if (match) {
//						shippingFee = match[1];
//						console.log('找到快递费用: ￥' + shippingFee);
//					}
//				}
//				// 匹配格式2: 快递：包邮
//				else if (element.textContent.includes('快递：包邮') || element.textContent.includes('快递:包邮')) {
//					shippingFee = '包邮';
//					console.log('找到快递费用: 包邮');
//				}
//				// 匹配格式3: 快递 包邮 (包含空格变体)
//				else if (element.textContent.match(/快递[：:\s]包邮/)) {
//					shippingFee = '包邮';
//					console.log('找到快递费用: 包邮');
//				}
//			});
//
//			if (!shippingFee) {
//				// 如果没找到，尝试搜索整个页面
//				const pageText = document.body.innerText;
//				const match = pageText.match(/快递￥(\d+\.\d{2})/);
//				if (match) {
//					shippingFee = match[1];
//					console.log('找到快递费用: ￥' + shippingFee);
//				}
//				// 尝试匹配包邮
//				else if (pageText.match(/快递[：:\s]包邮/)) {
//					shippingFee = '包邮';
//					console.log('找到快递费用: 包邮');
//				}
//				// 尝试其他包邮表述
//				else if (pageText.includes('包邮') && pageText.includes('快递')) {
//					shippingFee = '包邮';
//					console.log('找到快递费用: 包邮');
//				}
//				else {
//					console.log('未找到快递费用信息');
//				}
//			}
//			return shippingFee;
//		})();`
//	// 先导航到页面并等待完全加载
//	err := chromedp.Run(ctx,
//		// 导航到目标页面
//		chromedp.Navigate(url),
//		// 刷新页面，重新加载动态内容
//		chromedp.Reload(),
//		// 等待刷新后页面加载
//		chromedp.WaitReady("body", chromedp.ByQuery),
//		chromedp.Sleep(8*time.Second),
//		// 执行 JavaScript 来提取商品信息
//		chromedp.Evaluate(enhancedJSScript, &result),
//	)
//	if err != nil {
//		log.Printf("[CHROMEDP] 页面导航失败: %v", err)
//		return "", fmt.Errorf("页面导航失败: %v", err)
//	}
//	log.Printf("[CHROMEDP] 页面导航完成，开始提取数据")
//
//	if err != nil {
//		return "", fmt.Errorf("chromedp执行失败: %v", err)
//	}
//	return result, nil
//}
//
//// 获取孔网实拍图(查询商品列表)
//func getKFZSPTImageURL(proxyType, username, password, machineCode, isbn string) (*BookInfo, error) {
//	url := fmt.Sprintf("%s?dataType=0&keyword=%s&page=1&size=%d&sortType=7&actionPath=quality,sortType&quality=85~&quaSelect=2&userArea=13003000000", cf.API.ProductSearchURL, isbn, cf.App.Size)
//
//	req := XxProxyRequest(proxyType, username, password, machineCode).
//		Get(url).
//		Set("User-Agent", cf.App.DefaultUserAgent).
//		Set("Accept", "*/*")
//	resp, body, errs := req.End()
//	log.Printf("[DEBUG] 获取图书列表 URL: %s", url)
//
//	// 只在有响应内容时才打印，避免日志过长
//	if len(body) > 0 && len(body) < 500 {
//		log.Printf("[DEBUG] 获取图书列表响应: %s", body)
//	} else if len(body) > 0 {
//		log.Printf("[DEBUG] 获取图书列表响应长度: %d 字符", len(body))
//	} else {
//		log.Printf("[DEBUG] 获取图书列表响应为空")
//	}
//
//	// 处理请求错误
//	if len(errs) > 0 {
//		// 检查是否是代理认证失败
//		var proxyAuthFailed bool
//		for _, e := range errs {
//			if strings.Contains(e.Error(), "Proxy Authentication Required") {
//				proxyAuthFailed = true
//				break
//			}
//		}
//		if proxyAuthFailed {
//			return nil, fmt.Errorf("代理认证失败")
//		}
//		return nil, fmt.Errorf("查询请求失败: %v", errs)
//	}
//
//	// 检查HTTP状态码
//	if resp.StatusCode != http.StatusOK {
//		space := strings.TrimSpace(resp.Status)
//		return nil, fmt.Errorf("HTTP错误: %s", space)
//	}
//
//	// 解析响应
//	var apiResp struct {
//		Status     int    `json:"status"`
//		ErrType    string `json:"errType"`
//		Message    string `json:"message"`
//		SystemTime int64  `json:"systemTime"`
//		Data       struct {
//			ItemResponse struct {
//				Total int `json:"total"`
//				List  []struct {
//					Title      string `json:"title"`
//					ImgUrl     string `json:"imgUrl"`
//					ImgBigUrl  string `json:"imgBigUrl"`
//					ItemId     int64  `json:"itemId"`
//					ShopId     int64  `json:"shopId"`
//					TplRecords []struct {
//						Key   string `json:"key"`
//						Value string `json:"value"`
//					} `json:"tplRecords"`
//				} `json:"list"`
//			} `json:"itemResponse"`
//		} `json:"data"`
//	}
//
//	if err := json.Unmarshal([]byte(body), &apiResp); err != nil {
//		return nil, fmt.Errorf("解析JSON失败: %w", err)
//	}
//
//	// 如果找到商品，返回图片URL
//	if apiResp.Data.ItemResponse.Total > 0 && len(apiResp.Data.ItemResponse.List) > 0 {
//		// 确定起始索引
//		var startIndex int
//		if cf.App.Size >= apiResp.Data.ItemResponse.Total {
//			startIndex = apiResp.Data.ItemResponse.Total - 1
//		} else {
//			startIndex = cf.App.Size - 1
//		}
//
//		// 从指定索引开始，向前查找有效图片，最多重试3次
//		for attempt := 0; attempt < 3; attempt++ {
//			currentIndex := startIndex - attempt
//
//			// 检查索引是否有效
//			if currentIndex < 0 || currentIndex >= len(apiResp.Data.ItemResponse.List) {
//				log.Printf("[DEBUG] 索引 %d 超出范围，跳过", currentIndex)
//				continue
//			}
//
//			item := apiResp.Data.ItemResponse.List[currentIndex]
//
//			// 检查图片URL是否存在
//			if item.ImgBigUrl == "" {
//				log.Printf("[DEBUG] 索引 %d 的图片URL为空，跳过", currentIndex)
//				continue
//			}
//
//			info := &BookInfo{}
//			info.BookName = item.Title
//			info.BookPicS = item.ImgUrl
//			info.ItemId = item.ItemId
//			info.ShopId = item.ShopId
//
//			// 安全地获取TplRecords中的值
//			if len(item.TplRecords) > 0 {
//				info.Author = item.TplRecords[0].Value
//			}
//			if len(item.TplRecords) > 1 {
//				info.Publisher = item.TplRecords[1].Value
//			}
//			if len(item.TplRecords) > 2 {
//				info.PublicationTime = validateDateFormat(item.TplRecords[2].Value)
//			}
//			if len(item.TplRecords) > 3 {
//				info.BindingLayout = item.TplRecords[3].Value
//			}
//
//			// 成功时重置代理失败计数器
//			resetProxyFailCount()
//			return info, nil
//		}
//		// 如果所有尝试都失败了，返回错误
//		log.Printf("[WARN] 经过3次尝试，未找到有效图片")
//		return nil, fmt.Errorf("未找到有效图片，已尝试3次")
//	}
//	return nil, nil
//}
//
//// 获取孔网官图(查询图书条目)
//func getKFZGTImageURL(proxyType, username, password, machineCode, isbn string) (*BookInfo, error) {
//	url := fmt.Sprintf("%s?keyword=%s", cf.API.BookSearchURL, isbn)
//
//	info := &BookInfo{}
//
//	req := XxProxyRequest(proxyType, username, password, machineCode).
//		Get(url).
//		Set("User-Agent", cf.App.DefaultUserAgent).
//		Set("Accept", "*/*")
//	resp, body, errs := req.End()
//	log.Printf("[DEBUG] 获取图书条目 URL: %s", url)
//
//	// 只在有响应内容时才打印，避免日志过长
//	if len(body) > 0 && len(body) < 500 {
//		log.Printf("[DEBUG] 获取图书条目响应: %s", body)
//	} else if len(body) > 0 {
//		log.Printf("[DEBUG] 获取图书条目响应长度: %d 字符", len(body))
//	} else {
//		log.Printf("[DEBUG] 获取图书条目响应为空")
//	}
//
//	// 处理请求错误
//	if len(errs) > 0 {
//		// 检查是否是代理相关错误
//		var isProxyError bool
//		var errorDetails []string
//		for _, e := range errs {
//			errorStr := e.Error()
//			errorDetails = append(errorDetails, errorStr)
//			if strings.Contains(errorStr, "Proxy Authentication Required") ||
//				strings.Contains(errorStr, "connectex: A connection attempt failed") ||
//				strings.Contains(errorStr, "connectex: No connection could be made") ||
//				strings.Contains(errorStr, "proxyconnect tcp") ||
//				strings.Contains(errorStr, "timeout") ||
//				strings.Contains(errorStr, "connection refused") {
//				isProxyError = true
//			}
//		}
//
//		log.Printf("[ERROR] 请求错误详情: %v", errorDetails)
//
//		if isProxyError {
//			// 处理代理失败
//			return nil, fmt.Errorf("代理连接失败")
//		}
//
//		return nil, fmt.Errorf("查询请求失败: %v", errs)
//	}
//
//	//检查HTTP状态码
//	if resp.StatusCode != http.StatusOK {
//		space := strings.TrimSpace(resp.Status)
//		return nil, fmt.Errorf("HTTP错误: %s", space)
//	}
//
//	// 解析响应
//	var apiResp struct {
//		Status     int    `json:"status"`
//		ErrType    string `json:"errType"`
//		Message    string `json:"message"`
//		SystemTime int64  `json:"systemTime"`
//		Data       struct {
//			ItemResponse struct {
//				Total int `json:"total"`
//				List  []struct {
//					BookName     string `json:"bookName"`
//					Mid          int64  `json:"mid"`
//					ImgUrlEntity struct {
//						BigImgUrl string `json:"bigImgUrl"`
//					} `json:"imgUrlEntity"`
//					BookShowInfo []string `json:"bookShowInfo"`
//				} `json:"list"`
//			} `json:"itemResponse"`
//		} `json:"data"`
//	}
//
//	if err := json.Unmarshal([]byte(body), &apiResp); err != nil {
//		return nil, fmt.Errorf("解析JSON失败: %w", err)
//	}
//
//	// 如果找到条目，返回图片URL
//	if apiResp.Data.ItemResponse.Total > 0 && len(apiResp.Data.ItemResponse.List) > 0 {
//		list := apiResp.Data.ItemResponse.List[0]
//		info := list.BookShowInfo
//
//		bookItem := &BookInfo{
//			BookName: list.BookName,
//			BookPic:  list.ImgUrlEntity.BigImgUrl,
//			Mid:      list.Mid,
//		}
//
//		// 根据长度安全填充字段
//		if len(info) > 0 {
//			bookItem.Author = info[0]
//		}
//		if len(info) > 1 {
//			bookItem.Publisher = info[1]
//		}
//		if len(info) > 2 {
//			bookItem.PublicationTime = validateDateFormat(info[2])
//		}
//		if len(info) > 3 {
//			bookItem.BindingLayout = info[3]
//		}
//		if len(info) > 4 {
//			bookItem.FixPrice = info[4]
//		} else {
//			log.Printf("[WARN] BookShowInfo 长度不足 (仅 %d 项): %v", len(info), info)
//		}
//
//		fmt.Println("bookItem: ", bookItem)
//		return bookItem, nil
//	}
//
//	return info, nil
//}
//
//// 替换所有空白字符为空格
//func cleanString(s string) string {
//	s = strings.ReplaceAll(s, "\n", "")
//	s = strings.ReplaceAll(s, "\r", "")
//	s = strings.ReplaceAll(s, "\t", "")
//	s = strings.ReplaceAll(s, " ", "")
//	return removeDuplicates(s)
//}
//
//// 字符串去重
//func removeDuplicates(s string) string {
//	seen := make(map[rune]bool)
//	var result strings.Builder
//	for _, r := range s {
//		if !seen[r] {
//			seen[r] = true
//			result.WriteRune(r)
//		}
//	}
//	return result.String()
//}
//
//// 检测快递费用格式
//func extractShippingInfo(shippingFee string) string {
//	// 匹配 "快递￥数字" 格式
//	re1 := regexp.MustCompile(`快递￥(\d+\.?\d*)`)
//	// 匹配 "包邮" 格式
//	re2 := regexp.MustCompile(`(包邮)`)
//
//	if matches := re1.FindStringSubmatch(shippingFee); len(matches) > 1 {
//		return matches[1] // 返回数字部分
//	}
//
//	if matches := re2.FindStringSubmatch(shippingFee); len(matches) > 1 {
//		return "0" // 返回"包邮"
//	}
//
//	return ""
//}
//
//// 改进字段
//func extractNormalDetails(s *goquery.Selection, fieldName string) string {
//	var info string
//	s.Each(func(i int, selection *goquery.Selection) {
//		if strings.Contains(selection.Text(), fieldName) {
//			all := strings.ReplaceAll(selection.Text(), "&nbsp;", "")
//			all = strings.ReplaceAll(all, "\n", "")
//			all = strings.ReplaceAll(all, " ", "")
//			split := strings.SplitN(all, ":", 2)
//			if len(split) > 1 {
//				info = split[1]
//			} else {
//				return
//			}
//		}
//	})
//	return info
//}
//
//// 改进的字段提取函数
//func extractNormalText(s *goquery.Selection, fieldName string) string {
//	// 在左右两个分区中查找
//	selectors := []string{"div.f_left", "div.f_right"}
//	for _, selector := range selectors {
//		fieldItem := s.Find(selector + " div.normal-item").FilterFunction(func(i int, sel *goquery.Selection) bool {
//			title := sel.Find("span.normal-title").Text()
//			return strings.Contains(title, fieldName)
//		})
//
//		if fieldItem.Length() > 0 {
//			text := fieldItem.Find("span.normal-text").Text()
//			return strings.TrimSpace(text)
//		}
//	}
//	return ""
//}
//
//// 重置代理失败计数器（成功时调用）
//func resetProxyFailCount() {
//	tailProxyMu.Lock()
//	defer tailProxyMu.Unlock()
//	proxyFailCount = 0
//}
//
//// 验证日期格式
//func validateDateFormat(dateStr string) int64 {
//	// 去除前后空格
//	dateStr = strings.TrimSpace(dateStr)
//
//	// 替换各种分隔符为统一的分隔符"-"
//	dateStr = regexp.MustCompile(`[/_\\.,\s]+`).ReplaceAllString(dateStr, "-")
//
//	// 处理纯年份格式 (4位数字)
//	if regexp.MustCompile(`^\d{4}$`).MatchString(dateStr) {
//		dateStr += "-01-01"
//	}
//
//	// 处理年月格式 (4位数字-1或2位数字)
//	if matches := regexp.MustCompile(`^(\d{4})-(\d{1,2})$`).FindStringSubmatch(dateStr); len(matches) == 3 {
//		year := matches[1]
//		month := matches[2]
//		if len(month) == 1 {
//			month = "0" + month
//		}
//		if monthNum, _ := strconv.Atoi(month); monthNum >= 1 && monthNum <= 12 {
//			dateStr = year + "-" + month + "-01"
//		} else {
//			return 0
//		}
//	}
//
//	// 处理年月日格式 (4位数字-1或2位数字-1或2位数字)
//	if matches := regexp.MustCompile(`^(\d{4})-(\d{1,2})-(\d{1,2})`).FindStringSubmatch(dateStr); len(matches) >= 4 {
//		year := matches[1]
//		month := matches[2]
//		day := matches[3]
//
//		// 标准化月份和日期为两位数
//		if len(month) == 1 {
//			month = "0" + month
//		}
//		if len(day) == 1 {
//			day = "0" + day
//		}
//
//		dateStr = year + "-" + month + "-" + day
//	}
//
//	// 加载上海时区
//	loc, err := time.LoadLocation("Asia/Shanghai")
//	if err != nil {
//		// 如果加载时区失败，使用UTC+8作为后备方案
//		loc = time.FixedZone("CST", 8*60*60)
//	}
//
//	// 尝试解析为标准日期格式，并指定上海时区
//	parsedTime, err := time.ParseInLocation("2006-01-02", dateStr, loc)
//	if err != nil {
//		return 0
//	}
//
//	// 返回秒级时间戳（UTC时间，但解析时已经考虑了时区偏移）
//	return parsedTime.Unix()
//}
//
//// 代理请求(小象代理)
//func XxProxyRequest(proxyType, username, password, machineCode string) *gorequest.SuperAgent {
//	proxyManagerOnce.Do(func() {
//		log.Printf("[INFO] 初始化代理管理器，DLL路径: %s", cf.Proxy.ProxyFilePath)
//
//		// 检查DLL文件是否存在
//		if _, err := os.Stat(cf.Proxy.ProxyFilePath); os.IsNotExist(err) {
//			// 尝试在可执行文件目录查找
//			exePath, _ := os.Executable()
//			exeDir := filepath.Dir(exePath)
//			dllPath := filepath.Join(exeDir, cf.Proxy.ProxyFilePath)
//
//			if _, err := os.Stat(dllPath); err == nil {
//				cf.Proxy.ProxyFilePath = dllPath
//			} else {
//				proxyManagerInitErr = fmt.Errorf("代理DLL文件不存在: %s (也尝试了: %s)", cf.Proxy.ProxyFilePath, dllPath)
//				return
//			}
//		}
//
//		globalProxyManager, proxyManagerInitErr = NewProxyConfigManager(cf.Proxy.ProxyFilePath)
//		if proxyManagerInitErr != nil {
//			log.Printf("[ERROR] 代理管理器初始化失败: %v", proxyManagerInitErr)
//		} else {
//			log.Printf("[INFO] 代理管理器初始化成功")
//		}
//	})
//	typeManager, err := globalProxyManager.ProxyTypeManager(
//		proxyType,
//		username,
//		password,
//		machineCode,
//	)
//	if err != nil {
//		fmt.Printf("获取代理服务器信息失败: %v", err)
//	}
//	return gorequest.New().Proxy(typeManager).Timeout(120*time.Second).Retry(2, 3*time.Second)
//}
//
//// 初始化
//func initializeConfig(config Config) {
//	// 设置全局配置
//	cf = config
//}
//
////export GetKFZShopBookInfo
//func GetKFZShopBookInfo(fetchMode, proxyType, username, password, machineCode, shopId, isImage, bookNum, pageNum, sortType, sort, priceDown, priceUp *C.char) *C.char {
//	fetchModeStr := C.GoString(fetchMode)
//	proxyTypeStr := C.GoString(proxyType)
//	usernameStr := C.GoString(username)
//	passwordStr := C.GoString(password)
//	machineCodeStr := C.GoString(machineCode)
//	shopIdStr := C.GoString(shopId)
//	isImageStr := C.GoString(isImage)
//	bookNumStr := C.GoString(bookNum)
//	pageNumStr := C.GoString(pageNum)
//	sortTypeStr := C.GoString(sortType)
//	sortStr := C.GoString(sort)
//	priceDownStr := C.GoString(priceDown)
//	priceUpStr := C.GoString(priceUp)
//
//	books, goodsNum, pNum, err := getKFZShopBookInfo(fetchModeStr, proxyTypeStr, usernameStr, passwordStr, machineCodeStr, shopIdStr, isImageStr, bookNumStr, pageNumStr, sortTypeStr, sortStr, priceDownStr, priceUpStr)
//	if err != nil {
//		result := map[string]interface{}{
//			"success": false,
//			"error":   err.Error(),
//		}
//		jsonData, _ := json.Marshal(result)
//		return C.CString(string(jsonData))
//	}
//
//	jsonData, err := json.Marshal(APIResponse{
//		Success:  true,
//		Message:  "查询成功",
//		GoodsNum: goodsNum,
//		PNum:     pNum,
//		Data:     books,
//	})
//	if err != nil {
//		errorResult := map[string]interface{}{
//			"success": false,
//			"error":   err.Error(),
//		}
//		errorJson, _ := json.Marshal(errorResult)
//		return C.CString(string(errorJson))
//	}
//
//	return C.CString(string(jsonData))
//}
//
////export GetUrlBookDetails
//func GetUrlBookDetails(fetchMode, proxyType, username, password, machineCode, url *C.char) *C.char {
//	fetchModeStr := C.GoString(fetchMode)
//	proxyTypeStr := C.GoString(proxyType)
//	usernameStr := C.GoString(username)
//	passwordStr := C.GoString(password)
//	machineCodeStr := C.GoString(machineCode)
//	urlStr := C.GoString(url)
//	books, err := getUrlBookDetails(fetchModeStr, proxyTypeStr, usernameStr, passwordStr, machineCodeStr, urlStr)
//	if err != nil {
//		result := map[string]interface{}{
//			"success": false,
//			"error":   err.Error(),
//		}
//		jsonData, _ := json.Marshal(result)
//		return C.CString(string(jsonData))
//	}
//	jsonData, err := json.Marshal(APIResponse{
//		Success: true,
//		Message: "查询成功",
//		Data:    books,
//	})
//	if err != nil {
//		errorResult := map[string]interface{}{
//			"success": false,
//			"error":   err.Error(),
//		}
//		errorJson, _ := json.Marshal(errorResult)
//		return C.CString(string(errorJson))
//	}
//	return C.CString(string(jsonData))
//}
//
////export GetKFZSPTImageURL
//func GetKFZSPTImageURL(proxyType, username, password, machineCode, isbn *C.char) *C.char {
//	proxyTypeStr := C.GoString(proxyType)
//	usernameStr := C.GoString(username)
//	passwordStr := C.GoString(password)
//	machineCodeStr := C.GoString(machineCode)
//	isbnStr := C.GoString(isbn)
//
//	bookInfo, err := getKFZSPTImageURL(proxyTypeStr, usernameStr, passwordStr, machineCodeStr, isbnStr)
//	if err != nil {
//		result := map[string]interface{}{
//			"success": false,
//			"error":   err.Error(),
//		}
//		jsonData, _ := json.Marshal(result)
//		return C.CString(string(jsonData))
//	}
//
//	result := map[string]interface{}{
//		"success":  true,
//		"bookInfo": bookInfo,
//	}
//	jsonData, err := json.Marshal(result)
//	if err != nil {
//		errorResult := map[string]interface{}{
//			"success": false,
//			"error":   err.Error(),
//		}
//		errorJson, _ := json.Marshal(errorResult)
//		return C.CString(string(errorJson))
//	}
//	return C.CString(string(jsonData))
//}
//
////export GetKFZGTImageURL
//func GetKFZGTImageURL(proxyType, username, password, machineCode, isbn *C.char) *C.char {
//	proxyTypeStr := C.GoString(proxyType)
//	usernameStr := C.GoString(username)
//	passwordStr := C.GoString(password)
//	machineCodeStr := C.GoString(machineCode)
//	isbnStr := C.GoString(isbn)
//
//	bookInfo, err := getKFZGTImageURL(proxyTypeStr, usernameStr, passwordStr, machineCodeStr, isbnStr)
//	if err != nil {
//		result := map[string]interface{}{
//			"success": false,
//			"error":   err.Error(),
//		}
//		jsonData, _ := json.Marshal(result)
//		return C.CString(string(jsonData))
//	}
//
//	result := map[string]interface{}{
//		"success":  true,
//		"bookInfo": bookInfo,
//	}
//	jsonData, err := json.Marshal(result)
//	if err != nil {
//		errorResult := map[string]interface{}{
//			"success": false,
//			"error":   err.Error(),
//		}
//		errorJson, _ := json.Marshal(errorResult)
//		return C.CString(string(errorJson))
//	}
//
//	return C.CString(string(jsonData))
//}
//
////export Initialize
//func Initialize(configJSON *C.char) *C.char {
//	configStr := C.GoString(configJSON)
//	log.Printf("[DEBUG] 接收到的配置JSON: %s", configStr)
//
//	var config Config
//	if err := json.Unmarshal([]byte(configStr), &config); err != nil {
//		return C.CString(fmt.Sprintf(`{"success":false,"message":"配置解析失败: %v"}`, err))
//	}
//	initializeConfig(config)
//
//	return C.CString(`{"success":true,"message":"初始化成功"}`)
//}
//
//// 导出函数：释放C字符串内存
////
////export FreeCString
//func FreeCString(str *C.char) {
//	C.free(unsafe.Pointer(str))
//}
//
//// 空main函数，编译DLL时需要
//func main() {
//
//}
