beancount-gs/script/bql.go

package script

import (
	"bytes"
	"encoding/csv"
	"encoding/json"
	"fmt"
	"log"
	"os"
	"os/exec"
	"path/filepath"
	"reflect"
	"runtime"
	"strconv"
	"strings"

	"github.com/gin-gonic/gin"
)

// 调试模式下的错误处理
// 修改 handleError 函数中的提示
// handleError 处理错误，根据调试模式决定处理方式：
// - 调试模式下 panic 抛出错误
// - 生产环境下记录警告日志
// 参数：
//
//	err: 错误对象
//	message: 自定义错误信息
func handleError(err error, message string) {
	if IsDebugMode() {
		panic(fmt.Sprintf("%s: %v", message, err))
	} else {
		// 生产环境下记录警告日志
		log.Printf("警告: %s: %v", message, err)
	}
}

/*
QueryParams 结构体定义了查询参数，包含多个字段用于构建查询条件。
每个字段都带有 bql 标签，用于指定在 BQL 查询中的对应字段名。
*/
type QueryParams struct {
	From               bool   `bql:"From"`             // 是否包含 From 子句
	FromYear           int    `bql:"year ="`           // From 子句中的年份条件
	FromMonth          int    `bql:"month ="`          // From 子句中的月份条件
	Where              bool   `bql:"where"`            // 是否包含 Where 子句
	ID                 string `bql:"id ="`             // ID 等于条件
	IDList             string `bql:"id in"`            // ID 列表条件
	Currency           string `bql:"currency ="`       // 货币等于条件
	Year               int    `bql:"year ="`           // 年份等于条件
	Month              int    `bql:"month ="`          // 月份等于条件
	Tag                string `bql:"in tags"`          // 用于 tag in tags 条件
	TagNotNull         string `bql:"tags IS NOT NULL"` // 标签非空条件
	Account            string `bql:"account ="`        // 账户等于条件
	AccountLike        string `bql:"account ~"`        // 账户模糊匹配条件
	StrictAccountMatch bool   // true表示账户必须使用精确匹配，false表示使用模糊匹配
	GroupBy            string `bql:"group by"` // 分组条件
	OrderBy            string `bql:"order by"` // 排序条件
	Limit              int    `bql:"limit"`    // 限制结果数量
	Path               string // 查询路径
	Offset             int    // 查询偏移量
	DateRange          bool   // 启用日期范围查询
}

// HasConditions 检查查询参数是否包含任何条件
// 返回 true 如果 Year, Month, Account, AccountLike, Tag, ID 或 Currency 任一字段不为零值
func (queryParams *QueryParams) HasConditions() bool {
	return queryParams.Year != 0 || queryParams.Month != 0 ||
		queryParams.Account != "" || queryParams.AccountLike != "" ||
		queryParams.Tag != "" || queryParams.ID != "" ||
		queryParams.Currency != ""
}

// GetQueryParams 从 gin.Context 中解析查询参数并返回 QueryParams 结构体
// 支持以下查询参数：
//   - year/month: 数值型参数，用于时间范围筛选
//   - tag/account/type/id/idList/currency/path: 字符串型参数
//   - groupBy/orderBy: 分组和排序参数
//   - limit: 限制返回结果数量
//   - strictMode: 布尔值，控制账户匹配模式（精确/模糊）
//
// 默认值：
//   - StrictAccountMatch: true (精确匹配)
//   - OrderBy: "date desc"
//   - Limit: 100
//   - Year/Month: 0 (表示不限制)
//
// 注意：所有参数都会经过有效性检查（非空且不为"undefined"/"null"）
func GetQueryParams(c *gin.Context) QueryParams {
	queryParams := QueryParams{
		StrictAccountMatch: true,
		OrderBy:            "date desc",
		Limit:              100,
	}

	// 辅助函数检查有效值
	isValidParam := func(val string) bool {
		return val != "" && val != "undefined" && val != "null" && val != "None"
	}

	// 数值型条件
	if year := c.Query("year"); isValidParam(year) {
		if val, err := strconv.Atoi(year); err == nil && val > 0 {
			queryParams.Year = val
			DebugLogWithContext("GetQueryParams", "设置有效年份: %d", val)
		} else {
			WarnLogWithContext("GetQueryParams", "无效年份参数: %s", year)
		}
	}

	if month := c.Query("month"); isValidParam(month) {
		if val, err := strconv.Atoi(month); err == nil && val > 0 && val <= 12 {
			queryParams.Month = val
			DebugLogWithContext("GetQueryParams", "设置有效月份: %d", val)
		} else {
			WarnLogWithContext("GetQueryParams", "无效月份参数: %s", month)
		}
	}

	// 字符串条件
	setStringParam := func(param *string, queryKey string) {
		if val := c.Query(queryKey); isValidParam(val) {
			*param = val
			DebugLogWithContext("GetQueryParams", "设置%s: %s", queryKey, val)
		}
	}

	setStringParam(&queryParams.Tag, "tag")
	setStringParam(&queryParams.Account, "account")
	setStringParam(&queryParams.ID, "id")
	setStringParam(&queryParams.IDList, "idList")
	setStringParam(&queryParams.Currency, "currency")
	setStringParam(&queryParams.Path, "path")
	setStringParam(&queryParams.GroupBy, "groupBy")

	// 特殊处理type参数
	if accType := c.Query("type"); isValidParam(accType) {
		queryParams.AccountLike = accType
		queryParams.StrictAccountMatch = false
		DebugLogWithContext("GetQueryParams", "设置账户类型(模糊匹配): %s", accType)
	}

	// 处理排序参数
	if orderBy := c.Query("orderBy"); isValidParam(orderBy) {
		queryParams.OrderBy = orderBy
	} else if queryParams.Year > 0 || queryParams.Month > 0 {
		queryParams.OrderBy = "year desc, month desc"
	}

	// 处理limit参数
	if limit := c.Query("limit"); isValidParam(limit) {
		if val, err := strconv.Atoi(limit); err == nil && val > 0 {
			queryParams.Limit = val
		}
	}

	// 处理严格模式参数
	if strictMode := c.Query("strictMode"); isValidParam(strictMode) {
		if strict, err := strconv.ParseBool(strictMode); err == nil {
			queryParams.StrictAccountMatch = strict
			DebugLogWithContext("GetQueryParams", "设置严格模式: %t", strict)
		}
	}

	// 验证必要参数
	if queryParams.Year == 0 && queryParams.Month == 0 &&
		queryParams.Account == "" && queryParams.AccountLike == "" {
		WarnLogWithContext("GetQueryParams", "缺少必要查询参数")
	}

	queryParams.Where = queryParams.HasConditions()
	return queryParams
}

//func BQLQueryOne(ledgerConfig *Config, queryParams *QueryParams, queryResultPtr interface{}) error {
//	assertQueryResultIsPointer(queryResultPtr)
//	output, err := bqlRawQuery(ledgerConfig, "", queryParams, queryResultPtr)
//	if err != nil {
//		return err
//	}
//	err = parseResult(output, queryResultPtr, true)
//	if err != nil {
//		return err
//	}
//	return nil
//}

func BQLPrint(ledgerConfig *Config, transactionId string) (string, error) {
	// PRINT FROM id = 'xxx'
	output, err := queryByBQL(ledgerConfig, "PRINT FROM id = '"+transactionId+"'")
	if err != nil {
		return "", err
	}
	utf8, err := ConvertGBKToUTF8(output)
	if err != nil {
		return "", err
	}
	return utf8, nil
}

// BQLQueryList 执行BQL查询并将结果解析到指定的指针中
//
// 参数:
//
//	ledgerConfig: 账本配置信息
//	queryParams: 查询参数
//	queryResultPtr: 指向查询结果容器的指针，必须是指针类型
//
// 返回值:
//
//	error: 如果查询或解析过程中发生错误，返回错误信息
//
// 注意:
//  1. 函数内部包含详细的调试日志，可通过调试模式控制
//  2. queryResultPtr 必须是指针类型，否则会触发断言错误
//  3. 输出结果会被自动解析到queryResultPtr指向的变量中
func BQLQueryList(ledgerConfig *Config, queryParams *QueryParams, queryResultPtr interface{}) error {
	// 调试模式设置，默认为true（开启调试模式）

	// 调试信息：函数开始执行
	LogDebugDetailed(ledgerConfig.Mail, "BQLQueryList",
		"函数开始执行\n----------------------\n输入查询参数: %+v\n----------------------\nqueryResultPtr 类型: %T",
		queryParams, queryResultPtr)

	assertQueryResultIsPointer(queryResultPtr)

	// 调试信息：执行bqlRawQuery前
	LogDebugDetailed(ledgerConfig.Mail, "BQLQuery",
		"正在执行 bqlRawQuery...")

	output, err := bqlRawQuery(ledgerConfig, "", queryParams, queryResultPtr)

	// 调试信息：bqlRawQuery执行结果
	if err != nil {
		LogError(ledgerConfig.Mail,
			fmt.Sprintf("bqlRawQuery执行失败: %v", err))
		return fmt.Errorf("BQL查询失败: %v", err)
	} else {
		// 限制输出长度，避免日志过大
		outputPreview := output
		if len(output) > 500 {
			outputPreview = output[:500] + "... (输出被截断)"
		}
		LogDebugDetailed(ledgerConfig.Mail, "BQLQuery",
			"bqlRawQuery执行成功，输出预览: %s", outputPreview)
	}

	// 调试信息：执行parseResult前
	LogDebugDetailed(ledgerConfig.Mail, "BQLQuery",
		"正在使用parseResult解析查询结果...")

	parseErr := parseResult(output, queryResultPtr, false)

	// 调试信息：parseResult执行结果
	if parseErr != nil {
		LogDebugDetailed(ledgerConfig.Mail, "BQLParse",
			"parseResult解析失败: %v", parseErr)
	} else {
		resultValue := reflect.ValueOf(queryResultPtr).Elem()
		logMessage := fmt.Sprintf("parseResult解析成功\n结果类型: %s\n种类: %s",
			resultValue.Type().String(),
			resultValue.Kind().String())

		if resultValue.Kind() == reflect.Slice {
			logMessage += fmt.Sprintf("\n结果包含 %d 个项目", resultValue.Len())
		}

		LogDebugDetailed(ledgerConfig.Mail, "BQLParse", logMessage)
	}

	return parseErr
}

func BQLQueryListByCustomSelect(ledgerConfig *Config, selectBql string, queryParams *QueryParams, queryResultPtr interface{}) error {
	const contextTag = "QueryListByCustomSelect"

	// 调试信息：函数开始执行
	LogBQLQueryDebug(ledgerConfig.Mail, contextTag,
		"函数开始执行\n自定义 selectBql: %s\n输入查询参数: %+v\nqueryResultPtr 类型: %T",
		selectBql, queryParams, queryResultPtr)

	assertQueryResultIsPointer(queryResultPtr)

	// 调试信息：执行bqlRawQuery前
	LogBQLQueryDebug(ledgerConfig.Mail, contextTag, "正在执行 bqlRawQuery...")

	output, err := bqlRawQuery(ledgerConfig, selectBql, queryParams, queryResultPtr)

	// 调试信息：bqlRawQuery执行结果
	if err != nil {
		LogBQLQueryDebug(ledgerConfig.Mail, contextTag, "bqlRawQuery 执行失败: %v", err)
	} else {
		// 限制输出长度，避免日志过大
		outputPreview := output
		if len(output) > 500 {
			outputPreview = output[:500] + "... (输出被截断)"
		}
		LogBQLQueryDebug(ledgerConfig.Mail, contextTag,
			"bqlRawQuery 执行成功，输出预览: %s", outputPreview)
	}

	if err != nil {
		errorMsg := fmt.Sprintf("BQL:%s - 自定义 BQL 查询失败: %v", contextTag, err)
		LogError(ledgerConfig.Mail, errorMsg)
		return fmt.Errorf("自定义 BQL 查询失败: %v", err)
	}

	// 调试信息：执行parseResult前
	LogBQLQueryDebug(ledgerConfig.Mail, contextTag, "正在调用parseResult解析查询结果...")

	parseErr := parseResult(output, queryResultPtr, false)

	// 调试信息：parseResult执行结果
	if parseErr != nil {
		LogBQLQueryDebug(ledgerConfig.Mail, contextTag, "parseResult 解析失败: %v", parseErr)
	} else {
		resultValue := reflect.ValueOf(queryResultPtr).Elem()
		LogBQLQueryDebug(ledgerConfig.Mail, contextTag,
			"parseResult 解析成功\n结果类型: %s\n种类: %s",
			resultValue.Type().String(), resultValue.Kind().String())

		if resultValue.Kind() == reflect.Slice {
			LogBQLQueryDebug(ledgerConfig.Mail, contextTag,
				"结果包含 %d 个项目", resultValue.Len())
		}
	}

	return parseErr
}

func bqlRawQuery(ledgerConfig *Config, selectBql string, queryParamsPtr *QueryParams, queryResultPtr interface{}) (string, error) {
	LogDebugDetailed(ledgerConfig.Mail, "BQLBuilder",
		"=== 开始构建BQL查询 ===\n输入参数: selectBql='%s'\nqueryParamsPtr=%+v",
		selectBql, queryParamsPtr)

	var bql strings.Builder

	// 1. SELECT 部分
	if selectBql == "" {
		LogDebugDetailed(ledgerConfig.Mail, "BQLBuilder", "自动生成SELECT字段...")
		bql.WriteString("SELECT ")

		queryResultPtrType := reflect.TypeOf(queryResultPtr)
		queryResultType := queryResultPtrType.Elem()
		if queryResultType.Kind() == reflect.Slice {
			queryResultType = queryResultType.Elem()
		}

		first := true
		for i := 0; i < queryResultType.NumField(); i++ {
			typeField := queryResultType.Field(i)
			if b := typeField.Tag.Get("bql"); b != "" {
				if !first {
					bql.WriteString(", ")
				}
				if strings.Contains(b, "distinct") {
					b = strings.ReplaceAll(b, "distinct", "")
					bql.WriteString("DISTINCT ")
				}
				bql.WriteString(b)
				// 保留反斜线作为分隔符
				bql.WriteString(", '\\'")
				first = false
			}
		}
		LogDebugDetailed(ledgerConfig.Mail, "BQLBuilder", "生成的SELECT部分: %s", bql.String())
	} else {
		bql.WriteString(selectBql)
	}

	// 2. 记录WHERE条件构建
	if queryParamsPtr != nil {
		LogDebugDetailed(ledgerConfig.Mail, "BQLBuilder",
			"正在解析和构建WHERE条件子句...")
		// queryParamsType := reflect.TypeOf(queryParamsPtr).Elem()
		// queryParamsValue := reflect.ValueOf(queryParamsPtr).Elem()

		hasConditions := false
		// firstCondition := true

		// 检查是否有实际条件
		if (queryParamsPtr.Year != 0 || queryParamsPtr.Month != 0) || // 时间条件
			(queryParamsPtr.AccountLike != "" || queryParamsPtr.Tag != "") || // 账户/标签条件
			(queryParamsPtr.ID != "" || queryParamsPtr.Currency != "") { // ID/货币条件
			hasConditions = true
		}

		if hasConditions {
			// 账户匹配方式验证
			if queryParamsPtr.Account != "" && queryParamsPtr.AccountLike != "" {
				LogError(ledgerConfig.Mail,
					fmt.Sprintf("参数冲突: Account='%s' 和 AccountLike='%s' 不能同时指定",
						queryParamsPtr.Account, queryParamsPtr.AccountLike))
				return "", fmt.Errorf("不能同时指定Account和AccountLike参数")
			}

			if queryParamsPtr.StrictAccountMatch && queryParamsPtr.AccountLike != "" {
				LogError(ledgerConfig.Mail,
					fmt.Sprintf("参数冲突: StrictAccountMatch=%v 但指定了AccountLike='%s'",
						queryParamsPtr.StrictAccountMatch, queryParamsPtr.AccountLike))
				return "", fmt.Errorf("StrictAccountMatch模式下不能使用AccountLike")
			}

			if !queryParamsPtr.StrictAccountMatch && queryParamsPtr.Account != "" {
				LogError(ledgerConfig.Mail,
					fmt.Sprintf("参数冲突: StrictAccountMatch=%v 但指定了Account='%s' (应使用AccountLike)",
						queryParamsPtr.StrictAccountMatch, queryParamsPtr.Account))
				return "", fmt.Errorf("非StrictAccountMatch模式下必须指定AccountLike")
			}

			LogDebugDetailed(ledgerConfig.Mail, "BQLBuilder",
				"构建前SQL: %s", bql.String())

			bql.WriteString(" WHERE ")
			firstCondition := true

			// 辅助函数添加条件
			addCondition := func(condition string) {
				if !firstCondition {
					bql.WriteString(" AND ")
				}
				bql.WriteString(condition)
				firstCondition = false
			}

			// 时间条件
			if queryParamsPtr.Year != 0 {
				addCondition(fmt.Sprintf("year = %d", queryParamsPtr.Year))
			}

			if queryParamsPtr.Month != 0 {
				addCondition(fmt.Sprintf("month = %d", queryParamsPtr.Month))
			}

			// 账户条件
			if queryParamsPtr.Account != "" {
				addCondition(fmt.Sprintf("account = '%s'", escapeSQLString(queryParamsPtr.Account)))
			} else if queryParamsPtr.AccountLike != "" {
				addCondition(fmt.Sprintf("account ~ '%s'", escapeSQLString(queryParamsPtr.AccountLike)))
			}

			// 其他条件
			if queryParamsPtr.Tag != "" {
				addCondition("tag in tags")
			}

			if queryParamsPtr.TagNotNull != "" {
				addCondition("tags IS NOT NULL")
			}

			if queryParamsPtr.ID != "" {
				addCondition(fmt.Sprintf("id = '%s'", escapeSQLString(queryParamsPtr.ID)))
			}

			LogDebugDetailed(ledgerConfig.Mail, "BQLBuilder",
				"构建后SQL: %s", bql.String())
		}
	}

	// 在构建GROUP BY子句前添加验证
	if queryParamsPtr != nil && queryParamsPtr.GroupBy != "" {
		// 检查是否有聚合函数
		hasAggregate := strings.Contains(bql.String(), "sum(") ||
			strings.Contains(bql.String(), "count(") ||
			strings.Contains(bql.String(), "avg(") ||
			strings.Contains(bql.String(), "min(") ||
			strings.Contains(bql.String(), "max(")

		if hasAggregate {
			LogDebugDetailed(ledgerConfig.Mail, "BQLBuilder-GroupBy", "BQL查询包含聚合函数，将添加GROUP BY子句")
			bql.WriteString(" GROUP BY ")
			bql.WriteString(queryParamsPtr.GroupBy)
		} else {
			LogDebugDetailed(ledgerConfig.Mail, "BQLBuilder-GroupBy", "BQL查询不包含聚合函数，但是指定了GROUP BY子句，将仍然添加GROUP BY子句")
			bql.WriteString(" GROUP BY ")
			bql.WriteString(queryParamsPtr.GroupBy)
		}
	}

	// 构建 ORDER BY 子句
	if queryParamsPtr != nil && queryParamsPtr.OrderBy != "" {
		bql.WriteString(" ORDER BY ")
		orderBy := strings.ReplaceAll(queryParamsPtr.OrderBy, "'", "")
		orderBy = strings.ReplaceAll(orderBy, "\"", "")
		orderBy = strings.ReplaceAll(strings.ToLower(orderBy), "order by", "")
		orderBy = strings.TrimSpace(orderBy)
		bql.WriteString(orderBy)
	}

	// 构建 LIMIT 子句
	if queryParamsPtr != nil && queryParamsPtr.Limit > 0 {
		bql.WriteString(" LIMIT ")
		bql.WriteString(strconv.Itoa(queryParamsPtr.Limit))
	}

	finalQuery := bql.String()
	LogDebugDetailed(ledgerConfig.Mail, "BQLGenerator",
		"=== 最终生成的BQL ===\n%s", finalQuery)

	if strings.Contains(finalQuery, "WHERE") && strings.Contains(finalQuery, "GROUP BY") {
		if strings.Index(finalQuery, "WHERE") > strings.Index(finalQuery, "GROUP BY") {
			return "", fmt.Errorf("SQL语法错误: WHERE子句必须在GROUP BY之前")
		}
	}

	// 验证生成的SQL
	if strings.Contains(finalQuery, "WHERE  AND") {
		LogError(ledgerConfig.Mail, "!!! 检测到非法WHERE条件: "+finalQuery)
		return "", fmt.Errorf("invalid WHERE clause")
	}
	LogDebugDetailed(ledgerConfig.Mail, "BQLGenerator",
		"=== 最终生成的BQL语句 ===\n%s", finalQuery)
	return queryByBQL(ledgerConfig, finalQuery)
}

// 辅助函数：安全转义 SQL 字符串
func escapeSQLString(s string) string {
	// 只转义单引号，不处理反斜杠
	return strings.ReplaceAll(s, "'", "''")
}

// 修改 BeanReportAllPrices 函数
func BeanReportAllPrices(ledgerConfig *Config) []CommodityPrice {
	// 使用正确的 BQL 查询，不需要 FROM 子句
	output, err := queryByBQL(ledgerConfig,
		"SELECT date, 'price', currency, price WHERE price is not NULL")
	if err != nil {
		LogError(ledgerConfig.Mail, "Failed to query prices: "+err.Error())
		return nil
	}

	// 解析 CSV 输出
	reader := csv.NewReader(strings.NewReader(output))
	records, err := reader.ReadAll()
	if err != nil {
		LogError(ledgerConfig.Mail, "Failed to parse CSV: "+err.Error())
		return nil
	}

	// 将 [][]string 转换为 []string
	var lines []string
	if len(records) > 0 {
		// 跳过标题行
		for _, record := range records[1:] {
			lines = append(lines, strings.Join(record, " "))
		}
	}

	return newCommodityPriceListFromString(lines)
}

// 修改 parseResult 函数中的相关部分
func parseCsvResult(output string, queryResultPtr interface{}, selectOne bool) error {
	queryResultPtrType := reflect.TypeOf(queryResultPtr)
	queryResultType := queryResultPtrType.Elem()

	if queryResultType.Kind() == reflect.Slice {
		queryResultType = queryResultType.Elem()
	}

	// 使用 csv 解析器处理输出
	reader := csv.NewReader(strings.NewReader(output))
	records, err := reader.ReadAll()
	if err != nil {
		return err
	}

	// 跳过标题行
	if len(records) > 0 {
		records = records[1:]
	}

	if selectOne && len(records) > 0 {
		records = records[:1]
	}

	l := make([]map[string]interface{}, 0)
	for _, record := range records {
		if len(record) == 0 {
			continue
		}

		temp := make(map[string]interface{})
		for i, val := range record {
			if i >= queryResultType.NumField() {
				continue
			}

			field := queryResultType.Field(i)
			jsonName := field.Tag.Get("json")
			if jsonName == "" {
				jsonName = field.Name
			}

			val = strings.TrimSpace(val)
			if val == "" {
				continue
			}

			switch field.Type.Kind() {
			case reflect.Int, reflect.Int32:
				if i, err := strconv.Atoi(val); err == nil {
					temp[jsonName] = i
				}
			case reflect.String:
				temp[jsonName] = val
			case reflect.Float32, reflect.Float64:
				if f, err := strconv.ParseFloat(val, 64); err == nil {
					temp[jsonName] = f
				}
			case reflect.Array, reflect.Slice:
				strArray := strings.Split(val, ",")
				notBlanks := make([]string, 0)
				for _, s := range strArray {
					if s = strings.TrimSpace(s); s != "" {
						notBlanks = append(notBlanks, s)
					}
				}
				if len(notBlanks) > 0 {
					temp[jsonName] = notBlanks
				}
			}
		}
		if len(temp) > 0 {
			l = append(l, temp)
		}
	}

	var jsonBytes []byte
	var jsonErr error // 修改变量名，避免重复声明
	if selectOne && len(l) > 0 {
		jsonBytes, jsonErr = json.Marshal(l[0])
	} else {
		jsonBytes, jsonErr = json.Marshal(l)
	}
	if jsonErr != nil {
		return jsonErr
	}
	err = json.Unmarshal(jsonBytes, queryResultPtr) // 使用外层的 err
	if err != nil {
		return err
	}
	return nil
}

// 原v2版本格式数据导入函数
// 主解析函数 - 智能识别格式
func parseResult(output string, queryResultPtr interface{}, selectOne bool) error {

	lines := strings.Split(strings.TrimSpace(output), "\n")
	if len(lines) == 0 {
		return nil // 空输出
	}

	// 检测格式类型
	isCustomFormat := false
	for _, line := range lines {
		if strings.Contains(line, "\\") || strings.Contains(line, "'") {
			isCustomFormat = true
			break
		}
		if IsDebugMode() {
			log.Printf("line: %s", line)
			log.Println("isCustomFormat:", isCustomFormat)
		}
	}

	if isCustomFormat {
		if IsDebugMode() {
			log.Println("使用自定义分隔符//解析逻辑")
		}
		// 使用自定义分隔符解析逻辑
		return parseCustomFormat(output, queryResultPtr, selectOne)
	} else {
		if IsDebugMode() {
			log.Println("使用表格格式解析逻辑")
		}
		// 使用表格格式解析逻辑
		return parseTableFormat(output, queryResultPtr, selectOne)
	}
}

// 解析自定义分隔符格式（原v2格式）
func parseCustomFormat(output string, queryResultPtr interface{}, selectOne bool) error {
	queryResultPtrType := reflect.TypeOf(queryResultPtr)
	queryResultType := queryResultPtrType.Elem()

	if queryResultType.Kind() == reflect.Slice {
		queryResultType = queryResultType.Elem()
	}

	lines := strings.Split(output, "\n")

	// 跳过标题行（如果有）
	var dataLines []string
	if len(lines) >= 3 && strings.Contains(lines[1], "-") {
		dataLines = lines[2:] // 跳过前2行（标题和分隔线）
	} else {
		dataLines = lines // 没有标准标题格式
	}

	l := make([]map[string]interface{}, 0)
	for _, line := range dataLines {
		line = strings.TrimSpace(line)
		if line == "" {
			continue
		}

		values := strings.Split(line, "\\")

		// 安全地去除首尾空元素
		var cleanedValues []string
		for _, val := range values {
			trimmed := strings.TrimSpace(val)
			if trimmed != "" {
				cleanedValues = append(cleanedValues, trimmed)
			}
		}

		// 如果cleanedValues为空，跳过这行
		if len(cleanedValues) == 0 {
			continue
		}

		temp := make(map[string]interface{})
		for i, val := range cleanedValues {
			if i >= queryResultType.NumField() {
				break // 跳过多余的字段
			}

			field := queryResultType.Field(i)
			jsonName := field.Tag.Get("json")
			if jsonName == "" {
				jsonName = field.Name
			}

			val = strings.TrimSpace(val)
			if val == "" {
				continue
			}

			// 添加tags/payee字段的专门调试
			if jsonName == "tags" && IsDebugMode() {
				DebugLogWithContext("TAGS", "解析tags字段值: %s", val)
			}
			if jsonName == "payee" && IsDebugMode() {
				// DebugLogWithContext("PAYEE", "解析payee字段值: %s", val)
			}

			switch field.Type.Kind() {
			case reflect.Int, reflect.Int32:
				if intVal, err := strconv.Atoi(val); err != nil {
					handleError(err, fmt.Sprintf("解析整数值 '%s' 失败", val))
				} else {
					temp[jsonName] = intVal
				}
			case reflect.String, reflect.Struct:
				temp[jsonName] = val
			case reflect.Array, reflect.Slice:
				strArray := strings.Split(val, ",")
				notBlanks := make([]string, 0)
				for _, s := range strArray {
					if trimmed := strings.TrimSpace(s); trimmed != "" {
						notBlanks = append(notBlanks, trimmed)
					}
				}
				if len(notBlanks) > 0 {
					temp[jsonName] = notBlanks
				}
			default:
				if IsDebugMode() {
					panic(fmt.Sprintf("Unsupported field type: %s", field.Type.Kind()))
				}
			}
		}

		if len(temp) > 0 {
			l = append(l, temp)
		}
	}

	return marshalAndUnmarshal(l, queryResultPtr, selectOne)
}

// 解析表格格式（bean-query默认格式）
func parseTableFormat(output string, queryResultPtr interface{}, selectOne bool) error {
	queryResultPtrType := reflect.TypeOf(queryResultPtr)
	queryResultType := queryResultPtrType.Elem()

	if queryResultType.Kind() == reflect.Slice {
		queryResultType = queryResultType.Elem()
	}

	lines := strings.Split(strings.TrimSpace(output), "\n")

	// 检测并跳过标题行和分隔线
	var dataLines []string
	if len(lines) >= 3 && strings.Contains(lines[1], "-") {
		dataLines = lines[2:] // 跳过前2行
	} else if len(lines) >= 2 && strings.Contains(lines[0], "|") {
		dataLines = lines[1:] // 跳过标题行
	} else {
		dataLines = lines // 没有标准标题
	}

	l := make([]map[string]interface{}, 0)
	for _, line := range dataLines {
		line = strings.TrimSpace(line)
		if line == "" {
			continue
		}

		// 按 | 分割表格格式
		values := strings.Split(line, "|")
		var cleanedValues []string
		for _, val := range values {
			trimmed := strings.TrimSpace(val)
			if trimmed != "" {
				cleanedValues = append(cleanedValues, trimmed)
			}
		}

		if len(cleanedValues) == 0 {
			continue
		}

		temp := make(map[string]interface{})
		for i, val := range cleanedValues {
			if i >= queryResultType.NumField() {
				break
			}

			field := queryResultType.Field(i)
			jsonName := field.Tag.Get("json")
			if jsonName == "" {
				jsonName = field.Name
			}

			val = strings.TrimSpace(val)
			if val == "" {
				continue
			}

			switch field.Type.Kind() {
			case reflect.Int, reflect.Int32:
				if intVal, err := strconv.Atoi(val); err != nil {
					handleError(err, fmt.Sprintf("解析整数值 '%s' 失败", val))
				} else {
					temp[jsonName] = intVal
				}
			case reflect.String, reflect.Struct:
				temp[jsonName] = val
			case reflect.Float32, reflect.Float64:
				if floatVal, err := strconv.ParseFloat(val, 64); err != nil {
					handleError(err, fmt.Sprintf("解析浮点数值 '%s' 失败", val))
				} else {
					temp[jsonName] = floatVal
				}
			case reflect.Array, reflect.Slice:
				strArray := strings.Split(val, ",")
				notBlanks := make([]string, 0)
				for _, s := range strArray {
					if trimmed := strings.TrimSpace(s); trimmed != "" {
						notBlanks = append(notBlanks, trimmed)
					}
				}
				if len(notBlanks) > 0 {
					temp[jsonName] = notBlanks
				}
			default:
				if IsDebugMode() {
					panic(fmt.Sprintf("Unsupported field type: %s", field.Type.Kind()))
				}
			}
		}

		if len(temp) > 0 {
			l = append(l, temp)
		}
	}

	return marshalAndUnmarshal(l, queryResultPtr, selectOne)
}

// 通用的JSON序列化和反序列化
// 通用的JSON序列化和反序列化
func marshalAndUnmarshal(data []map[string]interface{}, queryResultPtr interface{}, selectOne bool) error {
	if len(data) == 0 {
		// 对于空结果，设置默认值
		if selectOne {
			if IsDebugMode() {
				panic("selectOne 查询没有找到结果")
			}
			return fmt.Errorf("selectOne 查询没有找到结果")
		}
		// 对于切片，返回空切片是合理的
	}

	var jsonBytes []byte
	var err error

	if selectOne {
		if len(data) == 0 {
			if IsDebugMode() {
				panic("selectOne 查询没有找到结果")
			}
			return fmt.Errorf("selectOne 查询没有找到结果")
		}
		jsonBytes, err = json.Marshal(data[0])
	} else {
		jsonBytes, err = json.Marshal(data)
	}

	if err != nil {
		handleError(err, "JSON 序列化失败")
		return err
	}

	err = json.Unmarshal(jsonBytes, queryResultPtr)
	if err != nil {
		handleError(err, "JSON 反序列化失败")
		return err
	}

	return nil
}

// 直接调用v3版本的bean-query命令，返回beancount专用表格格式
func queryByBQL(ledgerConfig *Config, bql string) (string, error) {
	beanFilePath := ledgerConfig.DataPath + "/index.bean"
	LogInfo(ledgerConfig.Mail, fmt.Sprintf("[BQLExecution] 查询语句: %s", bql))

	// 获取虚拟环境执行器
	executor := GetVenvExecutor()
	if executor == nil {
		// 降级方案：使用原来的逻辑但修复路径
		return queryByBQLFallback(beanFilePath, bql)
	}

	// 使用虚拟环境工具执行 bean-query
	output, err := executor.BeanQueryStdout(beanFilePath, bql)
	if err != nil {
		errorMsg := fmt.Sprintf("bean-query执行失败 - 错误详情: %v", err)
		LogError(ledgerConfig.Mail, errorMsg)
		return "", fmt.Errorf("bean-query 执行失败: %v", err)
	}
	return string(output), nil
}

// 降级方案，确保即使虚拟环境工具有问题也能工作
func queryByBQLFallback(beanFilePath, bql string) (string, error) {
	var cmdPath string
	if runtime.GOOS == "windows" {
		cmdPath = ".env_beancount-v3/Scripts/bean-query.exe"
	} else {
		cmdPath = ".env_beancount-v3/bin/bean-query"
	}

	// 检查文件是否存在
	if _, err := os.Stat(cmdPath); os.IsNotExist(err) {
		return "", fmt.Errorf("bean-query 未找到: %s", cmdPath)
	}

	cmd := exec.Command(cmdPath, beanFilePath, bql)
	output, err := cmd.Output()
	if err != nil {
		return "", fmt.Errorf("bean-query 执行错误: %v", err)
	}
	return string(output), nil
}

func assertQueryResultIsPointer(queryResult interface{}) {
	k := reflect.TypeOf(queryResult).Kind()
	if k != reflect.Ptr {
		panic("QueryResult 类型必须是指针，当前是 " + k.String())
	}
}