package main

/*
#include <stdlib.h>
*/
import "C"
import (
	"bufio"
	"encoding/csv"
	"encoding/json"
	"fmt"
	"io"
	"os"
	"path/filepath"
	"sync"
	"sync/atomic"
	"time"
)

// 修改操作类型
type ModifyType int

const (
	ModifyRow  ModifyType = iota // 修改整行
	ModifyCell                   // 修改单元格
	InsertRow                    // 插入行
	DeleteRow                    // 删除行
)

// ModifyRequest 修改请求
type ModifyRequest struct {
	HandleID     int64      // 句柄ID
	RowNumber    int64      // 行号（从1开始）
	ModifyType   ModifyType // 修改类型
	NewRow       []string   // 新行数据（整行修改）
	NewCellValue string     // 新单元格值
	ColumnIndex  int        // 列索引（单元格修改时使用）
	ColumnName   string     // 列名（可选，单元格修改时使用）
}

// ModifyResult 修改结果
type ModifyResult struct {
	Success      bool   // 是否成功
	Message      string // 消息
	RowsAffected int64  // 影响的行数
	BackupFile   string // 备份文件路径
	OperationID  string // 操作ID（用于追踪）
}

// RowPosition 行位置信息
type RowPosition struct {
	StartOffset int64 // 行开始偏移
	EndOffset   int64 // 行结束偏移
	RowLength   int   // 行长度（字节数）
}

// CSVHandle CSV文件句柄
type CSVHandle struct {
	ID             int64        // 句柄唯一ID
	Filename       string       // 文件名
	Delimiter      rune         // 分隔符
	HasHeader      bool         // 是否有表头
	Header         []string     // 表头（如果有）
	File           *os.File     // 底层文件句柄
	CSVReader      *csv.Reader  // CSV阅读器
	TotalRows      int64        // 总行数（如果已计算）
	IsOpen         bool         // 是否已打开
	OpenTime       time.Time    // 打开时间
	AccessTime     time.Time    // 最后访问时间
	AccessCount    int64        // 访问计数
	mu             sync.RWMutex // 读写锁（保护数据结构）
	writeMu        sync.Mutex   // 写入专用锁（保证写入互斥）
	autoCloseTimer *time.Timer  // 自动关闭计时器

	// 修改相关
	rowIndex     []RowPosition // 行索引（用于快速定位）
	indexBuilt   bool          // 索引是否已构建
	tempDir      string        // 临时目录
	backupFiles  []string      // 备份文件列表
	operationLog []string      // 操作日志
}

// CSVManager CSV文件管理器
type CSVManager struct {
	handles    sync.Map      // map[int64]*CSVHandle
	nextHandle int64         // 下一个句柄ID
	maxOpen    int           // 最大打开文件数
	semaphore  chan struct{} // 信号量控制并发打开
	config     ManagerConfig // 管理器配置
	fileLocks  *sync.Map     // 文件级锁映射
}

// ManagerConfig 管理器配置
type ManagerConfig struct {
	MaxOpenFiles     int           // 最大打开文件数
	AutoCloseTimeout time.Duration // 自动关闭超时
	BufferSize       int           // 缓冲区大小
	UseMMap          bool          // 是否使用内存映射（大文件）
	MMapThreshold    int64         // 使用内存映射的阈值（字节）
	CacheRows        int           // 缓存行数
	MaxWriteRetries  int           // 最大写入重试次数
	WriteTimeout     time.Duration // 写入超时时间
}

// DefaultConfig 默认配置
var DefaultConfig = ManagerConfig{
	MaxOpenFiles:     100,
	AutoCloseTimeout: 5 * time.Minute,
	BufferSize:       32 * 1024, // 32KB
	UseMMap:          true,
	MMapThreshold:    10 * 1024 * 1024, // 10MB
	CacheRows:        1000,
	MaxWriteRetries:  3,
	WriteTimeout:     30 * time.Second,
}

// 全局管理器实例
var (
	globalManager   *CSVManager
	managerInitOnce sync.Once
)

// GetManager 获取全局管理器
func GetManager() *CSVManager {
	managerInitOnce.Do(func() {
		globalManager = NewCSVManager(DefaultConfig)
	})
	return globalManager
}

// NewCSVManager 创建新的CSV管理器
func NewCSVManager(config ManagerConfig) *CSVManager {
	if config.MaxOpenFiles <= 0 {
		config.MaxOpenFiles = DefaultConfig.MaxOpenFiles
	}
	return &CSVManager{
		handles:    sync.Map{},
		nextHandle: 1,
		maxOpen:    config.MaxOpenFiles,
		semaphore:  make(chan struct{}, config.MaxOpenFiles),
		config:     config,
		fileLocks:  &sync.Map{},
	}
}

// getFileLock 获取文件级锁
func (mgr *CSVManager) getFileLock(filename string) *sync.RWMutex {
	lock, _ := mgr.fileLocks.LoadOrStore(filename, &sync.RWMutex{})
	return lock.(*sync.RWMutex)
}

// ========================== 文件操作 ==========================

// OpenCSVFile 打开CSV文件并返回句柄
func (mgr *CSVManager) OpenCSVFile(filename string, delimiter rune, hasHeader bool) (int64, error) {
	// 检查文件是否存在
	if _, err := os.Stat(filename); os.IsNotExist(err) {
		return -1, fmt.Errorf("文件不存在: %s", filename)
	}

	// 限制并发打开文件数
	mgr.semaphore <- struct{}{}
	defer func() { <-mgr.semaphore }()

	// 生成唯一句柄ID
	handleID := atomic.AddInt64(&mgr.nextHandle, 1)

	// 创建CSV句柄
	csvHandle := &CSVHandle{
		ID:         handleID,
		Filename:   filename,
		Delimiter:  delimiter,
		HasHeader:  hasHeader,
		OpenTime:   time.Now(),
		AccessTime: time.Now(),
	}

	// 打开文件
	if err := mgr.openFile(csvHandle); err != nil {
		return -1, fmt.Errorf("打开文件失败: %w", err)
	}

	// 获取总行数
	rows, err := csvHandle.GetTotalRows()
	if err != nil {
		return -1, err
	}
	csvHandle.TotalRows = rows

	// 读取表头（如果需要）
	if hasHeader {
		if err := mgr.readHeader(csvHandle); err != nil {
			csvHandle.Close()
			return -1, fmt.Errorf("读取表头失败: %w", err)
		}
	}

	// 注册到管理器
	mgr.handles.Store(handleID, csvHandle)

	// 启动自动关闭计时器
	if mgr.config.AutoCloseTimeout > 0 {
		csvHandle.startAutoClose(mgr.config.AutoCloseTimeout, mgr)
	}

	return handleID, nil
}

// openFile 打开文件
func (mgr *CSVManager) openFile(handle *CSVHandle) error {
	handle.mu.Lock()
	defer handle.mu.Unlock()

	if handle.IsOpen {
		return nil
	}

	// 获取文件大小
	fileInfo, err := os.Stat(handle.Filename)
	if err != nil {
		return err
	}

	fileSize := fileInfo.Size()

	// 根据文件大小选择打开策略
	if mgr.config.UseMMap && fileSize > mgr.config.MMapThreshold {
		return mgr.openFileWithMMap(handle, fileSize)
	}

	return mgr.openFileNormal(handle)
}

// openFileNormal 正常打开文件
func (mgr *CSVManager) openFileNormal(handle *CSVHandle) error {
	file, err := os.Open(handle.Filename)
	if err != nil {
		return err
	}

	// 创建带缓冲的CSV阅读器
	reader := csv.NewReader(bufio.NewReaderSize(file, mgr.config.BufferSize))
	reader.Comma = handle.Delimiter
	reader.LazyQuotes = true
	reader.TrimLeadingSpace = true

	handle.File = file
	handle.CSVReader = reader
	handle.IsOpen = true
	handle.AccessTime = time.Now()
	return nil
}

// openFileWithMMap 使用内存映射打开大文件
func (mgr *CSVManager) openFileWithMMap(handle *CSVHandle, fileSize int64) error {
	file, err := os.Open(handle.Filename)
	if err != nil {
		return err
	}

	// 对于大文件，我们可以先只打开，按需读取
	reader := csv.NewReader(file)
	reader.Comma = handle.Delimiter
	reader.LazyQuotes = true

	handle.File = file
	handle.CSVReader = reader
	handle.IsOpen = true
	handle.AccessTime = time.Now()

	return nil
}

// readHeader 读取CSV表头
func (mgr *CSVManager) readHeader(handle *CSVHandle) error {
	handle.mu.Lock()
	defer handle.mu.Unlock()

	if !handle.IsOpen {
		return fmt.Errorf("文件未打开")
	}

	// 确保文件指针在开头
	if _, err := handle.File.Seek(0, 0); err != nil {
		return err
	}

	// 重置CSV阅读器
	handle.CSVReader = csv.NewReader(handle.File)
	handle.CSVReader.Comma = handle.Delimiter

	// 读取表头
	header, err := handle.CSVReader.Read()
	if err != nil {
		return err
	}

	handle.Header = header
	return nil
}

// GetHandle 获取句柄对象
func (mgr *CSVManager) GetHandle(handleID int64) (*CSVHandle, error) {
	value, ok := mgr.handles.Load(handleID)
	if !ok {
		return nil, fmt.Errorf("句柄不存在: %d", handleID)
	}

	handle := value.(*CSVHandle)

	// 确保文件已打开
	handle.mu.RLock()
	isOpen := handle.IsOpen
	handle.mu.RUnlock()

	if !isOpen {
		if err := mgr.openFile(handle); err != nil {
			return nil, fmt.Errorf("重新打开文件失败: %w", err)
		}
	}

	// 更新访问时间
	atomic.AddInt64(&handle.AccessCount, 1)
	handle.AccessTime = time.Now()

	return handle, nil
}

// ========================== 读取操作 ==========================

// ReadRow 读取一行数据
func (h *CSVHandle) ReadRow() ([]string, error) {
	h.mu.RLock()
	defer h.mu.RUnlock()

	if !h.IsOpen {
		return nil, fmt.Errorf("文件未打开")
	}

	if h.CSVReader == nil {
		return nil, fmt.Errorf("CSV阅读器未初始化")
	}

	return h.CSVReader.Read()
}

// ReadAllRows 读取所有行
func (h *CSVHandle) ReadAllRows() ([][]string, error) {
	h.mu.Lock()
	defer h.mu.Unlock()

	if !h.IsOpen {
		return nil, fmt.Errorf("文件未打开")
	}

	// 重置文件指针到数据开始位置
	if _, err := h.File.Seek(0, 0); err != nil {
		return nil, err
	}

	// 重新创建CSV阅读器
	h.CSVReader = csv.NewReader(h.File)
	h.CSVReader.Comma = h.Delimiter

	// 跳过表头
	if h.HasHeader {
		if _, err := h.CSVReader.Read(); err != nil {
			return nil, err
		}
	}

	// 读取所有行
	return h.CSVReader.ReadAll()
}

// ReadRows 读取指定数量的行
func (h *CSVHandle) ReadRows(count int) ([][]string, error) {
	h.mu.Lock()
	defer h.mu.Unlock()

	if !h.IsOpen {
		return nil, fmt.Errorf("文件未打开")
	}

	rows := make([][]string, 0, count)

	for i := 0; i < count; i++ {
		row, err := h.CSVReader.Read()
		if err == io.EOF {
			break
		}
		if err != nil {
			return rows, err
		}
		rows = append(rows, row)
	}

	return rows, nil
}

// GetTotalRows 获取总行数
func (h *CSVHandle) GetTotalRows() (int64, error) {
	h.mu.Lock()
	defer h.mu.Unlock()

	if h.TotalRows > 0 {
		return h.TotalRows, nil
	}

	// 保存当前文件位置
	currentPos, err := h.File.Seek(0, io.SeekCurrent)
	if err != nil {
		return 0, err
	}
	defer h.File.Seek(currentPos, io.SeekStart)

	// 重置到文件开始
	if _, err := h.File.Seek(0, 0); err != nil {
		return 0, err
	}

	// 创建新的CSV阅读器进行计数
	reader := csv.NewReader(h.File)
	reader.Comma = h.Delimiter

	var count int64 = 0

	// 跳过表头
	if h.HasHeader {
		if _, err := reader.Read(); err != nil {
			return 0, err
		}
	}

	// 计数行数
	for {
		_, err := reader.Read()
		if err == io.EOF {
			break
		}
		if err != nil {
			return count, err
		}
		count++
	}

	h.TotalRows = count
	return count, nil
}

// ========================== 修改操作 ==========================

// ModifyRow 修改指定行
func (mgr *CSVManager) ModifyRow(handleID int64, rowNumber int64, newRow []string) (*ModifyResult, error) {
	req := &ModifyRequest{
		HandleID:   handleID,
		RowNumber:  rowNumber,
		ModifyType: ModifyRow,
		NewRow:     newRow,
	}

	return mgr.ModifyCSV(req)
}

// ModifyCell 修改指定单元格
func (mgr *CSVManager) ModifyCell(handleID int64, rowNumber int64, columnIndex int, newValue string) (*ModifyResult, error) {
	req := &ModifyRequest{
		HandleID:     handleID,
		RowNumber:    rowNumber,
		ModifyType:   ModifyCell,
		ColumnIndex:  columnIndex,
		NewCellValue: newValue,
	}

	return mgr.ModifyCSV(req)
}

// ModifyCSV 通用的CSV修改函数
func (mgr *CSVManager) ModifyCSV(req *ModifyRequest) (*ModifyResult, error) {
	// 1. 获取句柄
	handle, err := mgr.GetHandle(req.HandleID)
	if err != nil {
		return &ModifyResult{
			Success: false,
			Message: fmt.Sprintf("获取句柄失败: %v", err),
		}, err
	}

	// 2. 生成操作ID
	operationID := fmt.Sprintf("%d_%d_%d", req.HandleID, time.Now().UnixNano(), req.RowNumber)

	// 3. 获取文件级写锁
	fileLock := mgr.getFileLock(handle.Filename)
	fileLock.Lock()
	defer fileLock.Unlock()

	// 4. 验证基本参数
	if err := mgr.validateModifyRequestBeforeLock(handle, req); err != nil {
		return &ModifyResult{
			Success: false,
			Message: fmt.Sprintf("参数验证失败: %v", err),
		}, err
	}

	// 5. 获取句柄写入锁
	handle.writeMu.Lock()
	defer handle.writeMu.Unlock()

	// 6. 执行修改操作
	result, err := mgr.executeModifyWithRetry(handle, req, operationID)
	if result != nil {
		result.OperationID = operationID
	}

	return result, err
}

// validateModifyRequestBeforeLock 验证修改请求（无需句柄锁）
func (mgr *CSVManager) validateModifyRequestBeforeLock(handle *CSVHandle, req *ModifyRequest) error {
	if req.RowNumber <= 0 {
		return fmt.Errorf("行号必须大于0")
	}

	// 验证列数
	handle.mu.RLock()
	header := handle.Header
	handle.mu.RUnlock()

	if req.ModifyType == ModifyRow {
		expectedCols := len(header)
		if len(req.NewRow) != expectedCols {
			return fmt.Errorf("新行数据列数不匹配，期望: %d，实际: %d", expectedCols, len(req.NewRow))
		}
	}

	if req.ModifyType == ModifyCell {
		expectedCols := len(header)
		if req.ColumnIndex < 0 || req.ColumnIndex >= expectedCols {
			return fmt.Errorf("列索引超出范围，有效范围: 0-%d", expectedCols-1)
		}
	}

	return nil
}

// executeModifyWithRetry 带重试的修改执行
func (mgr *CSVManager) executeModifyWithRetry(handle *CSVHandle, req *ModifyRequest, operationID string) (*ModifyResult, error) {
	var lastErr error
	var result *ModifyResult

	for retry := 0; retry <= mgr.config.MaxWriteRetries; retry++ {
		if retry > 0 {
			// 重试前等待
			time.Sleep(time.Duration(retry*100) * time.Millisecond)
		}

		result, lastErr = mgr.executeModifyOnce(handle, req, operationID)
		if lastErr == nil {
			// 记录操作日志
			handle.mu.Lock()
			handle.operationLog = append(handle.operationLog,
				fmt.Sprintf("%s: %s", operationID, result.Message))
			handle.mu.Unlock()
			return result, nil
		}
	}

	return &ModifyResult{
		Success:     false,
		Message:     fmt.Sprintf("修改失败，重试%d次后仍失败: %v", mgr.config.MaxWriteRetries, lastErr),
		OperationID: operationID,
	}, lastErr
}

// executeModifyOnce 执行单次修改
func (mgr *CSVManager) executeModifyOnce(handle *CSVHandle, req *ModifyRequest, operationID string) (*ModifyResult, error) {
	// 1. 创建备份
	backupFile, err := mgr.createBackup(handle)
	if err != nil {
		return &ModifyResult{
			Success: false,
			Message: fmt.Sprintf("创建备份失败: %v", err),
		}, err
	}

	// 2. 获取总行数（使用更高效的方式）
	totalRows, err := mgr.getTotalRowsForModification(handle)
	if err != nil {
		return &ModifyResult{
			Success: false,
			Message: fmt.Sprintf("获取总行数失败: %v", err),
		}, err
	}

	//// 2. 获取总行数用于验证
	//totalRows, err := mgr.calculateTotalRowsWithLock(handle)
	//if err != nil {
	//	return &ModifyResult{
	//		Success: false,
	//		Message: fmt.Sprintf("获取总行数失败: %v", err),
	//	}, err
	//}

	// 3. 验证行号范围
	if err := mgr.validateRowNumber(handle, req, totalRows); err != nil {
		return &ModifyResult{
			Success: false,
			Message: fmt.Sprintf("行号验证失败: %v", err),
		}, err
	}

	// 4. 执行修改逻辑
	startTime := time.Now()
	var result *ModifyResult
	var modifyErr error

	switch req.ModifyType {
	case ModifyRow:
		result, modifyErr = mgr.modifyRowInternal(handle, req, totalRows)
	case ModifyCell:
		result, modifyErr = mgr.modifyCellInternal(handle, req, totalRows)
	case InsertRow:
		result, modifyErr = mgr.insertRowInternal(handle, req, totalRows)
	case DeleteRow:
		result, modifyErr = mgr.deleteRowInternal(handle, req, totalRows)
	default:
		modifyErr = fmt.Errorf("不支持的修改类型: %v", req.ModifyType)
		result = &ModifyResult{
			Success: false,
			Message: fmt.Sprintf("不支持的修改类型: %v", req.ModifyType),
		}
	}

	// 记录执行时间
	elapsed := time.Since(startTime)
	if elapsed > 1*time.Second {
		fmt.Printf("警告：修改操作耗时较长: %v\n", elapsed)
	}
	// 5. 设置备份文件路径
	if result != nil {
		result.BackupFile = backupFile
		result.OperationID = operationID
	}

	// 6. 记录备份文件
	if backupFile != "" {
		handle.mu.Lock()
		handle.backupFiles = append(handle.backupFiles, backupFile)
		handle.mu.Unlock()
	}

	return result, modifyErr
}

// getTotalRowsForModification 为修改操作获取总行数（优化版本）
func (mgr *CSVManager) getTotalRowsForModification(handle *CSVHandle) (int64, error) {
	// 先检查是否已有缓存
	if handle.TotalRows > 0 {
		return handle.TotalRows, nil
	}

	// 如果文件不大，直接快速计算
	fileInfo, err := os.Stat(handle.Filename)
	if err != nil {
		return 0, err
	}

	// 对于小文件，使用快速计算方法
	if fileInfo.Size() < 10*1024*1024 { // 10MB以下
		return mgr.fastCountRows(handle)
	}

	// 大文件使用原来的方法
	return mgr.calculateTotalRowsWithLock(handle)
}

// fastCountRows 快速计算行数（无需复杂锁）
func (mgr *CSVManager) fastCountRows(handle *CSVHandle) (int64, error) {
	file, err := os.Open(handle.Filename)
	if err != nil {
		return 0, err
	}
	defer file.Close()

	reader := csv.NewReader(file)
	reader.Comma = handle.Delimiter

	var count int64 = 0
	for {
		_, err := reader.Read()
		if err == io.EOF {
			break
		}
		if err != nil {
			return count, err
		}
		count++
	}

	// 减去表头行
	if handle.HasHeader {
		count--
	}

	// 缓存结果
	handle.mu.Lock()
	handle.TotalRows = count
	handle.mu.Unlock()

	return count, nil
}

// calculateTotalRowsWithLock 计算总行数（带锁）
func (mgr *CSVManager) calculateTotalRowsWithLock(handle *CSVHandle) (int64, error) {
	handle.mu.Lock()
	defer handle.mu.Unlock()

	if handle.TotalRows > 0 {
		return handle.TotalRows, nil
	}

	// 保存当前文件位置
	currentPos, err := handle.File.Seek(0, io.SeekCurrent)
	if err != nil {
		return 0, err
	}
	defer handle.File.Seek(currentPos, io.SeekStart)

	// 重置到文件开始
	if _, err := handle.File.Seek(0, 0); err != nil {
		return 0, err
	}

	// 创建新的CSV阅读器进行计数
	reader := csv.NewReader(handle.File)
	reader.Comma = handle.Delimiter

	var count int64 = 0

	// 跳过表头
	if handle.HasHeader {
		if _, err := reader.Read(); err != nil {
			return 0, err
		}
	}

	// 计数行数
	for {
		_, err := reader.Read()
		if err == io.EOF {
			break
		}
		if err != nil {
			return count, err
		}
		count++
	}

	handle.TotalRows = count
	return count, nil
}

// validateRowNumber 验证行号
func (mgr *CSVManager) validateRowNumber(handle *CSVHandle, req *ModifyRequest, totalRows int64) error {
	// 调整行号（考虑表头）
	adjustedRowNumber := req.RowNumber
	if handle.HasHeader {
		adjustedRowNumber = req.RowNumber + 1 // 表头占第1行
	}

	// 验证行号范围
	if req.ModifyType == ModifyRow || req.ModifyType == ModifyCell {
		if adjustedRowNumber > totalRows {
			return fmt.Errorf("行号超出范围，最大行数为: %d", totalRows-1)
		}
	} else if req.ModifyType == InsertRow {
		// 插入行可以在末尾
		if adjustedRowNumber > totalRows+1 {
			return fmt.Errorf("插入行号超出范围，最大行数为: %d", totalRows)
		}
	} else if req.ModifyType == DeleteRow {
		if adjustedRowNumber > totalRows {
			return fmt.Errorf("删除行号超出范围，最大行数为: %d", totalRows-1)
		}
	}

	return nil
}

// createBackup 创建备份文件
func (mgr *CSVManager) createBackup(handle *CSVHandle) (string, error) {
	handle.mu.RLock()
	defer handle.mu.RUnlock()

	// 创建临时目录
	if handle.tempDir == "" {
		tempDir, err := os.MkdirTemp("", fmt.Sprintf("csv_backup_%d_", handle.ID))
		if err != nil {
			return "", fmt.Errorf("创建临时目录失败: %v", err)
		}
		handle.tempDir = tempDir
	}

	// 生成备份文件名
	backupFile := filepath.Join(handle.tempDir,
		fmt.Sprintf("backup_%d_%s.csv", time.Now().UnixNano(),
			filepath.Base(handle.Filename)))

	// 复制文件
	src, err := os.Open(handle.Filename)
	if err != nil {
		return "", err
	}
	defer src.Close()

	dst, err := os.Create(backupFile)
	if err != nil {
		return "", err
	}
	defer dst.Close()

	_, err = io.Copy(dst, src)
	if err != nil {
		os.Remove(backupFile) // 删除失败的备份文件
		return "", err
	}

	return backupFile, nil
}

// modifyRowInternal 修改整行
func (mgr *CSVManager) modifyRowInternal(handle *CSVHandle, req *ModifyRequest, totalRows int64) (*ModifyResult, error) {
	// 1. 创建临时文件
	tempFile, err := os.CreateTemp(handle.tempDir, "temp_*.csv")
	if err != nil {
		return nil, fmt.Errorf("创建临时文件失败: %v", err)
	}
	defer func() {
		tempFile.Close()
		os.Remove(tempFile.Name())
	}()

	// 2. 复制并修改文件
	modifiedCount, err := mgr.copyAndModifyRow(handle, tempFile, req)
	if err != nil {
		return nil, fmt.Errorf("复制修改文件失败: %v", err)
	}

	// 3. 关闭临时文件以确保数据写入磁盘
	if err := tempFile.Close(); err != nil {
		return nil, fmt.Errorf("关闭临时文件失败: %v", err)
	}

	// 4. 原子替换原文件
	if err := mgr.atomicReplaceFile(tempFile.Name(), handle.Filename); err != nil {
		// 尝试恢复备份
		mgr.restoreFromBackup(handle)
		return nil, fmt.Errorf("替换文件失败: %v", err)
	}

	// 5. 重新打开文件
	handle.mu.Lock()
	if handle.File != nil {
		handle.File.Close()
		handle.File = nil
		handle.IsOpen = false
	}

	if err := mgr.openFile(handle); err != nil {
		handle.mu.Unlock()
		return nil, fmt.Errorf("重新打开文件失败: %v", err)
	}

	// 更新总行数
	handle.TotalRows = totalRows
	handle.mu.Unlock()

	return &ModifyResult{
		Success:      true,
		Message:      fmt.Sprintf("修改第%d行成功", req.RowNumber),
		RowsAffected: modifiedCount,
	}, nil
}

// copyAndModifyRow 复制文件并修改指定行
func (mgr *CSVManager) copyAndModifyRow(handle *CSVHandle, dst *os.File, req *ModifyRequest) (int64, error) {
	// 打开源文件
	src, err := os.Open(handle.Filename)
	if err != nil {
		return 0, err
	}
	defer src.Close()

	// 创建CSV读写器
	csvReader := csv.NewReader(src)
	csvReader.Comma = handle.Delimiter
	csvReader.LazyQuotes = true

	csvWriter := csv.NewWriter(dst)
	csvWriter.Comma = handle.Delimiter

	var rowCount int64 = 0
	var modifiedCount int64 = 0

	for {
		row, err := csvReader.Read()
		if err == io.EOF {
			break
		}
		if err != nil {
			csvWriter.Flush()
			return modifiedCount, fmt.Errorf("读取第%d行失败: %v", rowCount+1, err)
		}

		rowCount++

		// 检查是否是目标行（考虑表头）
		targetRowNumber := req.RowNumber
		if handle.HasHeader {
			targetRowNumber = req.RowNumber + 1
		}

		if rowCount == targetRowNumber {
			// 修改这一行
			row = req.NewRow
			modifiedCount++
		}

		// 写入行
		if err := csvWriter.Write(row); err != nil {
			csvWriter.Flush()
			return modifiedCount, fmt.Errorf("写入第%d行失败: %v", rowCount, err)
		}
	}

	// 确保所有数据写入文件
	if err := csvWriter.Error(); err != nil {
		return modifiedCount, fmt.Errorf("CSV写入错误: %v", err)
	}

	csvWriter.Flush()
	return modifiedCount, nil
}

// modifyCellInternal 修改单元格
func (mgr *CSVManager) modifyCellInternal(handle *CSVHandle, req *ModifyRequest, totalRows int64) (*ModifyResult, error) {
	// 1. 读取目标行
	targetRow, err := mgr.readSpecificRow(handle, req.RowNumber)
	if err != nil {
		return nil, fmt.Errorf("读取目标行失败: %v", err)
	}

	// 2. 修改单元格
	if req.ColumnIndex >= 0 && req.ColumnIndex < len(targetRow) {
		targetRow[req.ColumnIndex] = req.NewCellValue
	} else {
		return nil, fmt.Errorf("列索引超出范围: %d", req.ColumnIndex)
	}

	// 3. 构建修改请求（转换为整行修改）
	rowReq := &ModifyRequest{
		HandleID:   req.HandleID,
		RowNumber:  req.RowNumber,
		ModifyType: ModifyRow,
		NewRow:     targetRow,
	}

	// 4. 调用整行修改
	return mgr.modifyRowInternal(handle, rowReq, totalRows)
}

// insertRowInternal 插入行
func (mgr *CSVManager) insertRowInternal(handle *CSVHandle, req *ModifyRequest, totalRows int64) (*ModifyResult, error) {
	// 创建临时文件
	tempFile, err := os.CreateTemp(handle.tempDir, "insert_*.csv")
	if err != nil {
		return nil, fmt.Errorf("创建临时文件失败: %v", err)
	}
	defer func() {
		tempFile.Close()
		os.Remove(tempFile.Name())
	}()

	// 打开源文件
	src, err := os.Open(handle.Filename)
	if err != nil {
		return nil, err
	}
	defer src.Close()

	// 创建CSV读写器
	csvReader := csv.NewReader(src)
	csvReader.Comma = handle.Delimiter

	csvWriter := csv.NewWriter(tempFile)
	csvWriter.Comma = handle.Delimiter

	var rowCount int64 = 0

	for {
		row, err := csvReader.Read()
		if err == io.EOF {
			break
		}
		if err != nil {
			csvWriter.Flush()
			return nil, fmt.Errorf("读取第%d行失败: %v", rowCount+1, err)
		}

		rowCount++

		// 写入当前行
		if err := csvWriter.Write(row); err != nil {
			csvWriter.Flush()
			return nil, fmt.Errorf("写入第%d行失败: %v", rowCount, err)
		}

		// 检查是否到达插入位置（考虑表头）
		insertPosition := req.RowNumber
		if handle.HasHeader {
			insertPosition = req.RowNumber + 1
		}

		if rowCount == insertPosition {
			// 插入新行
			if err := csvWriter.Write(req.NewRow); err != nil {
				csvWriter.Flush()
				return nil, fmt.Errorf("插入新行失败: %v", err)
			}
		}
	}

	// 如果是最后一行之后插入
	adjustedTotalRows := totalRows
	if handle.HasHeader {
		adjustedTotalRows = totalRows - 1
	}

	if req.RowNumber == adjustedTotalRows+1 {
		// 在文件末尾插入
		if err := csvWriter.Write(req.NewRow); err != nil {
			csvWriter.Flush()
			return nil, fmt.Errorf("在末尾插入新行失败: %v", err)
		}
	}

	// 确保所有数据写入
	csvWriter.Flush()
	if err := csvWriter.Error(); err != nil {
		return nil, fmt.Errorf("CSV写入错误: %v", err)
	}

	// 关闭临时文件
	if err := tempFile.Close(); err != nil {
		return nil, fmt.Errorf("关闭临时文件失败: %v", err)
	}

	// 原子替换原文件
	handle.mu.Lock()
	if handle.File != nil {
		handle.File.Close()
		handle.File = nil
		handle.IsOpen = false
	}

	if err := mgr.atomicReplaceFile(tempFile.Name(), handle.Filename); err != nil {
		handle.mu.Unlock()
		mgr.restoreFromBackup(handle)
		return nil, fmt.Errorf("替换文件失败: %v", err)
	}

	// 重新打开文件
	if err := mgr.openFile(handle); err != nil {
		handle.mu.Unlock()
		return nil, fmt.Errorf("重新打开文件失败: %v", err)
	}

	// 更新总行数
	handle.TotalRows = totalRows + 1
	handle.mu.Unlock()

	return &ModifyResult{
		Success:      true,
		Message:      fmt.Sprintf("在第%d行后插入成功", req.RowNumber),
		RowsAffected: 1,
	}, nil
}

// deleteRowInternal 删除行
func (mgr *CSVManager) deleteRowInternal(handle *CSVHandle, req *ModifyRequest, totalRows int64) (*ModifyResult, error) {
	// 创建临时文件
	tempFile, err := os.CreateTemp(handle.tempDir, "delete_*.csv")
	if err != nil {
		return nil, fmt.Errorf("创建临时文件失败: %v", err)
	}
	defer func() {
		tempFile.Close()
		os.Remove(tempFile.Name())
	}()

	// 打开源文件
	src, err := os.Open(handle.Filename)
	if err != nil {
		return nil, err
	}
	defer src.Close()

	// 创建CSV读写器
	csvReader := csv.NewReader(src)
	csvReader.Comma = handle.Delimiter

	csvWriter := csv.NewWriter(tempFile)
	csvWriter.Comma = handle.Delimiter

	var rowCount int64 = 0
	var deletedCount int64 = 0

	for {
		row, err := csvReader.Read()
		if err == io.EOF {
			break
		}
		if err != nil {
			csvWriter.Flush()
			return nil, fmt.Errorf("读取第%d行失败: %v", rowCount+1, err)
		}

		rowCount++

		// 检查是否是要删除的行（考虑表头）
		deleteRowNumber := req.RowNumber
		if handle.HasHeader {
			deleteRowNumber = req.RowNumber + 1
		}

		if rowCount == deleteRowNumber {
			// 跳过这一行（不写入）
			deletedCount++
			continue
		}

		// 写入行
		if err := csvWriter.Write(row); err != nil {
			csvWriter.Flush()
			return nil, fmt.Errorf("写入第%d行失败: %v", rowCount, err)
		}
	}

	// 确保所有数据写入
	csvWriter.Flush()
	if err := csvWriter.Error(); err != nil {
		return nil, fmt.Errorf("CSV写入错误: %v", err)
	}

	// 关闭临时文件
	if err := tempFile.Close(); err != nil {
		return nil, fmt.Errorf("关闭临时文件失败: %v", err)
	}

	// 原子替换原文件
	handle.mu.Lock()
	if handle.File != nil {
		handle.File.Close()
		handle.File = nil
		handle.IsOpen = false
	}

	if err := mgr.atomicReplaceFile(tempFile.Name(), handle.Filename); err != nil {
		handle.mu.Unlock()
		mgr.restoreFromBackup(handle)
		return nil, fmt.Errorf("替换文件失败: %v", err)
	}

	// 重新打开文件
	if err := mgr.openFile(handle); err != nil {
		handle.mu.Unlock()
		return nil, fmt.Errorf("重新打开文件失败: %v", err)
	}

	// 更新总行数
	handle.TotalRows = totalRows - deletedCount
	handle.mu.Unlock()

	return &ModifyResult{
		Success:      true,
		Message:      fmt.Sprintf("删除第%d行成功", req.RowNumber),
		RowsAffected: deletedCount,
	}, nil
}

// readSpecificRow 读取指定行
func (mgr *CSVManager) readSpecificRow(handle *CSVHandle, rowNumber int64) ([]string, error) {
	// 保存当前位置
	currentPos, err := handle.File.Seek(0, io.SeekCurrent)
	if err != nil {
		return nil, err
	}
	defer handle.File.Seek(currentPos, io.SeekStart)

	// 重置到文件开始
	if _, err := handle.File.Seek(0, 0); err != nil {
		return nil, err
	}

	// 创建新的CSV阅读器
	reader := csv.NewReader(handle.File)
	reader.Comma = handle.Delimiter

	var rowCount int64 = 0
	targetRowNumber := rowNumber
	if handle.HasHeader {
		targetRowNumber = rowNumber + 1
	}

	for {
		row, err := reader.Read()
		if err == io.EOF {
			break
		}
		if err != nil {
			return nil, err
		}

		rowCount++
		if rowCount == targetRowNumber {
			return row, nil
		}
	}

	return nil, fmt.Errorf("行号超出范围: %d", rowNumber)
}

// ========================== 工具方法 ==========================

// atomicReplaceFile 原子替换文件
func (mgr *CSVManager) atomicReplaceFile(src, dst string) error {
	// 先尝试原子重命名（Unix/Linux上这是原子的）
	if err := os.Rename(src, dst); err == nil {
		return nil
	}

	// 如果重命名失败（比如Windows或跨分区），使用复制方式
	// 创建临时目标文件
	tmpDst := dst + ".tmp"
	if err := mgr.copyFile(src, tmpDst); err != nil {
		return err
	}

	// 重命名为目标文件
	if err := os.Rename(tmpDst, dst); err != nil {
		os.Remove(tmpDst)
		return err
	}

	return nil
}

// copyFile 复制文件
func (mgr *CSVManager) 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)
	return err
}

// restoreFromBackup 从备份恢复
func (mgr *CSVManager) restoreFromBackup(handle *CSVHandle) error {
	handle.mu.Lock()
	defer handle.mu.Unlock()

	if len(handle.backupFiles) == 0 {
		return fmt.Errorf("没有可用的备份文件")
	}

	// 使用最新的备份
	latestBackup := handle.backupFiles[len(handle.backupFiles)-1]

	// 关闭当前文件
	if handle.File != nil {
		handle.File.Close()
		handle.File = nil
		handle.IsOpen = false
	}

	// 恢复备份
	if err := mgr.atomicReplaceFile(latestBackup, handle.Filename); err != nil {
		return fmt.Errorf("恢复备份失败: %v", err)
	}

	// 重新打开文件
	return mgr.openFile(handle)
}

// ========================== 其他操作 ==========================

// GetRow 获取指定行数据
func (mgr *CSVManager) GetRow(handleID int64, rowNumber int64) ([]string, error) {
	handle, err := mgr.GetHandle(handleID)
	if err != nil {
		return nil, err
	}

	// 获取文件级读锁
	fileLock := mgr.getFileLock(handle.Filename)
	fileLock.RLock()
	defer fileLock.RUnlock()

	return mgr.readSpecificRow(handle, rowNumber)
}

// UndoLastModify 撤销最后一次修改
func (mgr *CSVManager) UndoLastModify(handleID int64) (*ModifyResult, error) {
	handle, err := mgr.GetHandle(handleID)
	if err != nil {
		return nil, err
	}

	// 获取文件级写锁
	fileLock := mgr.getFileLock(handle.Filename)
	fileLock.Lock()
	defer fileLock.Unlock()

	handle.mu.Lock()
	defer handle.mu.Unlock()

	if len(handle.backupFiles) == 0 {
		return &ModifyResult{
			Success: false,
			Message: "没有可撤销的修改",
		}, nil
	}

	// 关闭当前文件
	if handle.File != nil {
		handle.File.Close()
		handle.File = nil
		handle.IsOpen = false
	}

	// 获取最新的备份
	latestBackup := handle.backupFiles[len(handle.backupFiles)-1]

	// 恢复文件
	if err := mgr.atomicReplaceFile(latestBackup, handle.Filename); err != nil {
		return &ModifyResult{
			Success: false,
			Message: fmt.Sprintf("恢复文件失败: %v", err),
		}, err
	}

	// 重新打开文件
	if err := mgr.openFile(handle); err != nil {
		return &ModifyResult{
			Success: false,
			Message: fmt.Sprintf("重新打开文件失败: %v", err),
		}, err
	}

	// 移除已使用的备份
	handle.backupFiles = handle.backupFiles[:len(handle.backupFiles)-1]

	// 重新计算总行数
	totalRows, _ := mgr.calculateTotalRowsWithLock(handle)
	fmt.Printf("总行数: %d\n", totalRows)

	return &ModifyResult{
		Success:      true,
		Message:      "撤销成功",
		RowsAffected: 1,
		BackupFile:   latestBackup,
	}, nil
}

// CleanupBackups 清理备份文件
func (mgr *CSVManager) CleanupBackups(handleID int64) error {
	handle, err := mgr.GetHandle(handleID)
	if err != nil {
		return err
	}

	handle.mu.Lock()
	defer handle.mu.Unlock()

	// 清理所有备份文件
	for _, backupFile := range handle.backupFiles {
		os.Remove(backupFile)
	}
	handle.backupFiles = nil

	// 清理临时目录
	if handle.tempDir != "" {
		os.RemoveAll(handle.tempDir)
		handle.tempDir = ""
	}

	return nil
}

// ========================== 句柄管理 ==========================

// Close 关闭CSV句柄
func (h *CSVHandle) Close() error {
	h.mu.Lock()
	defer h.mu.Unlock()

	h.writeMu.Lock()
	defer h.writeMu.Unlock()

	if !h.IsOpen {
		return nil
	}

	// 停止自动关闭计时器
	if h.autoCloseTimer != nil {
		h.autoCloseTimer.Stop()
		h.autoCloseTimer = nil
	}

	// 关闭文件
	if h.File != nil {
		if err := h.File.Close(); err != nil {
			return err
		}
		h.File = nil
	}

	h.CSVReader = nil
	h.IsOpen = false

	return nil
}

// startAutoClose 启动自动关闭计时器
func (h *CSVHandle) startAutoClose(timeout time.Duration, mgr *CSVManager) {
	h.autoCloseTimer = time.AfterFunc(timeout, func() {
		h.mu.Lock()
		defer h.mu.Unlock()

		// 检查是否长时间未访问
		if h.IsOpen && time.Since(h.AccessTime) > timeout {
			h.Close()
			// 从管理器移除
			mgr.handles.Delete(h.ID)
		}
	})
}

// GetHeader 获取表头
func (h *CSVHandle) GetHeader() []string {
	h.mu.RLock()
	defer h.mu.RUnlock()
	return h.Header
}

// GetInfo 获取句柄信息
func (h *CSVHandle) GetInfo() map[string]interface{} {
	h.mu.RLock()
	defer h.mu.RUnlock()

	return map[string]interface{}{
		"id":           h.ID,
		"filename":     h.Filename,
		"delimiter":    string(h.Delimiter),
		"has_header":   h.HasHeader,
		"is_open":      h.IsOpen,
		"open_time":    h.OpenTime,
		"access_time":  h.AccessTime,
		"access_count": h.AccessCount,
		"total_rows":   h.TotalRows,
		"header":       h.Header,
	}
}

// CloseHandle 关闭指定句柄
func (mgr *CSVManager) CloseHandle(handleID int64) error {
	value, ok := mgr.handles.Load(handleID)
	if !ok {
		return fmt.Errorf("句柄不存在: %d", handleID)
	}

	handle := value.(*CSVHandle)
	if err := handle.Close(); err != nil {
		return err
	}

	// 清理文件锁
	mgr.fileLocks.Delete(handle.Filename)

	mgr.handles.Delete(handleID)
	return nil
}

// CloseAllHandles 关闭所有句柄
func (mgr *CSVManager) CloseAllHandles() {
	mgr.handles.Range(func(key, value interface{}) bool {
		handle := value.(*CSVHandle)
		handle.Close()
		mgr.fileLocks.Delete(handle.Filename)
		mgr.handles.Delete(key)
		return true
	})
}

// ========================== 简便函数 ==========================

//// OpenCSVFile 打开CSV文件
//func OpenCSVFile(filename string, delimiter rune, hasHeader bool) (int64, error) {
//	return GetManager().OpenCSVFile(filename, delimiter, hasHeader, "utf-8")
//}

// GetCSVHandle 获取CSV句柄
func GetCSVHandle(handleID int64) (*CSVHandle, error) {
	return GetManager().GetHandle(handleID)
}

// CloseCSVHandle 关闭CSV句柄
func CloseCSVHandle(handleID int64) error {
	return GetManager().CloseHandle(handleID)
}

// ModifyCSVRow 修改CSV行
func ModifyCSVRow(handleID int64, rowNumber int64, newRow []string) (*ModifyResult, error) {
	return GetManager().ModifyRow(handleID, rowNumber, newRow)
}

// ModifyCSVCell 修改CSV单元格
func ModifyCSVCell(handleID int64, rowNumber int64, columnIndex int, newValue string) (*ModifyResult, error) {
	return GetManager().ModifyCell(handleID, rowNumber, columnIndex, newValue)
}

// GetCSVRow 获取CSV行
func GetCSVRow(handleID int64, rowNumber int64) ([]string, error) {
	return GetManager().GetRow(handleID, rowNumber)
}

// UndoLastCSVModify 撤销最后修改
func UndoLastCSVModify(handleID int64) (*ModifyResult, error) {
	return GetManager().UndoLastModify(handleID)
}

// CleanupCSVBackups 清理CSV备份
func CleanupCSVBackups(handleID int64) error {
	return GetManager().CleanupBackups(handleID)
}

// UpdateCSVRowSafe 修改csv文件行数据
func (mgr *CSVManager) UpdateCSVRowSafe(handleID int64, rowNum int, newRow []string) error {
	getHandle, err := mgr.GetHandle(handleID)
	if err != nil {
		return fmt.Errorf("获取句柄信息失败: %v", err)
	}

	// 1. 创建临时文件
	tempDir := filepath.Dir(getHandle.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(getHandle.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, getHandle.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
}

// CSV响应结构体
type CSVResponse struct {
	Success bool        `json:"success"`
	Message string      `json:"message,omitempty"`
	Data    interface{} `json:"data,omitempty"`
}

// ===================== C 函数导入 ==================
// OpenCSVFile 打开/创建CSV文件
//
//export OpenCSVFile
func OpenCSVFile(filename *C.char, delimiter C.char, hasHeader C.int) *C.char {
	goFilename := C.GoString(filename)
	goDelimiter := rune(delimiter)
	var hasHeaderBool bool
	if hasHeader != 0 {
		hasHeaderBool = true
	}
	hasHeaderBool = false
	handle, err := GetManager().OpenCSVFile(goFilename, goDelimiter, hasHeaderBool)
	response := struct {
		Handle int64 `json:"handle"`
	}{
		Handle: handle,
	}
	var csvResponse CSVResponse
	if err != nil {
		csvResponse = CSVResponse{
			Success: false,
			Message: err.Error(),
		}
	} else {
		csvResponse = CSVResponse{
			Success: true,
			Data:    response,
		}
	}
	// 转换为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))
}

// 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 = GetManager().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))
}

// 主函数
func main() {
	//fmt.Println("=== CSV句柄管理器测试 ===")
	//
	//filename := "csv/taskLog.csv"
	//fmt.Printf("1. 创建测试文件: %s\n", filename)
	//
	//// 2. 打开CSV文件
	//handleID, err := OpenCSVFile(filename, ',', true)
	//if err != nil {
	//	fmt.Printf("打开文件失败: %v\n", err)
	//	return
	//}
	//defer CloseCSVHandle(handleID)
	//
	//fmt.Printf("2. 打开文件成功，句柄ID: %d\n", handleID)
	//
	////// 3. 获取句柄信息
	////handle, err := GetCSVHandle(handleID)
	////if err != nil {
	////	fmt.Printf("获取句柄失败: %v\n", err)
	////	return
	////}
	////
	////info := handle.GetInfo()
	////fmt.Printf("3. 文件信息:\n")
	////fmt.Printf("   - 文件名: %s\n", info["filename"])
	////fmt.Printf("   - 总行数: %v\n", info["total_rows"])
	////fmt.Printf("   - 表头: %v\n", info["header"])
	//
	////// 准备新的行数据
	////newData := []string{"9787115524539", "20.00", "20", "上传成功", ""}
	////err = UpdateCSVRowSafes(handleID, 6, newData)
	////if err != nil {
	////	fmt.Printf("错误: %v\n", err)
	////} else {
	////	fmt.Println("CSV文件更新成功！")
	////}
	//
	//// 4. 读取数据
	//fmt.Println("4. 读取测试:")
	//row3, err := GetCSVRow(handleID, 100000)
	//if err != nil {
	//	fmt.Printf("   读取第100000行失败: %v\n", err)
	//} else {
	//	fmt.Printf("   第100000行数据: %v\n", row3)
	//}
	//
	////// 5. 修改测试
	////fmt.Println("5. 修改测试:")
	////newRow := []string{"9787115524539", "20.00", "1", "上传成功", ""}
	////result, err := ModifyCSVRow(handleID, 3, newRow)
	////if err != nil {
	////	fmt.Printf("   修改失败: %v\n", err)
	////} else {
	////	fmt.Printf("   修改结果: %s (影响行数: %d)\n", result.Message, result.RowsAffected)
	////
	////	// 验证修改
	////	modifiedRow, _ := GetCSVRow(handleID, 3)
	////	fmt.Printf("   修改后的第3行: %v\n", modifiedRow)
	////}
	//
	////// 6. 单元格修改测试
	////fmt.Println("6. 单元格修改测试:")
	////cellResult, err := ModifyCSVCell(handleID, 5, 1, "35")
	////if err != nil {
	////	fmt.Printf("   单元格修改失败: %v\n", err)
	////} else {
	////	fmt.Printf("   单元格修改结果: %s\n", cellResult.Message)
	////
	////	// 验证修改
	////	cellModifiedRow, _ := GetCSVRow(handleID, 5)
	////	fmt.Printf("   修改后的第5行: %v\n", cellModifiedRow)
	////}
	////
	////// 7. 并发测试
	////fmt.Println("7. 并发测试:")
	////TestConcurrentOperations(handleID)
	////
	////fmt.Println("=== 测试完成 ===")
}

// 下面是一个更简单的版本，根据你的具体需求可以选择使用
func WriteCSVSimple(filename string, data [][]string) error {
	if len(data) == 0 {
		return fmt.Errorf("写入的数据不能为空")
	}

	var file *os.File
	var err error
	var fileMode int

	// 检查文件是否存在和有内容
	if info, err := os.Stat(filename); err == nil && info.Size() > 0 {
		// 文件存在且有内容，追加模式
		fileMode = os.O_APPEND | os.O_WRONLY
	} else {
		// 文件不存在或为空，创建模式（会清空已有内容）
		fileMode = os.O_CREATE | os.O_WRONLY | os.O_TRUNC
	}

	// 打开或创建文件
	file, err = os.OpenFile(filename, fileMode, 0755)
	if err != nil {
		return err
	}
	defer file.Close()

	// 写入CSV数据
	writer := csv.NewWriter(file)
	if err := writer.WriteAll(data); err != nil {
		return err
	}
	writer.Flush()

	return writer.Error()
}