package main

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

// ========================== 数据结构定义 ==========================

// CSVHandle CSV文件句柄
type CSVHandle struct {
	ID             int64         // 句柄唯一ID
	Filename       string        // 文件名
	Delimiter      rune          // 分隔符
	HasHeader      bool          // 是否有表头
	Header         []string      // 表头（如果有）
	File           *os.File      // 底层文件句柄
	CSVReader      *csv.Reader   // CSV阅读器
	CSVWriter      *csv.Writer   // CSV写入器
	TotalRows      int64         // 总行数（如果已计算）
	IsOpen         bool          // 是否已打开
	OpenTime       time.Time     // 打开时间
	AccessTime     time.Time     // 最后访问时间
	AccessCount    int64         // 访问计数
	mu             sync.RWMutex  // 读写锁（保护数据结构）
	autoCloseTimer *time.Timer   // 自动关闭计时器
	cachedRowCount int64         // 缓存的行数（避免重复计算）
	rowCountCached bool          // 行数是否已缓存
	writeBuffer    *bufio.Writer // 写入缓冲区

	// 新增：引用计数和状态管理
	refCount   int64        // 引用计数
	refCountMu sync.RWMutex // 引用计数锁
	closing    bool         // 正在关闭中
	closed     bool         // 已关闭
	statusMu   sync.RWMutex // 状态锁
	activeOps  int64        // 正在进行的操作数
}

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

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

// MergeOptions 合并选项
type MergeOptions struct {
	AppendMode         bool                             // true=追加模式，false=覆盖模式
	SkipHeader         bool                             // 是否跳过源文件的表头
	SkipDuplicates     bool                             // 是否跳过重复行
	ColumnMapping      map[int]int                      // 列映射：源文件列索引 -> 目标文件列索引
	ConflictResolution ConflictStrategy                 // 冲突解决策略
	TransformFunc      func([]string) ([]string, error) // 数据转换函数
}

// ConflictStrategy 冲突解决策略
type ConflictStrategy int

const (
	Overwrite ConflictStrategy = iota // 覆盖目标文件的数据
	Skip                              // 跳过冲突的行
	KeepBoth                          // 保留两者
	UseSource                         // 使用源数据
	UseTarget                         // 使用目标数据
)

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

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

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

// ========================== 辅助函数 ==========================

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

// ========================== 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{},
		fileLocks:  sync.Map{},
		nextHandle: 1,
		maxOpen:    config.MaxOpenFiles,
		semaphore:  make(chan struct{}, config.MaxOpenFiles),
		config:     config,
	}
}

// ========================== CSVHandle 引用计数方法 ==========================

// addRef 增加引用计数
func (h *CSVHandle) addRef() {
	atomic.AddInt64(&h.refCount, 1)
	h.AccessTime = time.Now()
	atomic.AddInt64(&h.AccessCount, 1)
}

// releaseRef 减少引用计数，如果为0则返回true表示可以关闭
func (h *CSVHandle) releaseRef() bool {
	h.refCountMu.Lock()
	defer h.refCountMu.Unlock()

	oldCount := atomic.AddInt64(&h.refCount, -1)
	return oldCount <= 0
}

// getRefCount 获取引用计数
func (h *CSVHandle) getRefCount() int64 {
	return atomic.LoadInt64(&h.refCount)
}

// isValid 检查句柄是否有效
func (h *CSVHandle) isValid() bool {
	h.statusMu.RLock()
	defer h.statusMu.RUnlock()
	return !h.closing && !h.closed && h.IsOpen
}

// markClosing 标记为正在关闭
func (h *CSVHandle) markClosing() {
	h.statusMu.Lock()
	defer h.statusMu.Unlock()
	h.closing = true
}

// markClosed 标记为已关闭
func (h *CSVHandle) markClosed() {
	h.statusMu.Lock()
	defer h.statusMu.Unlock()
	h.closing = false
	h.closed = true
	h.IsOpen = false
}

// beginOperation 开始一个操作
func (h *CSVHandle) beginOperation() bool {
	h.statusMu.RLock()
	if h.closing || h.closed || !h.IsOpen {
		h.statusMu.RUnlock()
		return false
	}
	atomic.AddInt64(&h.activeOps, 1)
	h.statusMu.RUnlock()
	return true
}

// endOperation 结束一个操作
func (h *CSVHandle) endOperation() {
	atomic.AddInt64(&h.activeOps, -1)
}

// waitForActiveOps 等待所有活动操作完成
func (h *CSVHandle) waitForActiveOps(timeout time.Duration) bool {
	start := time.Now()
	for atomic.LoadInt64(&h.activeOps) > 0 {
		if time.Since(start) > timeout {
			return false
		}
		time.Sleep(10 * time.Millisecond)
	}
	return true
}

// ========================== CSVHandle 文件操作方法 ==========================

// close 关闭CSV句柄（内部方法）
func (h *CSVHandle) close() error {
	h.mu.Lock()
	defer h.mu.Unlock()

	if !h.IsOpen {
		return nil
	}

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

	// 确保缓冲区数据写入文件
	if h.CSVWriter != nil {
		h.CSVWriter.Flush()
	}
	if h.writeBuffer != nil {
		h.writeBuffer.Flush()
	}

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

	h.CSVReader = nil
	h.CSVWriter = nil
	h.writeBuffer = nil
	h.IsOpen = false
	h.markClosed()

	return nil
}

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

// calculateTotalRows 计算CSV文件的总行数
func (h *CSVHandle) calculateTotalRows() (int64, error) {
	h.mu.Lock()
	defer h.mu.Unlock()

	// 如果已缓存，直接返回
	if h.rowCountCached {
		return h.cachedRowCount, nil
	}

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

	// 保存当前文件位置
	currentPos, err := h.File.Seek(0, 1) // 当前位置
	if err != nil {
		return 0, fmt.Errorf("获取当前文件位置失败: %w", err)
	}

	// 重置到文件开始
	if _, err := h.File.Seek(0, 0); err != nil {
		return 0, fmt.Errorf("重置文件指针失败: %w", err)
	}

	// 重置CSV阅读器
	reader := csv.NewReader(bufio.NewReader(h.File))
	reader.Comma = h.Delimiter
	reader.LazyQuotes = true
	reader.TrimLeadingSpace = true
	reader.FieldsPerRecord = -1 // 允许字段数量可变（不检查每行字段数）

	// 统计行数
	var rowCount int64 = 0
	for {
		_, err := reader.Read()
		if err != nil {
			if err == io.EOF {
				break
			}
			// 恢复文件位置
			h.File.Seek(currentPos, 0)
			return 0, fmt.Errorf("读取行失败: %w", err)
		}
		rowCount++
	}

	// 恢复文件位置
	if _, err := h.File.Seek(currentPos, 0); err != nil {
		return 0, fmt.Errorf("恢复文件位置失败: %w", err)
	}

	// 更新缓存
	h.cachedRowCount = rowCount
	h.rowCountCached = true
	h.TotalRows = rowCount

	// 如果有表头，需要减去表头行
	if h.HasHeader && rowCount > 0 {
		h.cachedRowCount = rowCount - 1
		h.TotalRows = rowCount - 1
	}

	return h.cachedRowCount, nil
}

// ========================== CSVManager 文件操作方法 ==========================

// 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) {
	// 获取文件锁
	fileLock := mgr.getFileLock(filename)
	fileLock.Lock()
	defer fileLock.Unlock()

	// 首先检查文件是否已经有打开的句柄
	if existingHandleID := mgr.findHandleByFilename(filename); existingHandleID != -1 {
		if handle, err := mgr.getHandle(existingHandleID); err == nil {
			handle.addRef()
			return existingHandleID, nil
		}
	}

	// 检查文件是否存在，如果不存在则创建
	fileInfo, err := os.Stat(filename)
	fileExists := true
	if os.IsNotExist(err) {
		fileExists = false
		// 创建文件
		file, createErr := os.Create(filename)
		if createErr != nil {
			return -1, fmt.Errorf("创建文件失败: %w", createErr)
		}
		file.Close() // 关闭文件，后续会重新打开

		// 重新获取文件信息
		fileInfo, err = os.Stat(filename)
		if err != nil {
			return -1, fmt.Errorf("获取文件信息失败: %w", err)
		}
	} else if err != nil {
		// 其他错误
		return -1, fmt.Errorf("检查文件状态失败: %w", err)
	}

	// 如果是新创建的空文件，需要特殊处理
	if !fileExists && fileInfo.Size() == 0 {
		return mgr.createEmptyCSVHandle(filename, delimiter, hasHeader)
	}

	// 限制并发打开文件数
	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(),
		AccessCount: 1,
		refCount:    1, // 初始引用计数为1
	}

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

	// 如果是新创建的文件，可能需要写入表头
	if !fileExists && hasHeader {
		// 创建空表头，用户后续可以写入实际表头
		csvHandle.Header = []string{}
	} else if hasHeader && fileInfo.Size() > 0 {
		// 读取现有文件的表头
		if err := mgr.readHeader(csvHandle); err != nil {
			csvHandle.close()
			return -1, fmt.Errorf("读取表头失败: %w", err)
		}
	}

	// 如果有数据行，计算总行数
	if fileInfo.Size() > 0 {
		// 计算总行数
		rows, err := csvHandle.calculateTotalRows()
		if err != nil {
			csvHandle.close()
			return -1, fmt.Errorf("计算总行数失败: %w", err)
		}
		csvHandle.TotalRows = rows
	} else {
		csvHandle.TotalRows = 0
		csvHandle.cachedRowCount = 0
		csvHandle.rowCountCached = true
	}

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

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

	return handleID, nil
}

// findHandleByFilename 根据文件名查找已存在的句柄ID
func (mgr *CSVManager) findHandleByFilename(filename string) int64 {
	var existingHandleID int64 = -1

	// 遍历所有句柄，查找相同文件名的句柄
	mgr.handles.Range(func(key, value interface{}) bool {
		handle := value.(*CSVHandle)

		// 检查文件名是否相同
		if handle.Filename == filename {
			// 检查句柄是否有效
			if handle.isValid() {
				existingHandleID = handle.ID
				return false // 停止遍历
			}
		}
		return true // 继续遍历
	})

	return existingHandleID
}

// createEmptyCSVHandle 创建空的CSV文件句柄
func (mgr *CSVManager) createEmptyCSVHandle(filename string, delimiter rune, hasHeader bool) (int64, error) {
	// 限制并发打开文件数
	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(),
		TotalRows:   0,
		AccessCount: 1,
		refCount:    1, // 初始引用计数为1
	}

	// 以读写模式打开文件
	file, err := os.OpenFile(filename, os.O_RDWR|os.O_CREATE, 0755)
	if err != nil {
		return -1, fmt.Errorf("打开文件失败: %w", err)
	}

	// 创建CSV写入器
	writer := csv.NewWriter(file)
	writer.Comma = delimiter

	// 如果是新创建的文件且有表头，写入空表头占位
	if hasHeader {
		// 写入空表头（用户后续需要设置实际表头）
		if err := writer.Write([]string{}); err != nil {
			file.Close()
			return -1, fmt.Errorf("写入空表头失败: %w", err)
		}
		writer.Flush()

		// 重置到文件开始位置
		if _, err := file.Seek(0, 0); err != nil {
			file.Close()
			return -1, fmt.Errorf("重置文件指针失败: %w", err)
		}
	}

	// 创建CSV阅读器
	reader := csv.NewReader(bufio.NewReaderSize(file, mgr.config.BufferSize))
	reader.Comma = delimiter
	reader.LazyQuotes = true
	reader.TrimLeadingSpace = true

	// 创建写入缓冲区
	writeBuffer := bufio.NewWriterSize(file, mgr.config.BufferSize)

	csvHandle.File = file
	csvHandle.CSVReader = reader
	csvHandle.CSVWriter = csv.NewWriter(writeBuffer)
	csvHandle.CSVWriter.Comma = delimiter
	csvHandle.writeBuffer = writeBuffer
	csvHandle.IsOpen = true
	csvHandle.AccessTime = time.Now()

	// 如果有表头，初始化空表头数组
	if hasHeader {
		csvHandle.Header = []string{}
	}

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

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

	return handleID, 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)

	// 检查句柄是否有效
	if !handle.isValid() {
		return nil, fmt.Errorf("句柄无效: %d", handleID)
	}

	// 增加引用计数
	handle.addRef()

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

	if !isOpen {
		// 获取文件锁
		fileLock := mgr.getFileLock(handle.Filename)
		fileLock.Lock()
		defer fileLock.Unlock()

		// 重新检查，防止其他协程已经重新打开了
		handle.mu.RLock()
		isOpen = handle.IsOpen
		handle.mu.RUnlock()

		if !isOpen {
			if err := mgr.openFile(handle); err != nil {
				// 恢复引用计数
				handle.releaseRef()
				return nil, fmt.Errorf("重新打开文件失败: %w", err)
			}
		}
	}

	return handle, nil
}

// releaseHandle 释放句柄引用
func (mgr *CSVManager) releaseHandle(handleID int64) {
	value, ok := mgr.handles.Load(handleID)
	if !ok {
		return
	}

	handle := value.(*CSVHandle)
	// 减少引用计数，如果为0则真正关闭
	if handle.releaseRef() {
		mgr.closeHandleInternal(handleID, handle)
	}
}

// ========================== 句柄管理方法 ==========================

// closeHandleInternal 内部关闭句柄方法
func (mgr *CSVManager) closeHandleInternal(handleID int64, handle *CSVHandle) {
	// 获取文件锁
	fileLock := mgr.getFileLock(handle.Filename)
	fileLock.Lock()
	defer fileLock.Unlock()

	// 再次检查引用计数，防止在获取锁期间有新的引用
	if handle.getRefCount() > 0 {
		return
	}

	// 标记为正在关闭
	handle.markClosing()

	// 等待所有活动操作完成
	if !handle.waitForActiveOps(30 * time.Second) {
		// 超时，强制关闭
		fmt.Printf("警告：句柄 %d 关闭超时，强制关闭\n", handleID)
	}

	// 真正关闭文件
	handle.close()

	// 从管理器移除
	mgr.handles.Delete(handleID)
}

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

	handle := value.(*CSVHandle)

	// 减少引用计数，如果为0则真正关闭
	if handle.releaseRef() {
		mgr.closeHandleInternal(handleID, handle)
	}

	return nil
}

// GracefulCloseHandle 优雅关闭句柄（等待所有操作完成）
func (mgr *CSVManager) GracefulCloseHandle(handleID int64, timeout time.Duration) error {
	value, ok := mgr.handles.Load(handleID)
	if !ok {
		return fmt.Errorf("句柄不存在: %d", handleID)
	}

	handle := value.(*CSVHandle)

	// 标记为正在关闭，阻止新操作
	handle.markClosing()

	// 等待现有操作完成
	done := make(chan bool, 1)
	go func() {
		// 等待引用计数降为1（只剩当前引用）
		for handle.getRefCount() > 1 {
			time.Sleep(100 * time.Millisecond)
		}
		done <- true
	}()

	// 设置超时
	select {
	case <-done:
		// 真正关闭
		return mgr.ForceCloseHandle(handleID)
	case <-time.After(timeout):
		return fmt.Errorf("关闭句柄超时，仍有 %d 个引用", handle.getRefCount())
	}
}

// ForceCloseHandle 强制关闭句柄（无论引用计数如何）
func (mgr *CSVManager) ForceCloseHandle(handleID int64) error {
	value, ok := mgr.handles.Load(handleID)
	if !ok {
		return fmt.Errorf("句柄不存在: %d", handleID)
	}

	handle := value.(*CSVHandle)

	// 强制设置引用计数为0
	handle.refCountMu.Lock()
	atomic.StoreInt64(&handle.refCount, 0)
	handle.refCountMu.Unlock()

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

	// 标记为正在关闭
	handle.markClosing()

	// 等待所有活动操作完成
	handle.waitForActiveOps(5 * time.Second)

	// 真正关闭文件
	handle.close()
	mgr.handles.Delete(handle.ID)

	return nil
}

// closeAllHandles 关闭所有句柄
func (mgr *CSVManager) closeAllHandles() {
	// 收集所有句柄ID
	var handleIDs []int64
	mgr.handles.Range(func(key, value interface{}) bool {
		handleIDs = append(handleIDs, key.(int64))
		return true
	})

	// 关闭每个句柄
	for _, handleID := range handleIDs {
		mgr.ForceCloseHandle(handleID)
	}
}

// ========================== 文件操作方法 ==========================

// 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)
}

// 正常打开文件
func (mgr *CSVManager) openFileNormal(handle *CSVHandle) error {
	// 以读写模式打开文件
	file, err := os.OpenFile(handle.Filename, os.O_RDWR, 0755)
	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

	// 创建写入缓冲区
	writeBuffer := bufio.NewWriterSize(file, mgr.config.BufferSize)

	handle.File = file
	handle.CSVReader = reader
	handle.CSVWriter = csv.NewWriter(writeBuffer)
	handle.CSVWriter.Comma = handle.Delimiter
	handle.writeBuffer = writeBuffer
	handle.IsOpen = true
	handle.AccessTime = time.Now()

	return nil
}

// 使用内存映射打开大文件
func (mgr *CSVManager) openFileWithMMap(handle *CSVHandle, fileSize int64) error {
	// 对于大文件，使用只读模式打开，写入需要特殊处理
	file, err := os.OpenFile(handle.Filename, os.O_RDWR, 0755)
	if err != nil {
		return err
	}

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

	// 创建写入缓冲区
	writeBuffer := bufio.NewWriterSize(file, mgr.config.BufferSize)

	handle.File = file
	handle.CSVReader = reader
	handle.CSVWriter = csv.NewWriter(writeBuffer)
	handle.CSVWriter.Comma = handle.Delimiter
	handle.writeBuffer = writeBuffer
	handle.IsOpen = true
	handle.AccessTime = time.Now()

	return nil
}

// 读取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(bufio.NewReader(handle.File))
	handle.CSVReader.Comma = handle.Delimiter

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

	handle.Header = header
	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 {
			// 检查引用计数
			if h.getRefCount() == 0 {
				h.close()
				// 从管理器移除
				mgr.handles.Delete(h.ID)
			}
		}
	})
}

// ========================== 写入功能 ==========================

// WriteHeader 写入CSV文件表头
func (mgr *CSVManager) WriteHeader(handleID int64, header []string) error {
	// 获取句柄
	handle, err := mgr.getHandle(handleID)
	if err != nil {
		return fmt.Errorf("获取句柄失败: %w", err)
	}
	defer mgr.releaseHandle(handleID)

	// 检查句柄状态
	if !handle.beginOperation() {
		return fmt.Errorf("句柄已关闭或正在关闭: %d", handleID)
	}
	defer handle.endOperation()

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

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

	// 检查文件是否已经有内容
	if handle.TotalRows > 0 {
		return fmt.Errorf("文件已有数据，无法修改表头")
	}

	// 移动到文件开头
	if _, err := handle.File.Seek(0, 0); err != nil {
		return fmt.Errorf("移动文件指针失败: %w", err)
	}

	// 清空文件内容
	if err := handle.File.Truncate(0); err != nil {
		return fmt.Errorf("清空文件失败: %w", err)
	}

	// 写入表头
	if err := handle.CSVWriter.Write(header); err != nil {
		return fmt.Errorf("写入表头失败: %w", err)
	}

	handle.CSVWriter.Flush()
	if handle.writeBuffer != nil {
		handle.writeBuffer.Flush()
	}

	// 更新句柄状态
	handle.Header = header
	handle.HasHeader = true

	return nil
}

// WriteRow 写入单行数据到CSV文件
func (mgr *CSVManager) WriteRow(handleID int64, row []string) error {
	// 获取句柄
	handle, err := mgr.getHandle(handleID)
	if err != nil {
		return fmt.Errorf("获取句柄失败: %w", err)
	}
	defer mgr.releaseHandle(handleID)

	// 检查句柄状态
	if !handle.beginOperation() {
		return fmt.Errorf("句柄已关闭或正在关闭: %d", handleID)
	}
	defer handle.endOperation()

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

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

	// 检查是否有表头且表头长度是否匹配
	if handle.HasHeader && len(handle.Header) > 0 && len(row) != len(handle.Header) {
		return fmt.Errorf("行数据列数(%d)与表头列数(%d)不匹配", len(row), len(handle.Header))
	}

	// 移动到文件末尾
	if _, err := handle.File.Seek(0, 2); err != nil {
		return fmt.Errorf("移动到文件末尾失败: %w", err)
	}

	// 写入行数据
	if err := handle.CSVWriter.Write(row); err != nil {
		return fmt.Errorf("写入行失败: %w", err)
	}

	// 更新行数统计
	handle.TotalRows++
	handle.cachedRowCount = handle.TotalRows
	handle.rowCountCached = true

	return nil
}

// WriteRows 批量写入多行数据到CSV文件
func (mgr *CSVManager) WriteRows(handleID int64, rows [][]string) (int64, error) {
	// 首先记录日志
	if err := mgr.logWriteRows(handleID, rows); err != nil {
		// 日志记录失败不影响主流程，但可以打印警告
		fmt.Printf("警告：记录日志失败: %v\n", err)
	}

	// 获取句柄
	handle, err := mgr.getHandle(handleID)
	if err != nil {
		return -1, fmt.Errorf("WriteRows 获取句柄失败: %w", err)
	}
	defer mgr.releaseHandle(handleID)

	// 检查句柄状态
	if !handle.beginOperation() {
		return -1, fmt.Errorf("句柄已关闭或正在关闭: %d", handleID)
	}
	defer handle.endOperation()

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

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

	// 检查是否有表头
	if handle.HasHeader && len(handle.Header) > 0 {
		// 验证每行的列数
		for i, row := range rows {
			if len(row) != len(handle.Header) {
				return -1, fmt.Errorf("第%d行列数(%d)与表头列数(%d)不匹配", i+1, len(row), len(handle.Header))
			}
		}
	}

	// 移动到文件末尾
	if _, err := handle.File.Seek(0, 2); err != nil {
		return -1, fmt.Errorf("移动到文件末尾失败: %w", err)
	}

	// 批量写入行数据
	for _, row := range rows {
		if err := handle.CSVWriter.Write(row); err != nil {
			return -1, fmt.Errorf("写入行失败: %w", err)
		}
	}

	// 更新行数统计
	handle.TotalRows += int64(len(rows))
	handle.cachedRowCount = handle.TotalRows
	handle.rowCountCached = true

	return handle.TotalRows, nil
}

// WriteRowsNum 批量写入多行数据到CSV文件
// 返回每行数据存储的行号数组（从1开始）
func (mgr *CSVManager) WriteRowsNum(handleID int64, rows [][]string) ([]int64, error) {

	// 获取句柄
	handle, err := mgr.getHandle(handleID)
	if err != nil {
		return nil, fmt.Errorf("WriteRows 获取句柄失败: %w", err)
	}
	defer mgr.releaseHandle(handleID)

	// 检查句柄状态
	if !handle.beginOperation() {
		return nil, fmt.Errorf("句柄已关闭或正在关闭: %d", handleID)
	}
	defer handle.endOperation()

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

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

	// 检查是否有表头
	if handle.HasHeader && len(handle.Header) > 0 {
		// 验证每行的列数
		for i, row := range rows {
			if len(row) != len(handle.Header) {
				return nil, fmt.Errorf("第%d行列数(%d)与表头列数(%d)不匹配", i+1, len(row), len(handle.Header))
			}
		}
	}

	// 移动到文件末尾
	if _, err := handle.File.Seek(0, 2); err != nil {
		return nil, fmt.Errorf("移动到文件末尾失败: %w", err)
	}

	// 计算起始行号 - 关键修正部分
	var startRow int64

	// 先获取当前文件的实际行数（包括表头）
	currentLineCount := handle.TotalRows
	if handle.HasHeader && currentLineCount == 0 {
		// 如果有表头但还没有数据行，表头算第1行，数据从第2行开始
		startRow = 2
	} else if handle.HasHeader {
		// 有表头且已有数据行，表头是第1行，TotalRows不包括表头
		// 所以下一行应该是 TotalRows + 2
		startRow = currentLineCount + 2
	} else {
		// 没有表头，直接累加
		startRow = currentLineCount + 1
	}

	// 创建行号数组
	rowNumbers := make([]int64, len(rows))
	for i := 0; i < len(rows); i++ {
		rowNumbers[i] = startRow + int64(i)
	}

	// 批量写入行数据
	for _, row := range rows {
		if err := handle.CSVWriter.Write(row); err != nil {
			return nil, fmt.Errorf("写入行失败: %w", err)
		}
	}

	// 更新行数统计
	handle.TotalRows += int64(len(rows))
	handle.cachedRowCount = handle.TotalRows
	handle.rowCountCached = true

	return rowNumbers, nil
}

// logWriteRows 记录行数据到日志文件
func (mgr *CSVManager) logWriteRows(handleID int64, rows [][]string) error {
	// 获取句柄信息（但不锁定，因为我们只是读取元数据）
	handle, err := mgr.getHandle(handleID)
	if err != nil {
		return fmt.Errorf("获取句柄信息失败: %w", err)
	}
	defer mgr.releaseHandle(handleID)

	// 创建日志目录
	logDir := filepath.Join(filepath.Dir("csv"), "logs")
	if err := os.MkdirAll(logDir, 0755); err != nil {
		return fmt.Errorf("创建日志目录失败: %w", err)
	}

	// 生成日志文件名（基于CSV文件名和时间）
	baseName := filepath.Base("csv")
	logFileName := fmt.Sprintf("%s_%s_write.log",
		baseName[:len(baseName)-len(filepath.Ext(baseName))],
		time.Now().Format("20060102"))
	logFilePath := filepath.Join(logDir, logFileName)

	// 打开或创建日志文件
	logFile, err := os.OpenFile(logFilePath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
	if err != nil {
		return fmt.Errorf("打开日志文件失败: %w", err)
	}
	defer logFile.Close()

	// 创建日志条目
	logEntry := map[string]interface{}{
		"timestamp":  time.Now().Format("2006-01-02 15:04:05.000"),
		"handle_id":  handleID,
		"filename":   "csv",
		"operation":  "write_rows",
		"row_count":  len(rows),
		"total_rows": handle.TotalRows + int64(len(rows)), // 预计的总行数
		"data":       rows,
	}

	// 序列化为JSON
	logData, err := json.Marshal(logEntry)
	if err != nil {
		return fmt.Errorf("序列化日志数据失败: %w", err)
	}

	// 写入日志（每行一个JSON对象）
	if _, err := logFile.Write(append(logData, '\n')); err != nil {
		return fmt.Errorf("写入日志文件失败: %w", err)
	}

	return nil
}

// logWriteRows 记录行数据到日志文件
func (mgr *CSVManager) logWriteRowsNum(handleID int64, rows [][]string, rowsNum []int64) error {
	// 获取句柄信息（但不锁定，因为我们只是读取元数据）
	handle, err := mgr.getHandle(handleID)
	if err != nil {
		return fmt.Errorf("获取句柄信息失败: %w", err)
	}
	defer mgr.releaseHandle(handleID)

	// 创建日志目录
	logDir := filepath.Join(filepath.Dir("csv"), "logs")
	if err := os.MkdirAll(logDir, 0755); err != nil {
		return fmt.Errorf("创建日志目录失败: %w", err)
	}

	// 生成日志文件名（基于CSV文件名和时间）
	baseName := filepath.Base("csv")
	logFileName := fmt.Sprintf("%s_%s_write.log",
		baseName[:len(baseName)-len(filepath.Ext(baseName))],
		time.Now().Format("20060102"))
	logFilePath := filepath.Join(logDir, logFileName)

	// 打开或创建日志文件
	logFile, err := os.OpenFile(logFilePath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
	if err != nil {
		return fmt.Errorf("打开日志文件失败: %w", err)
	}
	defer logFile.Close()

	// 创建日志条目
	logEntry := map[string]interface{}{
		"timestamp":  time.Now().Format("2006-01-02 15:04:05.000"),
		"handle_id":  handleID,
		"filename":   "csv",
		"operation":  "write_rows",
		"row_count":  len(rows),
		"total_rows": handle.TotalRows + int64(len(rows)), // 预计的总行数
		"data":       rows,
		"rowsNum":    rowsNum,
	}

	// 序列化为JSON
	logData, err := json.Marshal(logEntry)
	if err != nil {
		return fmt.Errorf("序列化日志数据失败: %w", err)
	}

	// 写入日志（每行一个JSON对象）
	if _, err := logFile.Write(append(logData, '\n')); err != nil {
		return fmt.Errorf("写入日志文件失败: %w", err)
	}

	return nil
}

// Flush 将缓冲区数据写入文件
func (mgr *CSVManager) Flush(handleID int64) error {
	// 获取句柄
	handle, err := mgr.getHandle(handleID)
	if err != nil {
		return fmt.Errorf("Flush 获取句柄失败: %w", err)
	}
	defer mgr.releaseHandle(handleID)

	// 检查句柄状态
	if !handle.beginOperation() {
		return fmt.Errorf("句柄已关闭或正在关闭: %d", handleID)
	}
	defer handle.endOperation()

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

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

	if handle.CSVWriter == nil {
		return fmt.Errorf("CSV写入器未初始化")
	}

	// 刷新缓冲区
	handle.CSVWriter.Flush()
	if handle.writeBuffer != nil {
		if err := handle.writeBuffer.Flush(); err != nil {
			return fmt.Errorf("刷新写入缓冲区失败: %w", err)
		}
	}

	return nil
}

// AppendRow 追加行数据（自动Flush）
func (mgr *CSVManager) AppendRow(handleID int64, row []string) error {
	if err := mgr.WriteRow(handleID, row); err != nil {
		return err
	}
	return mgr.Flush(handleID)
}

// AppendRows 批量追加行数据（自动Flush）
func (mgr *CSVManager) AppendRows(handleID int64, rows [][]string) (int64, error) {
	totalRows, err := mgr.WriteRows(handleID, rows)
	if err != nil {
		return -1, err
	}
	err = mgr.Flush(handleID)
	if err != nil {
		return -1, err
	}
	return totalRows, nil
}

// AppendRows 批量追加行数据（自动Flush）
func (mgr *CSVManager) AppendRowsNum(handleID int64, rows [][]string) ([]int64, error) {
	rowsNum, err := mgr.WriteRowsNum(handleID, rows)
	if err != nil {
		return nil, err
	}
	err = mgr.Flush(handleID)
	if err != nil {
		return nil, err
	}
	// 首先记录日志
	if err := mgr.logWriteRowsNum(handleID, rows, rowsNum); err != nil {
		// 日志记录失败不影响主流程，但可以打印警告
		fmt.Printf("警告：记录日志失败: %v\n", err)
	}
	return rowsNum, nil
}

// GetHeader 获取CSV文件表头
func (mgr *CSVManager) GetHeader(handleID int64) ([]string, error) {
	// 获取句柄
	handle, err := mgr.getHandle(handleID)
	if err != nil {
		return nil, fmt.Errorf("获取句柄失败: %w", err)
	}
	defer mgr.releaseHandle(handleID)

	// 检查句柄状态
	if !handle.beginOperation() {
		return nil, fmt.Errorf("句柄已关闭或正在关闭: %d", handleID)
	}
	defer handle.endOperation()

	handle.mu.RLock()
	defer handle.mu.RUnlock()

	if !handle.HasHeader {
		return nil, fmt.Errorf("文件没有表头")
	}

	return handle.Header, nil
}

// ========================== 获取总行数 ==========================

// GetTotalRows 快速获取总行数（如果已计算过则直接返回，否则重新计算）
func (mgr *CSVManager) GetTotalRows(handleID int64) (int64, error) {
	// 获取句柄
	handle, err := mgr.getHandle(handleID)
	if err != nil {
		return 0, fmt.Errorf("获取句柄失败: %w", err)
	}
	defer mgr.releaseHandle(handleID)

	// 检查句柄状态
	if !handle.beginOperation() {
		return 0, fmt.Errorf("句柄已关闭或正在关闭: %d", handleID)
	}
	defer handle.endOperation()

	handle.mu.RLock()
	// 如果已缓存，直接返回缓存值
	if handle.rowCountCached {
		count := handle.cachedRowCount
		handle.mu.RUnlock()
		return count, nil
	}
	handle.mu.RUnlock()

	// 否则计算总行数
	return handle.calculateTotalRows()
}

// ========================== 修改指定行功能 ==========================

// UpdateRow 修改指定行的数据
func (mgr *CSVManager) UpdateRow(handleID int64, rowNumber int64, newData []string) error {
	// 获取句柄
	handle, err := mgr.getHandle(handleID)
	if err != nil {
		return fmt.Errorf("获取句柄失败: %w", err)
	}
	defer mgr.releaseHandle(handleID)

	// 检查句柄状态
	if !handle.beginOperation() {
		return fmt.Errorf("句柄已关闭或正在关闭: %d", handleID)
	}
	defer handle.endOperation()

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

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

	// 检查行号是否有效
	if rowNumber < 0 {
		return fmt.Errorf("行号不能为负数: %d", rowNumber)
	}

	// 获取总行数
	totalRows, err := handle.calculateTotalRows()
	if err != nil {
		return fmt.Errorf("获取总行数失败: %w", err)
	}

	if rowNumber >= totalRows {
		return fmt.Errorf("行号超出范围: %d, 总行数: %d", rowNumber, totalRows)
	}

	// 检查新数据列数是否匹配
	if handle.HasHeader && len(handle.Header) > 0 {
		if len(newData) != len(handle.Header) {
			return fmt.Errorf("新数据列数(%d)与表头列数(%d)不匹配", len(newData), len(handle.Header))
		}
	}

	// 读取整个文件到内存
	allRows, err := mgr.readAllRows(handle)
	if err != nil {
		return fmt.Errorf("读取文件失败: %w", err)
	}

	// 修改指定行的数据
	if handle.HasHeader && len(allRows) > 0 {
		// 如果有表头，第一行是表头，实际数据从第二行开始
		if rowNumber+1 >= int64(len(allRows)) {
			return fmt.Errorf("行号超出范围: %d, 总数据行数: %d", rowNumber, len(allRows)-1)
		}
		allRows[rowNumber+1] = newData
	} else {
		if rowNumber >= int64(len(allRows)) {
			return fmt.Errorf("行号超出范围: %d, 总行数: %d", rowNumber, len(allRows))
		}
		allRows[rowNumber] = newData
	}

	// 写回文件
	if err := mgr.writeAllRows(handle, allRows); err != nil {
		return fmt.Errorf("写回文件失败: %w", err)
	}

	// 更新缓存的行数
	handle.rowCountCached = false

	// 重新计算总行数
	if _, err := handle.calculateTotalRows(); err != nil {
		return fmt.Errorf("重新计算总行数失败: %w", err)
	}

	return nil
}

// UpdateRows 批量修改多行数据
func (mgr *CSVManager) UpdateRows(handleID int64, updates map[int64][]string) (int, error) {
	// 获取句柄
	handle, err := mgr.getHandle(handleID)
	if err != nil {
		return 0, fmt.Errorf("获取句柄失败: %w", err)
	}
	defer mgr.releaseHandle(handleID)

	// 检查句柄状态
	if !handle.beginOperation() {
		return 0, fmt.Errorf("句柄已关闭或正在关闭: %d", handleID)
	}
	defer handle.endOperation()

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

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

	// 检查行号是否有效
	for rowNumber := range updates {
		if rowNumber < 0 {
			return 0, fmt.Errorf("行号不能为负数: %d", rowNumber)
		}
	}

	// 获取总行数
	totalRows, err := handle.calculateTotalRows()
	if err != nil {
		return 0, fmt.Errorf("获取总行数失败: %w", err)
	}

	// 检查新数据列数是否匹配
	if handle.HasHeader && len(handle.Header) > 0 {
		for rowNumber, newData := range updates {
			if rowNumber >= totalRows {
				return 0, fmt.Errorf("行号超出范围: %d, 总行数: %d", rowNumber, totalRows)
			}
			if len(newData) != len(handle.Header) {
				return 0, fmt.Errorf("行%d的新数据列数(%d)与表头列数(%d)不匹配", rowNumber, len(newData), len(handle.Header))
			}
		}
	}

	// 读取整个文件到内存
	allRows, err := mgr.readAllRows(handle)
	if err != nil {
		return 0, fmt.Errorf("读取文件失败: %w", err)
	}

	// 修改指定行的数据
	updatedCount := 0
	for rowNumber, newData := range updates {
		if handle.HasHeader && len(allRows) > 0 {
			// 如果有表头，第一行是表头，实际数据从第二行开始
			if rowNumber+1 >= int64(len(allRows)) {
				return 0, fmt.Errorf("行号超出范围: %d, 总数据行数: %d", rowNumber, len(allRows)-1)
			}
			allRows[rowNumber+1] = newData
			updatedCount++
		} else {
			if rowNumber >= int64(len(allRows)) {
				return 0, fmt.Errorf("行号超出范围: %d, 总行数: %d", rowNumber, len(allRows))
			}
			allRows[rowNumber] = newData
			updatedCount++
		}
	}

	// 写回文件
	if err := mgr.writeAllRows(handle, allRows); err != nil {
		return 0, fmt.Errorf("写回文件失败: %w", err)
	}

	// 更新缓存的行数
	handle.rowCountCached = false

	// 重新计算总行数
	if _, err := handle.calculateTotalRows(); err != nil {
		return 0, fmt.Errorf("重新计算总行数失败: %w", err)
	}

	return updatedCount, nil
}

// readAllRows 读取文件中的所有行
func (mgr *CSVManager) readAllRows(handle *CSVHandle) ([][]string, error) {
	// 保存当前文件位置
	currentPos, err := handle.File.Seek(0, 1) // 当前位置
	if err != nil {
		return nil, fmt.Errorf("获取当前文件位置失败: %w", err)
	}

	// 重置到文件开始
	if _, err := handle.File.Seek(0, 0); err != nil {
		return nil, fmt.Errorf("重置文件指针失败: %w", err)
	}

	// 重置CSV阅读器
	reader := csv.NewReader(bufio.NewReader(handle.File))
	reader.Comma = handle.Delimiter
	reader.LazyQuotes = true
	reader.TrimLeadingSpace = true

	// 读取所有行
	var allRows [][]string
	for {
		row, err := reader.Read()
		if err != nil {
			if err == io.EOF {
				break
			}
			// 恢复文件位置
			handle.File.Seek(currentPos, 0)
			return nil, fmt.Errorf("读取行失败: %w", err)
		}
		allRows = append(allRows, row)
	}

	// 恢复文件位置
	if _, err := handle.File.Seek(currentPos, 0); err != nil {
		return nil, fmt.Errorf("恢复文件位置失败: %w", err)
	}

	return allRows, nil
}

// writeAllRows 将所有行写回文件
func (mgr *CSVManager) writeAllRows(handle *CSVHandle, rows [][]string) error {
	// 清空文件
	if err := handle.File.Truncate(0); err != nil {
		return fmt.Errorf("清空文件失败: %w", err)
	}

	// 移动到文件开头
	if _, err := handle.File.Seek(0, 0); err != nil {
		return fmt.Errorf("移动文件指针失败: %w", err)
	}

	// 写入所有行
	for _, row := range rows {
		if err := handle.CSVWriter.Write(row); err != nil {
			return fmt.Errorf("写入行失败: %w", err)
		}
	}

	// 刷新缓冲区
	handle.CSVWriter.Flush()
	if handle.writeBuffer != nil {
		if err := handle.writeBuffer.Flush(); err != nil {
			return fmt.Errorf("刷新写入缓冲区失败: %w", err)
		}
	}

	return nil
}

// GetRow 获取指定行的数据
func (mgr *CSVManager) GetRow(handleID int64, rowNumber int64) ([]string, error) {
	// 获取句柄
	handle, err := mgr.getHandle(handleID)
	if err != nil {
		return nil, fmt.Errorf("获取句柄失败: %w", err)
	}
	defer mgr.releaseHandle(handleID)

	// 检查句柄状态
	if !handle.beginOperation() {
		return nil, fmt.Errorf("句柄已关闭或正在关闭: %d", handleID)
	}
	defer handle.endOperation()

	//handle.mu.RLock()
	//defer handle.mu.RUnlock()

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

	// 检查行号是否有效
	if rowNumber < 0 {
		return nil, fmt.Errorf("行号不能为负数: %d", rowNumber)
	}

	// 获取总行数
	totalRows, err := handle.calculateTotalRows()
	if err != nil {
		return nil, fmt.Errorf("获取总行数失败: %w", err)
	}

	if rowNumber >= totalRows {
		return nil, fmt.Errorf("行号超出范围: %d, 总行数: %d", rowNumber, totalRows)
	}

	//// 保存当前文件位置
	//currentPos, err := handle.File.Seek(0, 1) // 当前位置
	//if err != nil {
	//	return nil, fmt.Errorf("获取当前文件位置失败: %w", err)
	//}

	//// 重置到文件开始
	//if _, err := handle.File.Seek(0, 0); err != nil {
	//	return nil, fmt.Errorf("重置文件指针失败: %w", err)
	//}

	// 创建文件副本用于读取，避免影响其他goroutine
	file, err := os.Open(handle.Filename)
	if err != nil {
		return nil, fmt.Errorf("打开文件失败: %w", err)
	}
	defer file.Close()

	// 创建CSV阅读器
	reader := csv.NewReader(file)
	reader.Comma = handle.Delimiter
	reader.LazyQuotes = true
	reader.TrimLeadingSpace = true

	//// 重置CSV阅读器
	//reader := csv.NewReader(bufio.NewReader(handle.File))
	//reader.Comma = handle.Delimiter
	//reader.LazyQuotes = true
	//reader.TrimLeadingSpace = true

	// 定位到指定行
	var currentRow int64 = 0
	var targetRow []string
	for {
		row, err := reader.Read()
		if err != nil {
			if err == io.EOF {
				break
			}
			// 恢复文件位置
			//handle.File.Seek(currentPos, 0)
			return nil, fmt.Errorf("读取行失败: %w", err)
		}

		// 判断是否到达目标行
		if handle.HasHeader {
			// 如果有表头，跳过第一行
			if currentRow == rowNumber+1 {
				targetRow = row
				break
			}
		} else {
			// 如果没有表头，直接匹配
			if currentRow == rowNumber {
				targetRow = row
				break
			}
		}
		currentRow++
	}

	//// 恢复文件位置
	//if _, err := handle.File.Seek(currentPos, 0); err != nil {
	//	return nil, fmt.Errorf("恢复文件位置失败: %w", err)
	//}

	if targetRow == nil {
		return nil, fmt.Errorf("未找到行号 %d", rowNumber)
	}

	return targetRow, nil
}

// ========================== 文件合并功能 ==========================

// MergeCSVFiles 合并两个CSV文件
func (mgr *CSVManager) MergeCSVFiles(srcHandleID, dstHandleID int64, options MergeOptions) (int64, error) {
	// 获取源文件句柄
	srcHandle, err := mgr.getHandle(srcHandleID)
	if err != nil {
		return 0, fmt.Errorf("获取源文件句柄失败: %w", err)
	}
	defer mgr.releaseHandle(srcHandleID)

	// 获取目标文件句柄
	dstHandle, err := mgr.getHandle(dstHandleID)
	if err != nil {
		return 0, fmt.Errorf("获取目标文件句柄失败: %w", err)
	}
	defer mgr.releaseHandle(dstHandleID)

	// 检查句柄状态
	if !srcHandle.beginOperation() {
		return 0, fmt.Errorf("源文件句柄已关闭或正在关闭: %d", srcHandleID)
	}
	defer srcHandle.endOperation()

	if !dstHandle.beginOperation() {
		return 0, fmt.Errorf("目标文件句柄已关闭或正在关闭: %d", dstHandleID)
	}
	defer dstHandle.endOperation()

	srcHandle.mu.RLock()
	dstHandle.mu.Lock()
	defer func() {
		srcHandle.mu.RUnlock()
		dstHandle.mu.Unlock()
	}()

	if !srcHandle.IsOpen {
		return 0, fmt.Errorf("源文件未打开")
	}
	if !dstHandle.IsOpen {
		return 0, fmt.Errorf("目标文件未打开")
	}

	// 1. 检查表头兼容性
	if err := mgr.checkHeaderCompatibility(srcHandle, dstHandle, options); err != nil {
		return 0, fmt.Errorf("表头不兼容: %w", err)
	}

	// 2. 读取源文件的所有行
	srcRows, err := mgr.readAllRows(srcHandle)
	if err != nil {
		return 0, fmt.Errorf("读取源文件失败: %w", err)
	}

	// 3. 合并数据
	mergedRows, err := mgr.mergeDataRows(srcRows, srcHandle, dstHandle, options)
	if err != nil {
		return 0, fmt.Errorf("合并数据失败: %w", err)
	}

	// 4. 写入目标文件
	if options.AppendMode {
		// 追加模式：写入到文件末尾
		if err := mgr.appendRowsToFile(dstHandle, mergedRows); err != nil {
			return 0, fmt.Errorf("追加数据失败: %w", err)
		}
	} else {
		// 覆盖模式：先读取目标文件的所有行，然后合并后写回
		dstRows, err := mgr.readAllRows(dstHandle)
		if err != nil {
			return 0, fmt.Errorf("读取目标文件失败: %w", err)
		}

		// 如果是第一次合并且目标文件为空，可能需要保留表头
		allRows := mgr.mergeAllRows(dstRows, mergedRows, dstHandle, srcHandle, options)
		if err := mgr.writeAllRows(dstHandle, allRows); err != nil {
			return 0, fmt.Errorf("写入合并数据失败: %w", err)
		}
	}

	// 5. 更新目标文件的行数缓存
	dstHandle.rowCountCached = false
	newTotalRows, err := dstHandle.calculateTotalRows()
	if err != nil {
		return 0, fmt.Errorf("重新计算行数失败: %w", err)
	}

	return newTotalRows, nil
}

// 检查表头兼容性
func (mgr *CSVManager) checkHeaderCompatibility(srcHandle, dstHandle *CSVHandle, options MergeOptions) error {
	// 如果两个文件都有表头
	if srcHandle.HasHeader && dstHandle.HasHeader {
		srcHeader := srcHandle.Header
		dstHeader := dstHandle.Header

		// 如果指定了列映射，跳过表头检查
		if len(options.ColumnMapping) > 0 {
			return nil
		}

		// 检查列数是否相同
		if len(srcHeader) != len(dstHeader) && !options.SkipHeader {
			return fmt.Errorf("源文件列数(%d)与目标文件列数(%d)不一致", len(srcHeader), len(dstHeader))
		}

		// 检查列名是否相同（可选）
		for i := 0; i < min(len(srcHeader), len(dstHeader)); i++ {
			if srcHeader[i] != dstHeader[i] {
				fmt.Printf("警告: 第%d列列名不同: 源='%s', 目标='%s'\n", i+1, srcHeader[i], dstHeader[i])
			}
		}
	} else if srcHandle.HasHeader != dstHandle.HasHeader {
		// 一个有表头，一个没有表头
		if !options.SkipHeader {
			return fmt.Errorf("源文件与目标文件的表头设置不一致")
		}
	}

	return nil
}

// 合并数据行
func (mgr *CSVManager) mergeDataRows(srcRows [][]string, srcHandle, dstHandle *CSVHandle, options MergeOptions) ([][]string, error) {
	var result [][]string

	startIndex := 0
	// 如果源文件有表头且需要跳过表头
	if srcHandle.HasHeader && options.SkipHeader {
		if len(srcRows) > 0 {
			startIndex = 1
		}
	}

	// 处理列映射
	for i := startIndex; i < len(srcRows); i++ {
		srcRow := srcRows[i]
		transformedRow, err := mgr.transformRow(srcRow, srcHandle, dstHandle, options)
		if err != nil {
			return nil, fmt.Errorf("转换第%d行数据失败: %w", i+1, err)
		}

		// 跳过空行
		if transformedRow == nil {
			continue
		}

		// 检查重复行
		if options.SkipDuplicates && mgr.isDuplicateRow(result, transformedRow) {
			continue
		}

		result = append(result, transformedRow)
	}

	return result, nil
}

// 转换行数据
func (mgr *CSVManager) transformRow(srcRow []string, srcHandle, dstHandle *CSVHandle, options MergeOptions) ([]string, error) {
	// 如果有自定义转换函数，优先使用
	if options.TransformFunc != nil {
		return options.TransformFunc(srcRow)
	}

	// 如果有列映射，按照映射转换
	if len(options.ColumnMapping) > 0 {
		// 确定目标行的最大列数
		maxCol := 0
		for _, dstIndex := range options.ColumnMapping {
			if dstIndex > maxCol {
				maxCol = dstIndex
			}
		}

		// 创建目标行
		dstRow := make([]string, maxCol+1)
		for srcIndex, dstIndex := range options.ColumnMapping {
			if srcIndex < len(srcRow) && dstIndex >= 0 && dstIndex < len(dstRow) {
				dstRow[dstIndex] = srcRow[srcIndex]
			}
		}
		return dstRow, nil
	}

	// 如果没有列映射，直接复制
	dstRow := make([]string, len(srcRow))
	copy(dstRow, srcRow)

	// 如果目标文件有表头且列数不同，进行调整
	if dstHandle.HasHeader && len(dstRow) != len(dstHandle.Header) {
		if len(dstRow) < len(dstHandle.Header) {
			// 源列数少，用空字符串填充
			for i := len(dstRow); i < len(dstHandle.Header); i++ {
				dstRow = append(dstRow, "")
			}
		} else {
			// 源列数多，截断
			dstRow = dstRow[:len(dstHandle.Header)]
		}
	}

	return dstRow, nil
}

// 检查是否为重复行
func (mgr *CSVManager) isDuplicateRow(rows [][]string, newRow []string) bool {
	for _, row := range rows {
		if mgr.compareRows(row, newRow) {
			return true
		}
	}
	return false
}

// 比较两行是否相同
func (mgr *CSVManager) compareRows(row1, row2 []string) bool {
	if len(row1) != len(row2) {
		return false
	}
	for i := range row1 {
		if row1[i] != row2[i] {
			return false
		}
	}
	return true
}

// 追加行到文件末尾
func (mgr *CSVManager) appendRowsToFile(handle *CSVHandle, rows [][]string) error {
	// 移动到文件末尾
	if _, err := handle.File.Seek(0, 2); err != nil {
		return fmt.Errorf("移动到文件末尾失败: %w", err)
	}

	// 批量写入行数据
	for _, row := range rows {
		if err := handle.CSVWriter.Write(row); err != nil {
			return fmt.Errorf("写入行失败: %w", err)
		}
	}

	// 刷新缓冲区
	handle.CSVWriter.Flush()
	if handle.writeBuffer != nil {
		if err := handle.writeBuffer.Flush(); err != nil {
			return fmt.Errorf("刷新写入缓冲区失败: %w", err)
		}
	}

	// 更新行数统计
	handle.TotalRows += int64(len(rows))
	handle.cachedRowCount = handle.TotalRows
	handle.rowCountCached = true

	return nil
}

// 合并所有行（用于覆盖模式）
func (mgr *CSVManager) mergeAllRows(dstRows, srcRows [][]string, dstHandle, srcHandle *CSVHandle, options MergeOptions) [][]string {
	var result [][]string

	// 处理表头
	if dstHandle.HasHeader && len(dstRows) > 0 {
		// 保留目标文件的表头
		result = append(result, dstRows[0])
		dstRows = dstRows[1:]
	}

	// 根据冲突解决策略合并数据
	switch options.ConflictResolution {
	case Overwrite:
		// 覆盖模式：源数据完全替换目标数据
		result = append(result, srcRows...)
	case Skip:
		// 跳过模式：只保留目标数据中不冲突的行
		result = append(result, dstRows...)
		for _, srcRow := range srcRows {
			if !mgr.isDuplicateRow(result, srcRow) {
				result = append(result, srcRow)
			}
		}
	case KeepBoth:
		// 保留两者：先写目标数据，再写源数据
		result = append(result, dstRows...)
		result = append(result, srcRows...)
	case UseSource:
		// 使用源数据：源数据优先级更高
		result = append(result, srcRows...)
	case UseTarget:
		// 使用目标数据：目标数据优先级更高
		result = append(result, dstRows...)
	default:
		// 默认：追加模式
		result = append(result, dstRows...)
		result = append(result, srcRows...)
	}

	return result
}

// MergeCSVFilesSimple 简单合并CSV文件（默认选项）
func (mgr *CSVManager) MergeCSVFilesSimple(srcHandleID, dstHandleID int64, appendMode bool) (int64, error) {
	options := MergeOptions{
		AppendMode:         appendMode,
		SkipHeader:         true,     // 跳过源文件表头
		SkipDuplicates:     false,    // 不跳过重复行
		ConflictResolution: KeepBoth, // 保留两者
	}
	return mgr.MergeCSVFiles(srcHandleID, dstHandleID, options)
}

// ========================== C 导出函数 ==========================

// OpenCSVFile 打开CSV文件
//
//export OpenCSVFile
func OpenCSVFile(filename *C.char, delimiter C.char, hasHeader C.int) *C.char {
	filenameStr := C.GoString(filename)
	delimiterStr := rune(delimiter)
	handleID, err := GetManager().OpenCSVFile(filenameStr, delimiterStr, hasHeader != 0)
	response := struct {
		HandleID int64 `json:"handleID"`
	}{
		HandleID: handleID,
	}
	var csvResponse CSVResponse
	if err != nil {
		csvResponse = CSVResponse{
			Success: false,
			Message: err.Error(),
		}
	} else {
		csvResponse = CSVResponse{
			Success: true,
			Data:    response,
		}
	}
	csvResponseStr, _ := json.Marshal(csvResponse)
	return C.CString(string(csvResponseStr))
}

// WriteHeader 写入表头
//
//export WriteHeader
func WriteHeader(handleID C.int, header *C.char) *C.char {
	var csvResponse CSVResponse
	goHandleID := int64(handleID)
	goHeader := C.GoString(header)
	var data []string
	err := json.Unmarshal([]byte(goHeader), &data)
	if err != nil {
		csvResponse = CSVResponse{
			Success: false,
			Message: fmt.Sprintf("header JSON解析失败: %v", err),
		}
		csvResponseStr, _ := json.Marshal(csvResponse)
		return C.CString(string(csvResponseStr))
	}
	errs := GetManager().WriteHeader(goHandleID, data)
	if errs != nil {
		csvResponse = CSVResponse{
			Success: false,
			Message: errs.Error(),
		}
	} else {
		csvResponse = CSVResponse{
			Success: true,
		}
	}
	csvResponseStr, _ := json.Marshal(csvResponse)
	return C.CString(string(csvResponseStr))
}

// WriteRows 写入/覆盖行数据
//
//export WriteRows
func WriteRows(handleID C.int, rowsData *C.char) *C.char {
	var csvResponse CSVResponse
	goHandleID := int64(handleID)
	goRowsData := C.GoString(rowsData)
	// json解析
	var data [][]string
	err := json.Unmarshal([]byte(goRowsData), &data)
	if err != nil {
		csvResponse = CSVResponse{
			Success: false,
			Message: fmt.Sprintf("rowsData JSON解析失败: %v", err),
		}
		csvResponseStr, _ := json.Marshal(csvResponse)
		return C.CString(string(csvResponseStr))
	}
	// 写入数据
	rows, err := GetManager().AppendRows(goHandleID, data)
	response := struct {
		TotalRows int64 `json:"totalRows"`
	}{
		TotalRows: rows,
	}
	if err != nil {
		csvResponse = CSVResponse{
			Success: false,
			Message: err.Error(),
		}
	} else {
		csvResponse = CSVResponse{
			Success: true,
			Data:    response,
		}
	}
	csvResponseStr, _ := json.Marshal(csvResponse)
	return C.CString(string(csvResponseStr))
}

// WriteRowsNum 写入/覆盖行数据
//
//export WriteRowsNum
func WriteRowsNum(handleID C.int, rowsData *C.char) *C.char {
	var csvResponse CSVResponse
	goHandleID := int64(handleID)
	goRowsData := C.GoString(rowsData)
	// json解析
	var data [][]string
	err := json.Unmarshal([]byte(goRowsData), &data)
	if err != nil {
		csvResponse = CSVResponse{
			Success: false,
			Message: fmt.Sprintf("rowsData JSON解析失败: %v", err),
		}
		csvResponseStr, _ := json.Marshal(csvResponse)
		return C.CString(string(csvResponseStr))
	}
	// 写入数据
	rowsNum, err := GetManager().AppendRowsNum(goHandleID, data)
	response := struct {
		RowsNum []int64 `json:"rowsNum"`
	}{
		RowsNum: rowsNum,
	}
	if err != nil {
		csvResponse = CSVResponse{
			Success: false,
			Message: err.Error(),
		}
	} else {
		csvResponse = CSVResponse{
			Success: true,
			Data:    response,
		}
	}
	csvResponseStr, _ := json.Marshal(csvResponse)
	return C.CString(string(csvResponseStr))
}

// UpdateRow C导出函数 - 修改指定行数据
//
//export UpdateRow
func UpdateRow(handleID C.int, rowNumber C.int, rowData *C.char) *C.char {
	var csvResponse CSVResponse
	goHandleID := int64(handleID)
	goRowNumber := int64(rowNumber)
	goRowData := C.GoString(rowData)

	// JSON解析行数据
	var data []string
	err := json.Unmarshal([]byte(goRowData), &data)
	if err != nil {
		csvResponse = CSVResponse{
			Success: false,
			Message: fmt.Sprintf("rowsData JSON解析失败: %v", err),
		}
		csvResponseStr, _ := json.Marshal(csvResponse)
		return C.CString(string(csvResponseStr))
	}
	// 修改行数据
	err = GetManager().UpdateRow(goHandleID, goRowNumber, data)
	if err != nil {
		csvResponse = CSVResponse{
			Success: false,
			Message: err.Error(),
		}
	} else {
		csvResponse = CSVResponse{
			Success: true,
			Message: fmt.Sprintf("成功修改第%d行数据", goRowNumber),
		}
	}
	csvResponseStr, _ := json.Marshal(csvResponse)
	return C.CString(string(csvResponseStr))
}

// GetRow C导出函数 - 获取指定行数据
//
//export GetRow
func GetRow(handleID C.int, rowNumber C.int) *C.char {
	goHandleID := int64(handleID)
	goRowNumber := int64(rowNumber)

	// 获取行数据
	rowData, err := GetManager().GetRow(goHandleID, goRowNumber)
	var csvResponse CSVResponse
	if err != nil {
		csvResponse = CSVResponse{
			Success: false,
			Message: err.Error(),
		}
	} else {
		csvResponse = CSVResponse{
			Success: true,
			Data:    rowData,
		}
	}

	csvResponseStr, _ := json.Marshal(csvResponse)
	return C.CString(string(csvResponseStr))
}

// MergeCSVFilesSimple 合并两个csv文件
//
//export MergeCSVFilesSimple
func MergeCSVFilesSimple(srcHandleID, dstHandleID, appendMode C.int) *C.char {
	var csvResponse CSVResponse
	goSrcHandleID := int64(srcHandleID)
	goDstHandleID := int64(dstHandleID)
	goAppendMode := int(appendMode)
	rows, err := GetManager().MergeCSVFilesSimple(goSrcHandleID, goDstHandleID, goAppendMode == 0)
	response := struct {
		TotalRows int64 `json:"totalRows"`
	}{
		TotalRows: rows,
	}
	if err != nil {
		csvResponse = CSVResponse{
			Success: false,
			Message: err.Error(),
		}
	} else {
		csvResponse = CSVResponse{
			Success: true,
			Data:    response,
		}
	}
	csvResponseStr, _ := json.Marshal(csvResponse)
	return C.CString(string(csvResponseStr))
}

// CloseHandles 关闭指定句柄（使用优雅关闭）
//
//export CloseHandles
func CloseHandles(handleID C.int) *C.char {
	goHandleID := int64(handleID)

	// 使用优雅关闭
	err := GetManager().CloseHandle(goHandleID)

	var csvResponse CSVResponse
	if err != nil {
		csvResponse = CSVResponse{
			Success: false,
			Message: err.Error(),
		}
	} else {
		csvResponse = CSVResponse{
			Success: true,
			Message: fmt.Sprintf("成功关闭句柄 %d", goHandleID),
		}
	}

	csvResponseStr, _ := json.Marshal(csvResponse)
	return C.CString(string(csvResponseStr))
}

// CloseAllHandles 关闭所有句柄
//
//export CloseAllHandles
func CloseAllHandles() *C.char {
	GetManager().closeAllHandles()

	csvResponse := CSVResponse{
		Success: true,
		Message: "成功关闭所有句柄",
	}

	csvResponseStr, _ := json.Marshal(csvResponse)
	return C.CString(string(csvResponseStr))
}

// FreeCString 释放C字符串内存
//
//export FreeCString
func FreeCString(str *C.char) {
	C.free(unsafe.Pointer(str))
}

// 主函数
//func main() {
//}