package main

///*
//#include <stdlib.h>
//*/
//import "C"
//import (
//	"encoding/csv"
//	"encoding/json"
//	"fmt"
//	"io"
//	"os"
//	"path/filepath"
//	"strings"
//	"sync"
//	"sync/atomic"
//	"time"
//	"unsafe"
//)
//
//// CSVManager CSV全局管理器
//type CSVManager struct {
//	files      sync.Map     // handle -> *CSVFile (并发安全的映射)
//	nextHandle int64        // 生成唯一句柄
//	errorMsg   string       // 全局错误信息
//	mu         sync.RWMutex // 管理器级别的锁
//}
//
//// CSVFile 文件结构
//type CSVFile struct {
//	filename  string // 实际文件路径
//	handle    int64  // 唯一句柄
//	delimiter rune   // 分隔符（如 ','）
//	hasHeader bool   // 是否有标题行
//
//	// 内存数据缓存
//	data     [][]string // 内存中的数据行
//	header   []string   // 标题行（如果有）
//	fileSize int64      // 文件大小
//	modified bool       // 标记是否被修改
//
//	// 并发控制
//	mu       sync.RWMutex    // 文件级锁
//	rowLocks []*sync.RWMutex // 行级锁
//	rowMu    sync.Mutex      // 行锁数组保护
//	readers  int32           // 活跃读取器计数
//	writers  int32           // 活跃写入器计数
//	saving   int32           // 正在保存的goroutine计数
//	saveErr  chan error      // 保存错误通道
//	done     chan struct{}   // 关闭信号
//}
//
//// 单例模式的管理器
//var manager *CSVManager
//var once sync.Once
//
//// newCSVFile 创建新的CSVFile对象
//func newCSVFile(filename string, delimiter rune, hasHeader bool) *CSVFile {
//	return &CSVFile{
//		filename:  filename,
//		delimiter: delimiter,
//		hasHeader: hasHeader,
//		data:      make([][]string, 0),
//		rowLocks:  make([]*sync.RWMutex, 0),
//		saveErr:   make(chan error, 1),
//		done:      make(chan struct{}),
//	}
//}
//
//// getManager 获取全局管理器(单例)
//func getManager() *CSVManager {
//	once.Do(func() {
//		manager = &CSVManager{
//			nextHandle: 1,
//		}
//	})
//	return manager
//}
//
//// setError 设置错误信息
//func setError(err string) {
//	mgr := getManager()
//	mgr.mu.Lock()
//	mgr.errorMsg = err
//	mgr.mu.Unlock()
//}
//
//// 初始化管理器
//func initCSVManager() int64 {
//	_ = getManager()
//	return 0 // 成功
//}
//
//// 打开/创建CSV文件(句柄)
//func openCSVFile(filename string, delimiter rune, hasHeader bool) int64 {
//	// 创建CSV全局管理器
//	mgr := getManager()
//
//	// 先检查文件是否已经打开
//	var existingHandle int64 = -1
//	mgr.files.Range(func(key, value interface{}) bool {
//		file := value.(*CSVFile)
//		// 比较文件路径（使用绝对路径确保一致性）
//		absFilename, _ := filepath.Abs(filename)
//		absExisting, _ := filepath.Abs(file.filename)
//
//		if absFilename == absExisting {
//			fmt.Println("absFilename", absFilename)
//			fmt.Println("absExisting", absExisting)
//			fmt.Println("bool", absFilename == absExisting)
//
//			existingHandle = key.(int64)
//			return false // 停止遍历
//		}
//		return true // 继续遍历
//	})
//
//	// 如果文件已经打开，返回现有句柄
//	if existingHandle != -1 {
//		fmt.Printf("文件已打开，返回现有句柄: %d\n", existingHandle)
//		return existingHandle
//	}
//
//	// 生成句柄
//	handle := atomic.AddInt64(&mgr.nextHandle, 1)
//
//	// 创建文件对象
//	file := newCSVFile(filename, delimiter, hasHeader)
//	file.handle = handle
//
//	// 加载文件数据
//	if err := file.load(); err != nil {
//		setError(err.Error())
//		return -1
//	}
//
//	// 存储到管理器
//	mgr.files.Store(handle, file)
//	return handle
//}
//
//// 读取多行数据
//func readRows(handle int64, startRow, count int64, buffer []byte) int64 {
//	mgr := getManager()
//
//	// 获取文件对象
//	val, ok := mgr.files.Load(handle)
//	if !ok {
//		setError("Invalid file handle")
//		return -1
//	}
//
//	file := val.(*CSVFile)
//	atomic.AddInt32(&file.readers, 1)
//	defer atomic.AddInt32(&file.readers, -1)
//
//	// 获取读取锁
//	file.mu.RLock()
//	defer file.mu.RUnlock()
//
//	totalRows := int64(len(file.data))
//	if startRow < 0 || startRow >= totalRows {
//		return 0
//	}
//
//	// 计算实际读取行数
//	endRow := startRow + count
//	if endRow > totalRows {
//		endRow = totalRows
//	}
//
//	rowsToRead := endRow - startRow
//
//	// 将数据复制到缓冲区
//	bytesWritten := 0
//
//	for i := startRow; i < endRow; i++ {
//		row := file.data[i]
//
//		// 获取行读锁
//		if rowLock := file.getRowLock(int(i)); rowLock != nil {
//			rowLock.RLock()
//		}
//
//		for _, cell := range row {
//			// 写入单元格长度
//			cellLen := len(cell)
//			if bytesWritten+4 > len(buffer) {
//				break
//			}
//
//			// 写入4字节长度
//			buffer[bytesWritten] = byte(cellLen & 0xFF)
//			buffer[bytesWritten+1] = byte((cellLen >> 8) & 0xFF)
//			buffer[bytesWritten+2] = byte((cellLen >> 16) & 0xFF)
//			buffer[bytesWritten+3] = byte((cellLen >> 24) & 0xFF)
//			bytesWritten += 4
//
//			// 写入单元格数据
//			if bytesWritten+cellLen > len(buffer) {
//				// 缓冲区不足，回退长度写入
//				bytesWritten -= 4
//				break
//			}
//
//			copy(buffer[bytesWritten:bytesWritten+cellLen], cell)
//			bytesWritten += cellLen
//		}
//
//		// 写入行结束标记
//		if bytesWritten+4 <= len(buffer) {
//			// 4字节的0表示行结束
//			buffer[bytesWritten] = 0
//			buffer[bytesWritten+1] = 0
//			buffer[bytesWritten+2] = 0
//			buffer[bytesWritten+3] = 0
//			bytesWritten += 4
//		}
//
//		// 释放行锁
//		if rowLock := file.getRowLock(int(i)); rowLock != nil {
//			rowLock.RUnlock()
//		}
//
//		if bytesWritten >= len(buffer) {
//			break
//		}
//	}
//
//	return rowsToRead
//}
//
//// 写入/覆盖行数据
//func writeRows(handle int64, rowData [][]string, header int) int64 {
//	mgr := getManager()
//
//	// 获取文件对象
//	val, ok := mgr.files.Load(handle)
//	if !ok {
//		setError("文件无效句柄！")
//		return -1
//	}
//
//	file := val.(*CSVFile)
//
//	// 获取写入锁
//	file.mu.Lock()
//	defer file.mu.Unlock()
//
//	atomic.AddInt32(&file.writers, 1)
//	defer atomic.AddInt32(&file.writers, -1)
//
//	// 清空现有数据（因为这是覆盖写入）
//	file.data = make([][]string, 0, len(rowData))
//	if header == 0 {
//		file.header = rowData[0]
//		// 添加新数据
//		file.data = rowData[1:]
//	} else {
//		// 添加新数据
//		for _, row := range rowData {
//			file.data = append(file.data, row)
//		}
//	}
//
//	// 扩展行锁数组
//	file.rowMu.Lock()
//	file.rowLocks = make([]*sync.RWMutex, len(file.data))
//	for i := range file.rowLocks {
//		file.rowLocks[i] = &sync.RWMutex{}
//	}
//	file.rowMu.Unlock()
//
//	file.modified = true
//	// 异步保存到文件
//	go file.saveAsync()
//	return int64(len(file.data))
//}
//
//// 加载CSV文件到内存
//func (f *CSVFile) load() error {
//	f.mu.Lock()
//	defer f.mu.Unlock()
//
//	// 打开文件
//	file, err := os.Open(f.filename)
//	if err != nil {
//		// 文件不存在则创建空文件
//		if os.IsNotExist(err) {
//			f.data = make([][]string, 0)          // 初始化空数据
//			f.rowLocks = make([]*sync.RWMutex, 0) // 初始化空行锁数组
//			return nil
//		}
//		return fmt.Errorf("文件不存在: %v", err)
//	}
//	// 确保函数结束时关闭文件
//	defer file.Close()
//
//	// 获取文件大小
//	stat, _ := file.Stat()   // 获取文件信息
//	f.fileSize = stat.Size() // 获取文件大小
//
//	// 创建CSV读取器
//	reader := csv.NewReader(file)
//	reader.Comma = f.delimiter     // 设置分隔符（默认逗号）
//	reader.LazyQuotes = true       // 允许宽松的引号解析
//	reader.TrimLeadingSpace = true // 去除字段前的空格
//
//	// 关键修改：允许变长记录，不强制检查字段数量
//	reader.FieldsPerRecord = -1
//	firstRecord, err := reader.Read()
//	if err != nil {
//		if err == io.EOF {
//			// 空文件
//			f.data = make([][]string, 0)
//			f.rowLocks = make([]*sync.RWMutex, 0)
//			return nil
//		}
//		return err
//	}
//	maxColumns := len(firstRecord)
//	allData := [][]string{firstRecord}
//
//	// 读取剩余行
//	for {
//		record, err := reader.Read()
//		if err == io.EOF {
//			break
//		}
//		if err != nil {
//			// 对于有问题的行，可以填充或跳过
//			continue
//		}
//
//		// 确保所有行都有相同的列数
//		if len(record) < maxColumns {
//			// 填充缺失的列为空字符串
//			paddedRecord := make([]string, maxColumns)
//			copy(paddedRecord, record)
//			for i := len(record); i < maxColumns; i++ {
//				paddedRecord[i] = ""
//			}
//			record = paddedRecord
//		} else if len(record) > maxColumns {
//			// 如果行有更多列，更新最大列数
//			maxColumns = len(record)
//			// 重新处理之前的所有行
//			for i := range allData {
//				if len(allData[i]) < maxColumns {
//					paddedRecord := make([]string, maxColumns)
//					copy(paddedRecord, allData[i])
//					allData[i] = paddedRecord
//				}
//			}
//		}
//
//		allData = append(allData, record)
//	}
//
//	if len(allData) == 0 {
//		f.data = make([][]string, 0)
//		f.rowLocks = make([]*sync.RWMutex, 0)
//		return nil
//	}
//
//	// 处理表头
//	if f.hasHeader && len(allData) > 0 {
//		f.header = allData[0]
//		f.data = allData[1:]
//	} else {
//		f.data = allData
//	}
//
//	// 初始化行锁
//	f.initRowLocks()
//
//	return nil
//}
//
//// initRowLocks 初始化行锁数组
//func (f *CSVFile) initRowLocks() {
//	count := len(f.data)
//	f.rowLocks = make([]*sync.RWMutex, count)
//	for i := 0; i < count; i++ {
//		f.rowLocks[i] = &sync.RWMutex{}
//	}
//}
//
//// getRowLock 获取行锁（线程安全）
//func (f *CSVFile) getRowLock(rowIndex int) *sync.RWMutex {
//	if rowIndex < 0 {
//		return nil
//	}
//
//	f.rowMu.Lock()
//	defer f.rowMu.Unlock()
//
//	// 确保行锁存在
//	if rowIndex >= len(f.rowLocks) {
//		// 扩展行锁数组
//		newLocks := make([]*sync.RWMutex, rowIndex+1)
//		copy(newLocks, f.rowLocks)
//		for i := len(f.rowLocks); i <= rowIndex; i++ {
//			newLocks[i] = &sync.RWMutex{}
//		}
//		f.rowLocks = newLocks
//	}
//
//	return f.rowLocks[rowIndex]
//}
//
//// save 保存到文件
//func (f *CSVFile) save() error {
//	// 标记正在保存
//	if !atomic.CompareAndSwapInt32(&f.saving, 0, 1) {
//		// 已经在保存中，直接返回
//		return nil
//	}
//	defer atomic.StoreInt32(&f.saving, 0)
//
//	// 如果没有修改，直接返回
//	f.mu.RLock()
//	if !f.modified {
//		f.mu.RUnlock()
//		return nil
//	}
//	// 复制数据
//	dataCopy := make([][]string, len(f.data))
//
//	for i := range f.data {
//		dataCopy[i] = make([]string, len(f.data[i]))
//		copy(dataCopy[i], f.data[i])
//	}
//	// 复制表头
//	headerCopy := make([]string, len(f.header))
//	copy(headerCopy, f.header)
//	// 复制配置(值类型，直接赋值)
//	hasHeader := f.hasHeader
//	delimiter := f.delimiter
//	filename := f.filename
//	f.mu.RUnlock() // 释放读锁
//
//	// 创建临时文件(使用不同的扩展名避免冲突)
//	tempFile := filename + ".tmp"
//	file, err := os.Create(tempFile)
//	if err != nil {
//		return err
//	}
//
//	// 创建CSV写入器
//	writer := csv.NewWriter(file)
//	writer.Comma = delimiter
//
//	// 写入数据
//	if hasHeader && len(headerCopy) > 0 {
//		if err := writer.Write(headerCopy); err != nil {
//			file.Close()
//			os.Remove(tempFile)
//			return err
//		}
//	}
//
//	if err := writer.WriteAll(dataCopy); err != nil {
//		file.Close()
//		os.Remove(tempFile)
//		return err
//	}
//
//	writer.Flush()
//	if err := writer.Error(); err != nil {
//		file.Close()
//		os.Remove(tempFile)
//		return err
//	}
//
//	// 关闭文件，确保数据写入磁盘
//	if err := file.Close(); err != nil {
//		os.Remove(tempFile)
//		return err
//	}
//
//	// 尝试重命名，如果失败可能是文件被占用
//	var renameErr error
//	for retry := 0; retry < 3; retry++ {
//		renameErr = os.Rename(tempFile, filename)
//		if renameErr == nil {
//			break
//		}
//		time.Sleep(100 * time.Millisecond) // 等待重试
//	}
//
//	if renameErr != nil {
//		os.Remove(tempFile)
//		return renameErr
//	}
//
//	// 标记为已保存
//	f.mu.Lock()
//	f.modified = false
//	f.mu.Unlock()
//
//	return nil
//}
//
//// saveAsync 异步保存，带错误处理
//func (f *CSVFile) saveAsync() {
//	select {
//	case f.saveErr <- f.save():
//		// 保存完成
//	default:
//		// 通道已满，忽略错误
//	}
//}
//
//// 追加行数据
//func appendRows(handle int64, rowsData []byte, rowCount int64) int {
//	mgr := getManager()
//
//	// 获取文件对象
//	val, ok := mgr.files.Load(handle)
//	if !ok {
//		setError("Invalid file handle")
//		return -1
//	}
//
//	file := val.(*CSVFile)
//
//	// 获取写入锁
//	file.mu.Lock()
//	atomic.AddInt32(&file.writers, 1)
//
//	// 解析行数据
//	offset := 0
//
//	for i := int64(0); i < rowCount; i++ {
//		var row []string
//
//		// 读取行数据
//		for {
//			if offset+4 > len(rowsData) {
//				break
//			}
//
//			cellLen := int(uint32(rowsData[offset]) |
//				uint32(rowsData[offset+1])<<8 |
//				uint32(rowsData[offset+2])<<16 |
//				uint32(rowsData[offset+3])<<24)
//			offset += 4
//
//			if cellLen == 0 {
//				break
//			}
//
//			if offset+cellLen > len(rowsData) {
//				break
//			}
//
//			cell := string(rowsData[offset : offset+cellLen])
//			offset += cellLen
//			row = append(row, cell)
//		}
//
//		// 追加到数据
//		file.data = append(file.data, row)
//	}
//
//	file.modified = true
//
//	atomic.AddInt32(&file.writers, -1)
//	file.mu.Unlock()
//
//	// 异步保存
//	go file.saveAsync()
//
//	// 获取总行数
//	count := getRowCount(handle)
//	fmt.Println("count:", count)
//	return int(count)
//}
//
//// 打开/创建CSV文件(句柄)
//func createOpenCSVFile(filename string, delimiter rune, hasHeader bool) int64 {
//	// 创建CSV全局管理器
//	mgr := getManager()
//
//	// 生成句柄
//	handle := atomic.AddInt64(&mgr.nextHandle, 1)
//
//	// 创建文件对象
//	file := newCSVFile(filename, delimiter, hasHeader)
//	file.handle = handle
//
//	//// 加载文件数据
//	//if err := file.load(); err != nil {
//	//	setError(err.Error())
//	//	return -1
//	//}
//
//	// 存储到管理器
//	mgr.files.Store(handle, file)
//
//	return handle
//}
//
//// updateCSVRowSafe 修改csv文件行数据
//func updateCSVRowSafe(handleID int64, rowNum int, newRow []string) error {
//	mgr := getManager()
//
//	// 获取文件对象
//	val, ok := mgr.files.Load(handleID)
//	if !ok {
//		setError("Invalid file handle")
//		return fmt.Errorf("无效句柄: %d", handleID)
//	}
//	file := val.(*CSVFile)
//
//	// 1. 创建临时文件
//	tempDir := filepath.Dir(file.filename)
//	if tempDir == "" {
//		tempDir = "."
//	}
//
//	tempFile, err := os.CreateTemp(tempDir, "temp_*.csv")
//	if err != nil {
//		return fmt.Errorf("创建临时文件失败: %v", err)
//	}
//	tempFileName := tempFile.Name()
//
//	// 确保临时文件被关闭和清理
//	defer func() {
//		tempFile.Close()
//		// 如果临时文件还存在（替换失败），则清理它
//		if _, err := os.Stat(tempFileName); err == nil {
//			os.Remove(tempFileName)
//		}
//	}()
//
//	// 2. 读取原始文件
//	sourceFile, err := os.Open(file.filename)
//	if err != nil {
//		return fmt.Errorf("打开源文件失败: %v", err)
//	}
//	defer sourceFile.Close()
//
//	// 3. 读取并处理数据
//	reader := csv.NewReader(sourceFile)
//	allRows, err := reader.ReadAll()
//	if err != nil {
//		return fmt.Errorf("读取CSV失败: %v", err)
//	}
//
//	// 4. 验证并更新
//	if rowNum < 1 || rowNum > len(allRows) {
//		return fmt.Errorf("行号 %d 超出范围 (1-%d)", rowNum, len(allRows))
//	}
//
//	// 显示修改前后的对比
//	oldRow := allRows[rowNum-1]
//	fmt.Printf("修改前第 %d 行: %v\n", rowNum, oldRow)
//	fmt.Printf("修改后第 %d 行: %v\n", rowNum, newRow)
//
//	allRows[rowNum-1] = newRow
//
//	// 5. 写入临时文件
//	writer := csv.NewWriter(tempFile)
//	if err := writer.WriteAll(allRows); err != nil {
//		return fmt.Errorf("写入临时文件失败: %v", err)
//	}
//	writer.Flush()
//
//	if err := writer.Error(); err != nil {
//		return fmt.Errorf("刷新写入失败: %v", err)
//	}
//
//	// 6. 确保数据写入磁盘
//	if err := tempFile.Sync(); err != nil {
//		return fmt.Errorf("同步文件失败: %v", err)
//	}
//	tempFile.Close()
//
//	// 7. 使用复制而不是重命名（解决Windows文件占用问题）
//	if err := copyFile(tempFileName, file.filename); err != nil {
//		return fmt.Errorf("复制文件失败: %v", err)
//	}
//
//	fmt.Printf("✅ 成功更新第 %d 行，文件已直接更新\n", rowNum)
//
//	return nil
//}
//
//// copyFile 复制文件内容
//func copyFile(src, dst string) error {
//	// 打开源文件
//	source, err := os.Open(src)
//	if err != nil {
//		return err
//	}
//	defer source.Close()
//
//	// 创建目标文件
//	destination, err := os.Create(dst)
//	if err != nil {
//		return err
//	}
//	defer destination.Close()
//
//	// 复制内容
//	_, err = io.Copy(destination, source)
//	if err != nil {
//		return err
//	}
//
//	// 确保数据写入磁盘
//	err = destination.Sync()
//	if err != nil {
//		return err
//	}
//
//	return nil
//}
//
//// 获取总行数
//func getRowCount(handle int64) int64 {
//	mgr := getManager()
//
//	val, ok := mgr.files.Load(handle)
//	if !ok {
//		setError("Invalid file handle")
//		return -1
//	}
//
//	file := val.(*CSVFile)
//	file.mu.RLock()
//	defer file.mu.RUnlock()
//	if file.header != nil {
//		return int64(len(file.data) + 1)
//	}
//	return int64(len(file.data))
//}
//
//// 搜索行
//func findRows(handle int64, searchText string, columnIndex int64, resultBuffer []byte, maxResults int64) int64 {
//	mgr := getManager()
//
//	val, ok := mgr.files.Load(handle)
//	if !ok {
//		setError("Invalid file handle")
//		return -1
//	}
//
//	file := val.(*CSVFile)
//
//	file.mu.RLock()
//	defer file.mu.RUnlock()
//
//	atomic.AddInt32(&file.readers, 1)
//	defer atomic.AddInt32(&file.readers, -1)
//
//	var foundRows []int64
//
//	// 搜索行
//	for i, row := range file.data {
//		if maxResults > 0 && int64(len(foundRows)) >= maxResults {
//			break
//		}
//
//		// 获取行读锁
//		if rowLock := file.getRowLock(i); rowLock != nil {
//			rowLock.RLock()
//		}
//
//		// 检查列
//		if columnIndex < 0 || columnIndex >= int64(len(row)) {
//			// 搜索所有列
//			for _, cell := range row {
//				if cell == searchText {
//					foundRows = append(foundRows, int64(i))
//					break
//				}
//			}
//		} else if row[columnIndex] == searchText {
//			foundRows = append(foundRows, int64(i))
//		}
//
//		// 释放行锁
//		if rowLock := file.getRowLock(i); rowLock != nil {
//			rowLock.RUnlock()
//		}
//	}
//
//	// 写入结果到缓冲区
//	if resultBuffer != nil && len(foundRows) > 0 {
//		bytesWritten := 0
//
//		for _, rowIndex := range foundRows {
//			if bytesWritten+8 > len(resultBuffer) {
//				break
//			}
//
//			// 写入行索引（8字节）
//			for j := 0; j < 8; j++ {
//				resultBuffer[bytesWritten] = byte((rowIndex >> (uint(j) * 8)) & 0xFF)
//				bytesWritten++
//			}
//		}
//	}
//
//	return int64(len(foundRows))
//}
//
//// 合并多个CSV文件（线程安全）
//func mergeCSVFiles(handles []int64, outputFilename string, delimiter rune, hasHeader bool) int64 {
//	mgr := getManager()
//
//	// 验证所有句柄并获取文件对象
//	files := make([]*CSVFile, 0, len(handles))
//	for _, handle := range handles {
//		val, ok := mgr.files.Load(handle)
//		if !ok {
//			setError("Invalid file handle: " + string(handle))
//			return -1
//		}
//		files = append(files, val.(*CSVFile))
//	}
//
//	// 创建输出文件对象
//	outputFile := newCSVFile(outputFilename, delimiter, hasHeader)
//	outputFile.modified = true // 标记为需要保存
//
//	// 第一步：合并表头
//	mergedHeader := make([]string, 0)
//	headerSet := make(map[string]bool)
//
//	if hasHeader {
//		// 收集所有不重复的表头
//		for _, file := range files {
//			file.mu.RLock()
//			if file.hasHeader && len(file.header) > 0 {
//				for _, h := range file.header {
//					if !headerSet[h] {
//						headerSet[h] = true
//						mergedHeader = append(mergedHeader, h)
//					}
//				}
//			}
//			file.mu.RUnlock()
//		}
//
//		// 如果没有找到表头，创建一个默认的表头
//		if len(mergedHeader) == 0 && len(files) > 0 {
//			files[0].mu.RLock()
//			maxColumns := len(files[0].data[0])
//			files[0].mu.RUnlock()
//
//			for i := 0; i < maxColumns; i++ {
//				mergedHeader = append(mergedHeader, fmt.Sprintf("Column%d", i+1))
//			}
//		}
//	}
//	outputFile.header = mergedHeader
//
//	// 第二步：合并数据
//	mergedData := make([][]string, 0)
//
//	// 为每个输入文件创建读取锁并并发读取
//	var wg sync.WaitGroup
//	dataChan := make(chan [][]string, len(files))
//	errorChan := make(chan error, len(files))
//
//	for idx, file := range files {
//		wg.Add(1)
//		go func(fileIdx int, f *CSVFile) {
//			defer wg.Done()
//
//			// 获取文件的读取锁
//			f.mu.RLock()
//			defer f.mu.RUnlock()
//
//			// 增加活跃读取器计数
//			atomic.AddInt32(&f.readers, 1)
//			defer atomic.AddInt32(&f.readers, -1)
//
//			// 读取数据
//			fileData := make([][]string, len(f.data))
//			for i := 0; i < len(f.data); i++ {
//				// 获取行读锁
//				if rowLock := f.getRowLock(i); rowLock != nil {
//					rowLock.RLock()
//				}
//
//				// 复制行数据
//				row := make([]string, len(f.data[i]))
//				copy(row, f.data[i])
//
//				// 释放行锁
//				if rowLock := f.getRowLock(i); rowLock != nil {
//					rowLock.RUnlock()
//				}
//
//				fileData[i] = row
//			}
//
//			// 如果需要处理表头映射
//			if hasHeader && f.hasHeader && len(f.header) > 0 {
//				// 创建列映射：源列 -> 目标列
//				columnMapping := make(map[int]int)
//				for srcIdx, srcHeader := range f.header {
//					for dstIdx, dstHeader := range mergedHeader {
//						if srcHeader == dstHeader {
//							columnMapping[srcIdx] = dstIdx
//							break
//						}
//					}
//				}
//
//				// 重新排列数据以匹配合并后的表头
//				for i := 0; i < len(fileData); i++ {
//					newRow := make([]string, len(mergedHeader))
//					for srcIdx, dstIdx := range columnMapping {
//						if srcIdx < len(fileData[i]) {
//							newRow[dstIdx] = fileData[i][srcIdx]
//						}
//					}
//					fileData[i] = newRow
//				}
//			} else if hasHeader && len(mergedHeader) > 0 {
//				// 文件没有表头，但输出需要表头
//				// 简单地将数据填充到对应位置
//				for i := 0; i < len(fileData); i++ {
//					newRow := make([]string, len(mergedHeader))
//					for j := 0; j < len(fileData[i]) && j < len(newRow); j++ {
//						newRow[j] = fileData[i][j]
//					}
//					fileData[i] = newRow
//				}
//			}
//
//			// 将处理后的数据发送到通道
//			dataChan <- fileData
//		}(idx, file)
//	}
//
//	// 等待所有goroutine完成
//	go func() {
//		wg.Wait()
//		close(dataChan)
//		close(errorChan)
//	}()
//
//	// 收集所有数据
//	for data := range dataChan {
//		mergedData = append(mergedData, data...)
//	}
//
//	// 检查是否有错误
//	select {
//	case err := <-errorChan:
//		if err != nil {
//			setError("Error merging files: " + err.Error())
//			return -1
//		}
//	default:
//	}
//
//	// 第三步：设置输出文件的数据
//	outputFile.data = mergedData
//	outputFile.initRowLocks()
//
//	// 第四步：保存到文件
//	if err := outputFile.save(); err != nil {
//		setError("Error saving merged file: " + err.Error())
//		return -1
//	}
//
//	// 第五步：将输出文件添加到管理器
//	handle := atomic.AddInt64(&mgr.nextHandle, 1)
//	outputFile.handle = handle
//	mgr.files.Store(handle, outputFile)
//
//	return handle
//}
//
//// 关闭文件
//func closeCSVFile(handle int64) int64 {
//	mgr := getManager()
//
//	val, ok := mgr.files.Load(handle)
//	if !ok {
//		setError("文件句柄无效！")
//		return -1
//	}
//
//	file := val.(*CSVFile)
//
//	// 等待所有读写操作完成
//	for atomic.LoadInt32(&file.readers) > 0 || atomic.LoadInt32(&file.writers) > 0 {
//		time.Sleep(time.Millisecond)
//	}
//
//	// 等待异步保存完成
//	for i := 0; i < 100; i++ { // 最多等待100ms
//		if atomic.LoadInt32(&file.saving) == 0 {
//			break
//		}
//		time.Sleep(time.Millisecond)
//	}
//
//	// 如果有正在进行的保存，等待一小段时间
//	if atomic.LoadInt32(&file.saving) > 0 {
//		time.Sleep(50 * time.Millisecond)
//	}
//
//	// 检查是否需要保存
//	file.mu.RLock()
//	needSave := file.modified
//	file.mu.RUnlock()
//
//	if needSave {
//		// 同步保存修改
//		if err := file.save(); err != nil {
//			setError(err.Error())
//			return -1
//		}
//	}
//
//	// 从管理器移除
//	mgr.files.Delete(handle)
//
//	//// 安全关闭通道（如果存在）
//	//if file.done != nil {
//	//	close(file.done)
//	//}
//
//	return 0
//}
//
//// 获取错误信息
//func getError() string {
//	mgr := getManager()
//	mgr.mu.RLock()
//	defer mgr.mu.RUnlock()
//
//	if mgr.errorMsg == "" {
//		return ""
//	}
//
//	err := mgr.errorMsg
//	mgr.errorMsg = "" // 清空错误
//
//	return err
//}
//
//func parseSimpleTable(goData string) [][]string {
//	lines := strings.Split(strings.TrimSpace(goData), "\n")
//	result := make([][]string, len(lines))
//
//	for i, line := range lines {
//		// 根据你的分隔符分割，这里用逗号举例
//		fields := strings.Split(line, ",")
//		// 如果需要去除每个字段的空格
//		for j := range fields {
//			fields[j] = strings.TrimSpace(fields[j])
//		}
//		result[i] = fields
//	}
//
//	return result
//}
//
//// ============ C 导出接口 ============
//
////export InitCSVManager
//func InitCSVManager() C.longlong {
//	return C.longlong(initCSVManager())
//}
//
//// OpenCSVFile 打开/创建CSV文件
////
////export OpenCSVFile
//func OpenCSVFile(filename *C.char, delimiter C.char, hasHeader C.int) C.longlong {
//	return C.longlong(openCSVFile(C.GoString(filename), rune(delimiter), hasHeader != 0))
//}
//
//// CSV响应结构体
//type CSVResponse struct {
//	Success bool        `json:"success"`
//	Message string      `json:"message,omitempty"`
//	Data    interface{} `json:"data,omitempty"`
//}
//
//// UpdateCSVRowSafe 修改csv文件行数据
////
////export UpdateCSVRowSafe
//func UpdateCSVRowSafe(handleID C.longlong, rowNum C.int, newRow *C.char) *C.char {
//	goHandle := int64(handleID)
//	goRowNum := int(rowNum)
//	goNewRow := C.GoString(newRow)
//	var row []string
//	var csvResponse CSVResponse
//	// 解析JSON
//	err := json.Unmarshal([]byte(goNewRow), &row)
//	if err != nil {
//		csvResponse = CSVResponse{
//			Success: false,
//			Message: fmt.Sprintf("解析JSON失败: %v", err),
//		}
//		errorJson, _ := json.Marshal(csvResponse)
//		return C.CString(string(errorJson))
//	}
//	// 修改csv行数据
//	err = updateCSVRowSafe(goHandle, goRowNum, row)
//	if err != nil {
//		csvResponse = CSVResponse{
//			Success: false,
//			Message: fmt.Sprintf(err.Error()),
//		}
//		errorJson, _ := json.Marshal(csvResponse)
//		return C.CString(string(errorJson))
//	} else {
//		csvResponse = CSVResponse{
//			Success: true,
//		}
//	}
//	// 转换为JSON字符串
//	jsonData, err := json.Marshal(csvResponse)
//	if err != nil {
//		// 如果JSON序列化失败，返回错误信息
//		csvResponse = CSVResponse{
//			Success: false,
//			Message: fmt.Sprintf("JSON序列化失败: %v", err),
//		}
//		errorJson, _ := json.Marshal(csvResponse)
//		return C.CString(string(errorJson))
//	}
//	return C.CString(string(jsonData))
//}
//
////export CreateOpenCSVFile
//func CreateOpenCSVFile(filename *C.char, delimiter C.char, hasHeader C.int) *C.char {
//	goFilename := C.GoString(filename)
//	goDelimiter := rune(delimiter)
//	var goHasHeader bool
//	if int(hasHeader) == 0 {
//		goHasHeader = true
//	}
//	goHasHeader = false
//	handle := createOpenCSVFile(goFilename, goDelimiter, goHasHeader)
//	var csvResponse CSVResponse
//	response := struct {
//		HandleID int64 `json:"handleID"`
//	}{
//		HandleID: handle,
//	}
//	csvResponse.Success = true
//	csvResponse.Data = response
//	jsonData, _ := json.Marshal(csvResponse)
//	return C.CString(string(jsonData))
//}
//
//// ReadRows 读取多行数据
////
////export ReadRows
//func ReadRows(handle C.longlong, startRow C.longlong, count C.longlong, buffer *C.char, bufferSize C.int) C.longlong {
//	// 将 C 缓冲区转换为 Go 的字节切片
//	goBuffer := unsafe.Slice((*byte)(unsafe.Pointer(buffer)), int(bufferSize))
//	result := readRows(int64(handle), int64(startRow), int64(count), goBuffer)
//	return C.longlong(result)
//}
//
//// WriteRows 写入/覆盖行数据
////
////export WriteRows
//func WriteRows(handle C.longlong, rowsData *C.char, header C.int) C.int {
//	goData := C.GoString(rowsData)
//	goHeader := int(header)
//	//data := parseSimpleTable(goData)
//	var data [][]string
//	err := json.Unmarshal([]byte(goData), &data)
//	if err != nil {
//		setError(err.Error())
//	}
//	result := writeRows(int64(handle), data, goHeader)
//	return C.int(result)
//}
//
//// AppendRows 追加行数据
////
////export AppendRows
//func AppendRows(handle C.longlong, rowsData *C.char, dataSize C.int, rowCount C.longlong) C.int {
//	goData := unsafe.Slice((*byte)(unsafe.Pointer(rowsData)), int(dataSize))
//	result := appendRows(int64(handle), goData, int64(rowCount))
//	return C.int(result)
//}
//
//// GetRowCount 获取总行数
////
////export GetRowCount
//func GetRowCount(handle C.longlong) C.longlong {
//	result := getRowCount(int64(handle))
//	return C.longlong(result)
//}
//
//// FindRows 搜索行
////
////export FindRows
//func FindRows(handle C.longlong, searchText *C.char, columnIndex C.longlong, resultBuffer *C.char, bufferSize C.int, maxResults C.longlong) C.longlong {
//	goSearchText := C.GoString(searchText)
//	goResultBuffer := unsafe.Slice((*byte)(unsafe.Pointer(resultBuffer)), int(bufferSize))
//	result := findRows(int64(handle), goSearchText, int64(columnIndex), goResultBuffer, int64(maxResults))
//	return C.longlong(result)
//}
//
//// MergeCSVFiles 合并多个CSV文件(线程安全)
////
////export MergeCSVFiles
//func MergeCSVFiles(handlesPtr *C.longlong, handlesCount C.int, outputFilename *C.char, delimiter C.char, hasHeader C.int) C.longlong {
//	// 将C数组转换为Go切片
//	goHandles := unsafe.Slice(handlesPtr, int(handlesCount))
//	handles := make([]int64, len(goHandles))
//	for i := 0; i < len(goHandles); i++ {
//		handles[i] = int64(goHandles[i])
//	}
//	// 调用合并函数
//	result := mergeCSVFiles(handles, C.GoString(outputFilename), rune(delimiter), hasHeader != 0)
//	return C.longlong(result)
//}
//
//// CloseCSVFile 关闭文件
////
////export CloseCSVFile
//func CloseCSVFile(handle C.longlong) C.int {
//	result := closeCSVFile(int64(handle))
//	return C.int(result)
//}
//
//// GetError 获取错误信息
////
////export GetError
//func GetError(buffer *C.char, bufferSize C.int) C.int {
//	errMsg := getError()
//	if errMsg == "" {
//		return 0
//	}
//
//	// 将错误信息复制到缓冲区
//	goBuffer := unsafe.Slice((*byte)(unsafe.Pointer(buffer)), int(bufferSize))
//	n := copy(goBuffer, errMsg)
//	return C.int(n)
//}
//
//// 导出函数：释放C字符串内存
////
////export FreeCString
//func FreeCString(str *C.char) {
//	C.free(unsafe.Pointer(str))
//}
//
//// CSV_VERSION 版本号
//const (
//	CSV_VERSION = "v1"
//)
//
//// 获取版本信息
////
////export GetVersion
//func GetVersion() *C.char {
//	return C.CString(CSV_VERSION)
//}
//
//// main 函数是必需的，即使为空
//func main() {
//}