package services

import (
	"bytes"
	"context"
	"database/sql"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"net/http"
	"strconv"
	"strings"
	"sync"
	"time"

	"goalfymax-admin/internal/config"
	"goalfymax-admin/internal/notifier"
	"goalfymax-admin/internal/storage"
	pkgredis "goalfymax-admin/pkg/redis"

	mysqldriver "github.com/go-sql-driver/mysql"
	"github.com/google/uuid"
	"github.com/jackc/pgconn"
	"github.com/shopspring/decimal"
	"gorm.io/gorm"
)

type PageResult struct {
	List  []map[string]interface{} `json:"list"`
	Total int64                    `json:"total"`
}

var (
	usdScalingFactor                  = decimal.NewFromInt(100000000)
	lowBalanceThreshold               = decimal.NewFromInt(30) // 默认值30
	lowBalanceThresholdMutex          sync.RWMutex
	ErrMcpUsageJobAlreadyProcessed    = errors.New("mcp usage job already processed")
	ErrMcpUsageJobAlreadyInProgress   = errors.New("mcp usage job already in progress")
	ErrModelTokenJobAlreadyProcessed  = errors.New("model token job already processed")
	ErrModelTokenJobAlreadyInProgress = errors.New("model token job already in progress")
)

// GetLowBalanceThreshold 获取低余额阈值（线程安全）
func GetLowBalanceThreshold() decimal.Decimal {
	lowBalanceThresholdMutex.RLock()
	defer lowBalanceThresholdMutex.RUnlock()
	return lowBalanceThreshold
}

// RefreshLowBalanceThreshold 从系统配置刷新低余额阈值（定时任务执行前调用）
func RefreshLowBalanceThreshold() {
	const configKey = "low_balance_threshold"
	const defaultValue = 30

	// 创建系统配置服务实例
	systemConfigService := NewSystemConfigService(
		storage.NewSystemConfigStorage(),
		nil, // 不使用 logger
	)

	config, err := systemConfigService.GetByKey(configKey)
	if err != nil {
		// 配置不存在，使用默认值
		lowBalanceThresholdMutex.Lock()
		lowBalanceThreshold = decimal.NewFromInt(defaultValue)
		lowBalanceThresholdMutex.Unlock()
		return
	}

	// 解析配置值
	valueStr := strings.TrimSpace(config.Value)
	if valueStr == "" {
		// 值为空，使用默认值
		lowBalanceThresholdMutex.Lock()
		lowBalanceThreshold = decimal.NewFromInt(defaultValue)
		lowBalanceThresholdMutex.Unlock()
		return
	}

	// 尝试解析为整数
	valueInt, err := strconv.ParseInt(valueStr, 10, 64)
	if err != nil {
		// 解析失败，使用默认值
		lowBalanceThresholdMutex.Lock()
		lowBalanceThreshold = decimal.NewFromInt(defaultValue)
		lowBalanceThresholdMutex.Unlock()
		return
	}

	// 设置配置值
	lowBalanceThresholdMutex.Lock()
	lowBalanceThreshold = decimal.NewFromInt(valueInt)
	lowBalanceThresholdMutex.Unlock()
}

const (
	jobStatusPending = "pending"
	jobStatusSuccess = "success"
	jobStatusFailed  = "failed"

	mcpUsageJobName   = "mcp_usage_hourly_settlement"
	modelTokenJobName = "model_token_usage_hourly_settlement"
)

func toString(v interface{}) string {
	switch t := v.(type) {
	case []byte:
		return string(t)
	case string:
		return t
	default:
		return fmt.Sprintf("%v", v)
	}
}

func toInt(v interface{}) (int64, bool) {
	s := toString(v)
	if s == "" {
		return 0, false
	}
	n, err := strconv.ParseInt(s, 10, 64)
	if err != nil {
		return 0, false
	}
	return n, true
}

func toFloat(v interface{}) (float64, bool) {
	s := toString(v)
	if s == "" {
		return 0, false
	}
	f, err := strconv.ParseFloat(s, 64)
	if err != nil {
		return 0, false
	}
	return f, true
}

func toTimeISO(s interface{}) (string, bool) {
	str := toString(s)
	if str == "" {
		return "", false
	}
	// Try common layouts
	layouts := []string{
		time.RFC3339,
		"2006-01-02 15:04:05",
		"2006-01-02T15:04:05",
	}
	for _, l := range layouts {
		if tm, err := time.ParseInLocation(l, str, time.Local); err == nil {
			return tm.Format(time.RFC3339), true
		}
	}
	return str, true
}

func normalizeSandboxRow(cols []string, vals []interface{}) map[string]interface{} {
	m := map[string]interface{}{}
	for i, c := range cols {
		switch c {
		case "duration_minutes", "unit_price_usd", "total_cost_usd":
			if f, ok := toFloat(vals[i]); ok {
				m[c] = f
			} else {
				m[c] = nil
			}
		case "total_cost_balance":
			if n, ok := toInt(vals[i]); ok {
				m[c] = n
			} else {
				m[c] = nil
			}
		case "created_at", "updated_at", "started_at", "released_at", "last_billed_at":
			if iso, ok := toTimeISO(vals[i]); ok {
				m[c] = iso
			} else {
				m[c] = nil
			}
		case "info":
			s := toString(vals[i])
			var obj interface{}
			if err := json.Unmarshal([]byte(s), &obj); err == nil {
				m[c] = obj
			} else {
				m[c] = s
			}
		default:
			m[c] = toString(vals[i])
		}
	}
	return m
}

func normalizeGenericInts(cols []string, vals []interface{}, intCols []string, timeCols []string) map[string]interface{} {
	m := map[string]interface{}{}
	isInt := map[string]struct{}{}
	for _, k := range intCols {
		isInt[k] = struct{}{}
	}
	isTime := map[string]struct{}{}
	for _, k := range timeCols {
		isTime[k] = struct{}{}
	}
	for i, c := range cols {
		if _, ok := isInt[c]; ok {
			if n, ok2 := toInt(vals[i]); ok2 {
				m[c] = n
			} else {
				m[c] = nil
			}
			continue
		}
		if _, ok := isTime[c]; ok {
			if iso, ok2 := toTimeISO(vals[i]); ok2 {
				m[c] = iso
			} else {
				m[c] = nil
			}
			continue
		}
		m[c] = toString(vals[i])
	}
	return m
}

func parseBool(val interface{}) bool {
	switch v := val.(type) {
	case bool:
		return v
	case *bool:
		if v != nil {
			return *v
		}
	case int, int32, int64:
		if v, ok := toInt(val); ok {
			return v != 0
		}
	case uint, uint32, uint64:
		if v, ok := toInt(val); ok {
			return v != 0
		}
	case string:
		lower := strings.ToLower(strings.TrimSpace(v))
		return lower == "true" || lower == "1" || lower == "t"
	}
	return false
}

type mcpUsageAggregation struct {
	Provider string         `gorm:"column:provider"`
	Account  sql.NullString `gorm:"column:account"`
	CostSum  int64          `gorm:"column:cost_sum"`
}

type modelConfigInfo struct {
	ID         uint64
	Provider   string
	ModelName  string
	PriceRatio float64
}

func applyMcpBalanceChange(tx *gorm.DB, providerID uuid.UUID, delta decimal.Decimal, remark string) (decimal.Decimal, decimal.Decimal, error) {
	var latest struct {
		Balance decimal.Decimal `gorm:"column:balance"`
	}
	prev := decimal.Zero

	err := tx.Table("mcp_account_balances").
		Select("balance").
		Where("provider_id = ?", providerID).
		Order("created_at DESC").
		Take(&latest).Error

	if err != nil {
		if !errors.Is(err, gorm.ErrRecordNotFound) {
			return decimal.Zero, decimal.Zero, err
		}
	} else {
		prev = latest.Balance
	}

	newBalance := prev.Add(delta)

	record := map[string]interface{}{
		"provider_id": providerID,
		"balance":     newBalance,
		"currency":    "USD",
		"remark":      remark,
	}

	if err := tx.Table("mcp_account_balances").Create(record).Error; err != nil {
		return decimal.Zero, decimal.Zero, err
	}

	return prev, newBalance, nil
}

func findMcpProviderID(pg *gorm.DB, provider, account string) (uuid.UUID, error) {
	var result struct {
		ID uuid.UUID `gorm:"column:id"`
	}

	query := pg.Table("mcp_providers").Select("id").Where("provider = ?", provider)
	if account != "" {
		query = query.Where("account = ?", account)
	} else {
		query = query.Where("(account IS NULL OR account = '')")
	}

	err := query.Order("created_at DESC").Take(&result).Error
	if err != nil {
		return uuid.Nil, err
	}
	return result.ID, nil
}

// mcpProviderInfo 存储 provider 信息用于内存查找
type mcpProviderInfo struct {
	ID            uuid.UUID
	Provider      string
	Account       string // 空字符串表示 account 为空
	FloatingRatio float64
}

type mcpProviderCache struct {
	ID            uuid.UUID
	FloatingRatio float64
}

// loadMcpProvidersToMemory 加载所有 mcp_providers 记录到内存
// 构建 map: key = account, value = provider_id
func loadMcpProvidersToMemory(pg *gorm.DB) (map[string]mcpProviderCache, error) {
	var providers []mcpProviderInfo
	err := pg.Table("mcp_providers").
		Select("id, provider, COALESCE(account, '') AS account, COALESCE(floating_ratio, 1) AS floating_ratio").
		Order("created_at DESC").
		Find(&providers).Error
	if err != nil {
		return nil, err
	}

	// 构建 map: key = account, value = provider_id
	// 如果同一个 account 有多条记录，保留最新的（因为已经按 created_at DESC 排序）
	providerMap := make(map[string]mcpProviderCache)
	for _, p := range providers {
		key := p.Account
		// 如果该 key 已存在，保留最新的（因为已经按 created_at DESC 排序）
		if _, exists := providerMap[key]; !exists {
			ratio := p.FloatingRatio
			if ratio < 0 {
				ratio = 0
			}
			ratio = 1 + ratio
			providerMap[key] = mcpProviderCache{
				ID:            p.ID,
				FloatingRatio: ratio,
			}
		}
	}

	return providerMap, nil
}

// findMcpProviderFromMemory 从内存 map 中查找 provider 信息
// 直接通过 account 查找，不使用 provider
func findMcpProviderFromMemory(providerMap map[string]mcpProviderCache, provider, account string) (mcpProviderCache, error) {
	// 直接使用 account 作为 key
	if entry, found := providerMap[account]; found {
		return entry, nil
	}

	return mcpProviderCache{}, fmt.Errorf("未找到匹配的账号: account=%s", account)
}

func getLastProcessedWindowEnd(pg *gorm.DB, jobName string) (time.Time, error) {
	var result struct {
		WindowEnd time.Time `gorm:"column:window_end"`
	}
	err := pg.Table("mcp_usage_balance_job_runs").
		Select("window_end").
		Where("job_name = ? AND status = ?", jobName, jobStatusSuccess).
		Order("id DESC").
		Limit(1).
		Take(&result).Error
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return time.Time{}, nil // 返回零值表示没有记录
		}
		return time.Time{}, err
	}
	return result.WindowEnd, nil
}

func createMcpUsageJobRun(pg *gorm.DB, jobName string, windowStart, windowEnd time.Time) (int64, error) {
	type JobRun struct {
		ID               int64           `gorm:"column:id;primaryKey;autoIncrement"`
		JobName          string          `gorm:"column:job_name"`
		WindowStart      time.Time       `gorm:"column:window_start"`
		WindowEnd        time.Time       `gorm:"column:window_end"`
		Status           string          `gorm:"column:status"`
		RecordsProcessed int             `gorm:"column:records_processed"`
		TotalCost        decimal.Decimal `gorm:"column:total_cost"`
		ErrorMessage     string          `gorm:"column:error_message"`
		CreatedAt        time.Time       `gorm:"column:created_at"`
		UpdatedAt        time.Time       `gorm:"column:updated_at"`
	}

	jobRun := JobRun{
		JobName:          jobName,
		WindowStart:      windowStart,
		WindowEnd:        windowEnd,
		Status:           jobStatusPending,
		RecordsProcessed: 0,
		TotalCost:        decimal.Zero,
		ErrorMessage:     "",
		CreatedAt:        time.Now(),
		UpdatedAt:        time.Now(),
	}

	if err := pg.Table("mcp_usage_balance_job_runs").Create(&jobRun).Error; err != nil {
		var pgErr *pgconn.PgError
		if errors.As(err, &pgErr) && pgErr.Code == "23505" {
			var existing struct {
				ID     int64  `gorm:"column:id"`
				Status string `gorm:"column:status"`
			}
			if lookupErr := pg.Table("mcp_usage_balance_job_runs").
				Select("id, status").
				Where("job_name = ? AND window_start = ?", jobName, windowStart).
				Take(&existing).Error; lookupErr == nil {
				switch existing.Status {
				case jobStatusPending:
					return existing.ID, ErrMcpUsageJobAlreadyInProgress
				case jobStatusSuccess:
					return existing.ID, ErrMcpUsageJobAlreadyProcessed
				default:
					return existing.ID, fmt.Errorf("job already exists with status %s", existing.Status)
				}
			}
		}
		return 0, err
	}
	return jobRun.ID, nil
}

func updateMcpUsageJobRun(pg *gorm.DB, runID int64, status string, records int, total decimal.Decimal, errorMessage string) error {
	updateData := map[string]interface{}{
		"status":            status,
		"records_processed": records,
		"total_cost":        total,
		"error_message":     errorMessage,
		"updated_at":        time.Now(),
	}
	return pg.Table("mcp_usage_balance_job_runs").Where("id = ?", runID).Updates(updateData).Error
}

func getLastProcessedModelTokenWindowEnd(db *gorm.DB, jobName string) (time.Time, error) {
	var result struct {
		WindowEnd time.Time `gorm:"column:window_end"`
	}
	err := db.Table("model_token_balance_job_runs").
		Select("window_end").
		Where("job_name = ? AND status = ?", jobName, jobStatusSuccess).
		Order("id DESC").
		Limit(1).
		Take(&result).Error
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return time.Time{}, nil
		}
		return time.Time{}, err
	}
	return result.WindowEnd, nil
}

func createModelTokenJobRun(db *gorm.DB, jobName string, windowStart, windowEnd time.Time) (int64, error) {
	type jobRun struct {
		ID               int64     `gorm:"column:id;primaryKey;autoIncrement"`
		JobName          string    `gorm:"column:job_name"`
		WindowStart      time.Time `gorm:"column:window_start"`
		WindowEnd        time.Time `gorm:"column:window_end"`
		Status           string    `gorm:"column:status"`
		RecordsProcessed int       `gorm:"column:records_processed"`
		TotalCost        decimal.Decimal
		ErrorMessage     string    `gorm:"column:error_message"`
		CreatedAt        time.Time `gorm:"column:created_at"`
		UpdatedAt        time.Time `gorm:"column:updated_at"`
	}

	run := jobRun{
		JobName:          jobName,
		WindowStart:      windowStart,
		WindowEnd:        windowEnd,
		Status:           jobStatusPending,
		RecordsProcessed: 0,
		TotalCost:        decimal.Zero,
		ErrorMessage:     "",
		CreatedAt:        time.Now(),
		UpdatedAt:        time.Now(),
	}

	if err := db.Table("model_token_balance_job_runs").Create(&run).Error; err != nil {
		var mysqlErr *mysqldriver.MySQLError
		if errors.As(err, &mysqlErr) && mysqlErr.Number == 1062 {
			var existing struct {
				ID     int64  `gorm:"column:id"`
				Status string `gorm:"column:status"`
			}
			if lookupErr := db.Table("model_token_balance_job_runs").
				Select("id, status").
				Where("job_name = ? AND window_start = ?", jobName, windowStart).
				Order("id DESC").
				Take(&existing).Error; lookupErr == nil {
				switch existing.Status {
				case jobStatusPending:
					return existing.ID, ErrModelTokenJobAlreadyInProgress
				case jobStatusSuccess:
					return existing.ID, ErrModelTokenJobAlreadyProcessed
				default:
					return existing.ID, fmt.Errorf("job already exists with status %s", existing.Status)
				}
			}
			return 0, ErrModelTokenJobAlreadyProcessed
		}
		return 0, err
	}

	return run.ID, nil
}

func updateModelTokenJobRun(db *gorm.DB, runID int64, status string, records int, total decimal.Decimal, errorMessage string) error {
	updateData := map[string]interface{}{
		"status":            status,
		"records_processed": records,
		"total_cost":        total,
		"error_message":     errorMessage,
		"updated_at":        time.Now(),
	}
	return db.Table("model_token_balance_job_runs").Where("id = ?", runID).Updates(updateData).Error
}

func loadModelConfigsToMemory(db *gorm.DB) (map[string]modelConfigInfo, error) {
	var configs []struct {
		ID         uint64  `gorm:"column:id"`
		Provider   string  `gorm:"column:provider"`
		ModelName  string  `gorm:"column:model_name"`
		PriceRatio float64 `gorm:"column:price_ratio"`
	}

	err := db.Table("gw_model_config_v2").
		Select("id, provider, model_name, price_ratio").
		Where("deleted_at IS NULL").
		Find(&configs).Error
	if err != nil {
		return nil, err
	}

	result := make(map[string]modelConfigInfo, len(configs))
	for _, cfg := range configs {
		key := makeModelConfigKey(cfg.Provider, cfg.ModelName)
		if _, exists := result[key]; !exists {
			result[key] = modelConfigInfo{
				ID:         cfg.ID,
				Provider:   strings.TrimSpace(cfg.Provider),
				ModelName:  strings.TrimSpace(cfg.ModelName),
				PriceRatio: cfg.PriceRatio,
			}
		}
	}
	return result, nil
}

func makeModelConfigKey(provider, model string) string {
	return strings.ToLower(strings.TrimSpace(provider)) + "|" + strings.ToLower(strings.TrimSpace(model))
}

func AdjustMcpAccountBalance(providerID string, newBalance float64, operatorName, remark string) error {
	db := storage.GetPG()
	if db == nil {
		return fmt.Errorf("PostgreSQL未初始化")
	}

	if newBalance < 0 {
		return fmt.Errorf("余额不能为负数")
	}

	uuidVal, err := uuid.Parse(providerID)
	if err != nil {
		return fmt.Errorf("无效的provider_id: %w", err)
	}

	target := decimal.NewFromFloat(newBalance).Round(8)
	current := decimal.Zero

	var latest struct {
		Balance decimal.Decimal `gorm:"column:balance"`
	}
	err = db.Table("mcp_account_balances").
		Select("balance").
		Where("provider_id = ?", uuidVal).
		Order("created_at DESC").
		Take(&latest).Error
	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
		return fmt.Errorf("获取当前余额失败: %w", err)
	}
	if err == nil {
		current = latest.Balance
	}

	delta := target.Sub(current)
	if delta.Abs().LessThan(decimal.NewFromFloat(1e-8)) {
		// 无需更新，但仍返回成功
		return nil
	}

	tx := db.Begin()
	if tx.Error != nil {
		return fmt.Errorf("开启事务失败: %w", tx.Error)
	}

	fullRemark := remark
	if strings.TrimSpace(fullRemark) == "" {
		fullRemark = fmt.Sprintf("手动调整余额至 $%s by %s", target.StringFixed(8), operatorName)
	} else {
		fullRemark = fmt.Sprintf("%s (by %s)", remark, operatorName)
	}

	_, _, err = applyMcpBalanceChange(tx, uuidVal, delta, fullRemark)
	if err != nil {
		tx.Rollback()
		return err
	}

	if err := tx.Commit().Error; err != nil {
		return fmt.Errorf("提交事务失败: %w", err)
	}
	return nil
}

func CreateMcpAccountBalanceRecord(providerID string, balance float64, operatorName, remark string) error {
	db := storage.GetPG()
	if db == nil {
		return fmt.Errorf("PostgreSQL未初始化")
	}

	if balance < 0 {
		return fmt.Errorf("余额不能为负数")
	}

	uuidVal, err := uuid.Parse(providerID)
	if err != nil {
		return fmt.Errorf("无效的provider_id: %w", err)
	}

	var exists int64
	if err := db.Table("mcp_account_balances").Where("provider_id = ?", uuidVal).Limit(1).Count(&exists).Error; err != nil {
		return fmt.Errorf("查询余额失败: %w", err)
	}
	if exists > 0 {
		return fmt.Errorf("余额记录已存在，请使用调整余额功能")
	}

	target := decimal.NewFromFloat(balance).Round(8)

	tx := db.Begin()
	if tx.Error != nil {
		return fmt.Errorf("开启事务失败: %w", tx.Error)
	}

	fullRemark := remark
	if strings.TrimSpace(fullRemark) == "" {
		fullRemark = fmt.Sprintf("新增余额 $%s by %s", target.StringFixed(8), operatorName)
	} else {
		fullRemark = fmt.Sprintf("%s (by %s)", remark, operatorName)
	}

	_, _, err = applyMcpBalanceChange(tx, uuidVal, target, fullRemark)
	if err != nil {
		tx.Rollback()
		return err
	}

	if err := tx.Commit().Error; err != nil {
		return fmt.Errorf("提交事务失败: %w", err)
	}
	return nil
}

func AdjustModelAccountBalance(account string, newBalance float64, operatorName, remark string) error {
	db := storage.DB
	if db == nil {
		return fmt.Errorf("MySQL未初始化")
	}

	if newBalance < 0 {
		return fmt.Errorf("余额不能为负数")
	}

	target := decimal.NewFromFloat(newBalance).Round(8)
	current := decimal.Zero

	var latest struct {
		Balance decimal.Decimal `gorm:"column:balance"`
	}
	err := db.Table("gw_model_account_balances").
		Select("balance").
		Where("account = ?", account).
		Order("created_at DESC").
		Take(&latest).Error
	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
		return fmt.Errorf("获取当前余额失败: %w", err)
	}
	if err == nil {
		current = latest.Balance
	}

	delta := target.Sub(current)
	if delta.Abs().LessThan(decimal.NewFromFloat(1e-8)) {
		return nil
	}

	tx := db.Begin()
	if tx.Error != nil {
		return fmt.Errorf("开启事务失败: %w", tx.Error)
	}

	fullRemark := remark
	if strings.TrimSpace(fullRemark) == "" {
		fullRemark = fmt.Sprintf("手动调整余额至 $%s by %s", target.StringFixed(8), operatorName)
	} else {
		fullRemark = fmt.Sprintf("%s (by %s)", remark, operatorName)
	}

	_, _, err = applyModelAccountBalanceChange(tx, account, delta, fullRemark)
	if err != nil {
		tx.Rollback()
		return err
	}

	if err := tx.Commit().Error; err != nil {
		return fmt.Errorf("提交事务失败: %w", err)
	}
	return nil
}

func CreateModelAccountBalanceRecord(account string, balance float64, operatorName, remark string) error {
	db := storage.DB
	if db == nil {
		return fmt.Errorf("MySQL未初始化")
	}

	if balance < 0 {
		return fmt.Errorf("余额不能为负数")
	}

	var exists int64
	if err := db.Table("gw_model_account_balances").Where("account = ?", account).Limit(1).Count(&exists).Error; err != nil {
		return fmt.Errorf("查询余额失败: %w", err)
	}
	if exists > 0 {
		return fmt.Errorf("余额记录已存在，请使用调整余额功能")
	}

	target := decimal.NewFromFloat(balance).Round(8)

	tx := db.Begin()
	if tx.Error != nil {
		return fmt.Errorf("开启事务失败: %w", tx.Error)
	}

	fullRemark := remark
	if strings.TrimSpace(fullRemark) == "" {
		fullRemark = fmt.Sprintf("新增余额 $%s by %s", target.StringFixed(8), operatorName)
	} else {
		fullRemark = fmt.Sprintf("%s (by %s)", remark, operatorName)
	}

	_, _, err := applyModelAccountBalanceChange(tx, account, target, fullRemark)
	if err != nil {
		tx.Rollback()
		return err
	}
	if err := tx.Commit().Error; err != nil {
		return fmt.Errorf("提交事务失败: %w", err)
	}
	return nil
}

func ListSandboxRecords(offset, limit int, userID, projectID, start, end string) (*PageResult, error) {
	var total int64
	q := storage.DB.Table("sb_sandbox_record")
	if userID != "" {
		q = q.Where("user_id = ?", userID)
	}
	if projectID != "" {
		q = q.Where("project_id = ?", projectID)
	}
	if start != "" && end != "" {
		q = q.Where("created_at BETWEEN ? AND ?", start, end)
	}
	if err := q.Count(&total).Error; err != nil {
		return nil, fmt.Errorf("count sandbox records: %w", err)
	}
	rows, err := q.Offset(offset).Limit(limit).Rows()
	if err != nil {
		return nil, fmt.Errorf("query sandbox records: %w", err)
	}
	defer rows.Close()
	cols, _ := rows.Columns()
	list := make([]map[string]interface{}, 0)
	for rows.Next() {
		vals := make([]interface{}, len(cols))
		valPtrs := make([]interface{}, len(cols))
		for i := range vals {
			valPtrs[i] = &vals[i]
		}
		if err := rows.Scan(valPtrs...); err != nil {
			return nil, err
		}
		list = append(list, normalizeSandboxRow(cols, vals))
	}
	return &PageResult{List: list, Total: total}, nil
}

func ListTokenUsages(offset, limit int, userID, projectID, startDay, endDay string) (*PageResult, error) {
	var total int64
	q := storage.DB.Table("gw_token_usages")
	if userID != "" {
		q = q.Where("user_id = ?", userID)
	}
	if projectID != "" {
		q = q.Where("project_id = ?", projectID)
	}
	if startDay != "" && endDay != "" {
		q = q.Where("day BETWEEN ? AND ?", startDay, endDay)
	}
	if err := q.Count(&total).Error; err != nil {
		return nil, fmt.Errorf("count token usages: %w", err)
	}
	rows, err := q.Offset(offset).Limit(limit).Rows()
	if err != nil {
		return nil, fmt.Errorf("query token usages: %w", err)
	}
	defer rows.Close()
	cols, _ := rows.Columns()
	list := make([]map[string]interface{}, 0)
	intCols := []string{"id", "hour", "cost", "prompt_token", "completion_token", "cache_create_token", "cache_read_token"}
	for rows.Next() {
		vals := make([]interface{}, len(cols))
		valPtrs := make([]interface{}, len(cols))
		for i := range vals {
			valPtrs[i] = &vals[i]
		}
		if err := rows.Scan(valPtrs...); err != nil {
			return nil, err
		}
		list = append(list, normalizeGenericInts(cols, vals, intCols, nil))
	}
	return &PageResult{List: list, Total: total}, nil
}

func ListMCPUsages(offset, limit int, userID, projectID, start, end string) (*PageResult, error) {
	var total int64
	q := storage.DB.Table("mcp_invoke_usages")
	if userID != "" {
		q = q.Where("user_id = ?", userID)
	}
	if projectID != "" {
		q = q.Where("project_id = ?", projectID)
	}
	if start != "" && end != "" {
		q = q.Where("created_at BETWEEN ? AND ?", start, end)
	}
	if err := q.Count(&total).Error; err != nil {
		return nil, fmt.Errorf("count mcp usages: %w", err)
	}
	rows, err := q.Offset(offset).Limit(limit).Rows()
	if err != nil {
		return nil, fmt.Errorf("query mcp usages: %w", err)
	}
	defer rows.Close()
	cols, _ := rows.Columns()
	list := make([]map[string]interface{}, 0)
	intCols := []string{"id", "hour", "cost", "call_count"}
	timeCols := []string{"created_at", "updated_at"}
	for rows.Next() {
		vals := make([]interface{}, len(cols))
		valPtrs := make([]interface{}, len(cols))
		for i := range vals {
			valPtrs[i] = &vals[i]
		}
		if err := rows.Scan(valPtrs...); err != nil {
			return nil, err
		}
		list = append(list, normalizeGenericInts(cols, vals, intCols, timeCols))
	}
	return &PageResult{List: list, Total: total}, nil
}

func ListTransactionLogs(offset, limit int, userID, orderID, txType, status, start, end string) (*PageResult, error) {
	var total int64
	q := storage.DB.Table("m_transaction_logs")
	if userID != "" {
		q = q.Where("user_id = ?", userID)
	}
	if orderID != "" {
		q = q.Where("order_id = ?", orderID)
	}
	if txType != "" {
		q = q.Where("type = ?", txType)
	}
	if status != "" {
		q = q.Where("status = ?", status)
	}
	if start != "" && end != "" {
		q = q.Where("created_at BETWEEN ? AND ?", start, end)
	}
	if err := q.Count(&total).Error; err != nil {
		return nil, fmt.Errorf("count transaction logs: %w", err)
	}
	rows, err := q.Offset(offset).Limit(limit).Rows()
	if err != nil {
		return nil, fmt.Errorf("query transaction logs: %w", err)
	}
	defer rows.Close()
	cols, _ := rows.Columns()
	list := make([]map[string]interface{}, 0)
	intCols := []string{"id", "amount", "balance_before", "balance_after"}
	timeCols := []string{"created_at"}
	for rows.Next() {
		vals := make([]interface{}, len(cols))
		valPtrs := make([]interface{}, len(cols))
		for i := range vals {
			valPtrs[i] = &vals[i]
		}
		if err := rows.Scan(valPtrs...); err != nil {
			return nil, err
		}
		list = append(list, normalizeGenericInts(cols, vals, intCols, timeCols))
	}
	return &PageResult{List: list, Total: total}, nil
}

// ListPaymentRecords 查询充值支付记录
func ListPaymentRecords(offset, limit int, userID, orderID, paypalOrderID, status, refundStatus, payerEmail, start, end string) (*PageResult, error) {
	var total int64
	q := storage.DB.Table("m_payment_records")
	if userID != "" {
		q = q.Where("user_id = ?", userID)
	}
	if orderID != "" {
		q = q.Where("order_id = ?", orderID)
	}
	if paypalOrderID != "" {
		q = q.Where("paypal_order_id = ?", paypalOrderID)
	}
	if status != "" {
		q = q.Where("status = ?", status)
	}
	if refundStatus != "" {
		q = q.Where("refund_status = ?", refundStatus)
	}
	if payerEmail != "" {
		q = q.Where("payer_email LIKE ?", "%"+payerEmail+"%")
	}
	if start != "" && end != "" {
		q = q.Where("created_at BETWEEN ? AND ?", start, end)
	}
	if err := q.Count(&total).Error; err != nil {
		return nil, fmt.Errorf("count payment records: %w", err)
	}
	rows, err := q.Offset(offset).Limit(limit).Rows()
	if err != nil {
		return nil, fmt.Errorf("query payment records: %w", err)
	}
	defer rows.Close()
	cols, _ := rows.Columns()
	list := make([]map[string]interface{}, 0)
	intCols := []string{"id", "amount", "refunded_amount"}
	timeCols := []string{"created_at", "updated_at"}
	for rows.Next() {
		vals := make([]interface{}, len(cols))
		valPtrs := make([]interface{}, len(cols))
		for i := range vals {
			valPtrs[i] = &vals[i]
		}
		if err := rows.Scan(valPtrs...); err != nil {
			return nil, err
		}
		list = append(list, normalizeGenericInts(cols, vals, intCols, timeCols))
	}
	return &PageResult{List: list, Total: total}, nil
}

// RefundPaymentRecord 退款支付记录
func RefundPaymentRecord(orderID, paypalCaptureID string, amount *int64) error {
	cfg := config.GetConfig()
	payBaseURL := cfg.Pay.BaseURL
	timeout := time.Duration(cfg.Pay.Timeout) * time.Second

	// 构建请求体
	reqBody := make(map[string]interface{})
	if orderID != "" {
		reqBody["order_id"] = orderID
	}
	if paypalCaptureID != "" {
		reqBody["paypal_capture_id"] = paypalCaptureID
	}
	if amount != nil {
		reqBody["amount"] = *amount
	}

	jsonData, err := json.Marshal(reqBody)
	if err != nil {
		return fmt.Errorf("序列化请求失败: %w", err)
	}

	// 创建HTTP请求
	req, err := http.NewRequest("POST", payBaseURL+"/api/refund", bytes.NewBuffer(jsonData))
	if err != nil {
		return fmt.Errorf("创建请求失败: %w", err)
	}

	req.Header.Set("Content-Type", "application/json")

	// 发送请求
	client := &http.Client{Timeout: timeout}
	resp, err := client.Do(req)
	if err != nil {
		return fmt.Errorf("发送退款请求失败: %w", err)
	}
	defer resp.Body.Close()

	// 读取响应
	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return fmt.Errorf("读取响应失败: %w", err)
	}

	if resp.StatusCode != http.StatusOK {
		return fmt.Errorf("退款接口返回错误: %d, 响应: %s", resp.StatusCode, string(body))
	}

	// 读取订单基础信息（一次查询拿到 user_id 和 amount）
	var rec struct {
		UserID string `json:"user_id"`
		Amount int64  `json:"amount"`
	}
	if err := storage.DB.Table("m_payment_records").Select("user_id, amount").Where("order_id = ?", orderID).Scan(&rec).Error; err != nil {
		return nil // 不阻断主流程
	}

	// 确定应扣减的退款金额（单位：分）
	var refundCents int64
	if amount != nil {
		refundCents = *amount
	} else {
		refundCents = rec.Amount
	}

	if refundCents <= 0 {
		return nil
	}

	// 计算递减值（Redis单位）
	decrBy := refundCents * 1_000_000 // 1 cent = 1e6 in Redis unit

	// 连接 Redis 并扣减余额
	rclient, err := pkgredis.NewClient(cfg.Redis)
	if err != nil {
		return nil // 忽略Redis失败
	}
	defer rclient.Close()

	ctx := context.Background()
	key := fmt.Sprintf("GW:QU_%s", rec.UserID)
	_, _ = rclient.Rdb.DecrBy(ctx, key, decrBy).Result()

	return nil
}

// ListMcpAccountRechargeRecords 查询MCP账号充值记录
func ListMcpAccountRechargeRecords(offset, limit int, provider, account, start, end string) (*PageResult, error) {
	db := storage.GetPG()
	if db == nil {
		return nil, fmt.Errorf("PostgreSQL未初始化")
	}

	var total int64
	q := db.Table("mcp_account_recharge_records").
		Select(`
			mcp_account_recharge_records.*,
			mcp_providers.provider,
			mcp_providers.account
		`).
		Joins("LEFT JOIN mcp_providers ON mcp_account_recharge_records.provider_id = mcp_providers.id")

	if provider != "" {
		q = q.Where("mcp_providers.provider ILIKE ?", "%"+provider+"%")
	}
	if account != "" {
		q = q.Where("mcp_providers.account ILIKE ?", "%"+account+"%")
	}
	if start != "" {
		q = q.Where("mcp_account_recharge_records.recharge_date >= ?", start)
	}
	if end != "" {
		q = q.Where("mcp_account_recharge_records.recharge_date <= ?", end)
	}

	if err := q.Count(&total).Error; err != nil {
		return nil, fmt.Errorf("count mcp account recharge records: %w", err)
	}

	rows, err := q.Order("mcp_account_recharge_records.created_at DESC").
		Offset(offset).Limit(limit).Rows()
	if err != nil {
		return nil, fmt.Errorf("query mcp account recharge records: %w", err)
	}
	defer rows.Close()

	cols, _ := rows.Columns()
	list := make([]map[string]interface{}, 0)
	floatCols := []string{"amount"}
	timeCols := []string{"created_at", "updated_at"}

	for rows.Next() {
		vals := make([]interface{}, len(cols))
		valPtrs := make([]interface{}, len(cols))
		for i := range vals {
			valPtrs[i] = &vals[i]
		}
		if err := rows.Scan(valPtrs...); err != nil {
			return nil, err
		}

		// 处理数据类型
		m := map[string]interface{}{}
		isFloat := map[string]struct{}{}
		for _, k := range floatCols {
			isFloat[k] = struct{}{}
		}
		isTime := map[string]struct{}{}
		for _, k := range timeCols {
			isTime[k] = struct{}{}
		}

		for i, c := range cols {
			if _, ok := isFloat[c]; ok {
				if f, ok2 := toFloat(vals[i]); ok2 {
					m[c] = f
				} else {
					m[c] = nil
				}
				continue
			}
			if _, ok := isTime[c]; ok {
				if iso, ok2 := toTimeISO(vals[i]); ok2 {
					m[c] = iso
				} else {
					m[c] = nil
				}
				continue
			}
			m[c] = toString(vals[i])
		}
		list = append(list, m)
	}

	return &PageResult{List: list, Total: total}, nil
}

// CreateMcpAccountRechargeRecord 创建MCP账号充值记录
func CreateMcpAccountRechargeRecord(providerID string, amount float64, rechargeDate string, operatorID interface{}, operatorName, remark string) error {
	db := storage.GetPG()
	if db == nil {
		return fmt.Errorf("PostgreSQL未初始化")
	}

	// 解析provider_id为UUID
	providerUUID, err := uuid.Parse(providerID)
	if err != nil {
		return fmt.Errorf("无效的provider_id: %w", err)
	}

	// 解析日期
	date, err := time.Parse("2006-01-02", rechargeDate)
	if err != nil {
		return fmt.Errorf("无效的日期格式: %w", err)
	}

	// 处理operator_id
	var operatorUUID *uuid.UUID
	if operatorID != nil {
		var opID uuid.UUID
		switch v := operatorID.(type) {
		case string:
			opID, err = uuid.Parse(v)
			if err != nil {
				// 如果不是UUID格式，可能是数字ID，设为nil
				operatorUUID = nil
			} else {
				operatorUUID = &opID
			}
		case uuid.UUID:
			operatorUUID = &v
		default:
			operatorUUID = nil
		}
	}

	// 开始事务
	tx := db.Begin()
	if tx.Error != nil {
		return fmt.Errorf("开始事务失败: %w", tx.Error)
	}
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()

	// 1. 创建充值记录
	record := map[string]interface{}{
		"provider_id":   providerUUID,
		"amount":        amount,
		"currency":      "USD",
		"recharge_date": date,
		"operator_id":   operatorUUID,
		"operator_name": operatorName,
		"remark":        remark,
	}

	if err := tx.Table("mcp_account_recharge_records").Create(record).Error; err != nil {
		tx.Rollback()
		return fmt.Errorf("创建充值记录失败: %w", err)
	}

	amountDecimal := decimal.NewFromFloat(amount).Round(8)
	remarkText := fmt.Sprintf("手动充值 $%s by %s", amountDecimal.StringFixed(2), operatorName)

	_, _, err = applyMcpBalanceChange(tx, providerUUID, amountDecimal, remarkText)
	if err != nil {
		tx.Rollback()
		return fmt.Errorf("创建余额记录失败: %w", err)
	}

	// 提交事务
	if err := tx.Commit().Error; err != nil {
		return fmt.Errorf("提交事务失败: %w", err)
	}

	return nil
}

// UpdateMcpAccountRechargeRecord 更新MCP账号充值记录
func UpdateMcpAccountRechargeRecord(id string, amount *float64, rechargeDate *string, remark *string) error {
	db := storage.GetPG()
	if db == nil {
		return fmt.Errorf("PostgreSQL未初始化")
	}

	recordID, err := uuid.Parse(id)
	if err != nil {
		return fmt.Errorf("无效的记录ID: %w", err)
	}

	updates := map[string]interface{}{}
	if amount != nil {
		updates["amount"] = *amount
	}
	if rechargeDate != nil {
		date, err := time.Parse("2006-01-02", *rechargeDate)
		if err != nil {
			return fmt.Errorf("无效的日期格式: %w", err)
		}
		updates["recharge_date"] = date
	}
	if remark != nil {
		updates["remark"] = *remark
	}

	if len(updates) == 0 {
		return fmt.Errorf("没有需要更新的字段")
	}

	updates["updated_at"] = time.Now()

	return db.Table("mcp_account_recharge_records").
		Where("id = ?", recordID).
		Updates(updates).Error
}

// DeleteMcpAccountRechargeRecord 删除MCP账号充值记录
func DeleteMcpAccountRechargeRecord(id string) error {
	db := storage.GetPG()
	if db == nil {
		return fmt.Errorf("PostgreSQL未初始化")
	}

	recordID, err := uuid.Parse(id)
	if err != nil {
		return fmt.Errorf("无效的记录ID: %w", err)
	}

	return db.Table("mcp_account_recharge_records").
		Where("id = ?", recordID).
		Delete(nil).Error
}

// GetMcpProviderAccounts 获取MCP账号列表（用于下拉选择）
func GetMcpProviderAccounts(status string, isUsed *bool) ([]map[string]interface{}, error) {
	db := storage.GetPG()
	if db == nil {
		return nil, fmt.Errorf("PostgreSQL未初始化")
	}

	q := db.Table("mcp_providers").
		Select("id, provider, account, status, is_used")

	if status != "" {
		q = q.Where("status = ?", status)
	}
	if isUsed != nil {
		q = q.Where("is_used = ?", *isUsed)
	}

	var list []map[string]interface{}
	rows, err := q.Order("provider, account").Rows()
	if err != nil {
		return nil, fmt.Errorf("query mcp providers: %w", err)
	}
	defer rows.Close()

	cols, _ := rows.Columns()
	for rows.Next() {
		vals := make([]interface{}, len(cols))
		valPtrs := make([]interface{}, len(cols))
		for i := range vals {
			valPtrs[i] = &vals[i]
		}
		if err := rows.Scan(valPtrs...); err != nil {
			return nil, err
		}

		m := map[string]interface{}{}
		for i, c := range cols {
			m[c] = toString(vals[i])
		}
		list = append(list, m)
	}

	return list, nil
}

// GetMcpAccountLatestBalance 获取账户最新余额
func GetMcpAccountLatestBalance(providerID string) (map[string]interface{}, error) {
	db := storage.GetPG()
	if db == nil {
		return nil, fmt.Errorf("PostgreSQL未初始化")
	}

	providerUUID, err := uuid.Parse(providerID)
	if err != nil {
		return nil, fmt.Errorf("无效的provider_id: %w", err)
	}

	var balance map[string]interface{}
	err = db.Table("mcp_account_balances").
		Select(`
			mcp_account_balances.*,
			mcp_providers.provider,
			mcp_providers.account
		`).
		Joins("LEFT JOIN mcp_providers ON mcp_account_balances.provider_id = mcp_providers.id").
		Where("mcp_account_balances.provider_id = ?", providerUUID).
		Order("mcp_account_balances.created_at DESC").
		Limit(1).
		Find(&balance).Error

	if err != nil {
		// 如果没有记录，返回空map而不是错误
		return map[string]interface{}{}, nil
	}

	return balance, nil
}

// GetMcpAccountBalances 获取所有账户最新余额列表
func GetMcpAccountBalances() ([]map[string]interface{}, error) {
	db := storage.GetPG()
	if db == nil {
		return nil, fmt.Errorf("PostgreSQL未初始化")
	}

	// 先获取每个账户最新的创建时间
	var latestRecords []struct {
		ProviderID uuid.UUID
		MaxCreated time.Time
	}

	err := db.Table("mcp_account_balances").
		Select("provider_id, MAX(created_at) as max_created").
		Group("provider_id").
		Find(&latestRecords).Error

	if err != nil {
		return nil, fmt.Errorf("查询余额失败: %w", err)
	}

	// 为每个账户获取最新余额
	balances := make([]map[string]interface{}, 0)
	for _, lr := range latestRecords {
		var balance map[string]interface{}
		err = db.Table("mcp_account_balances").
			Select(`
				mcp_account_balances.*,
				mcp_providers.provider,
				mcp_providers.account
			`).
			Joins("LEFT JOIN mcp_providers ON mcp_account_balances.provider_id = mcp_providers.id").
			Where("mcp_account_balances.provider_id = ? AND mcp_account_balances.created_at = ?", lr.ProviderID, lr.MaxCreated).
			Limit(1).
			Find(&balance).Error

		if err == nil && len(balance) > 0 {
			balances = append(balances, balance)
		}
	}

	// 处理数据类型
	result := make([]map[string]interface{}, 0)
	for _, bal := range balances {
		m := make(map[string]interface{})
		for k, v := range bal {
			if k == "balance" {
				if f, ok := toFloat(v); ok {
					m[k] = f
				} else {
					m[k] = v
				}
			} else if k == "created_at" {
				if iso, ok := toTimeISO(v); ok {
					m[k] = iso
				} else {
					m[k] = toString(v)
				}
			} else {
				m[k] = toString(v)
			}
		}
		result = append(result, m)
	}

	return result, nil
}

// RunMcpUsageBalanceJob 汇总MCP调用费用并更新余额
// 根据上次处理的时间窗口自动计算本次需要处理的时间范围
func RunMcpUsageBalanceJob() error {
	// 定时任务执行前刷新低余额阈值配置
	RefreshLowBalanceThreshold()

	mysqlDB := storage.DB
	if mysqlDB == nil {
		return fmt.Errorf("MySQL未初始化")
	}
	pg := storage.GetPG()
	if pg == nil {
		return fmt.Errorf("PostgreSQL未初始化")
	}

	// 获取上次成功处理的窗口结束时间
	lastWindowEnd, err := getLastProcessedWindowEnd(pg, mcpUsageJobName)
	if err != nil {
		return fmt.Errorf("获取上次处理时间失败: %w", err)
	}

	// 计算当前时间前一个小时的整点时间
	now := time.Now().UTC()
	currentWindowEnd := now.Truncate(time.Hour)

	var windowStart, windowEnd time.Time
	if lastWindowEnd.IsZero() {
		// 如果没有历史记录，只处理上一个小时的数据
		windowEnd = currentWindowEnd
		windowStart = windowEnd.Add(-time.Hour)
	} else {
		// 如果有历史记录，从上次处理的时间到当前时间前一个小时
		windowStart = lastWindowEnd
		windowEnd = currentWindowEnd
	}

	// 如果窗口为空（例如上次处理到10:00，当前也是10:00），直接返回
	if !windowStart.Before(windowEnd) {
		return nil
	}

	windowStart = windowStart.UTC()
	windowEnd = windowEnd.UTC()

	// 加载所有 mcp_providers 记录到内存
	providerMap, err := loadMcpProvidersToMemory(pg)
	if err != nil {
		return fmt.Errorf("加载账号信息失败: %w", err)
	}

	runID, err := createMcpUsageJobRun(pg, mcpUsageJobName, windowStart, windowEnd)
	if err != nil {
		if errors.Is(err, ErrMcpUsageJobAlreadyProcessed) || errors.Is(err, ErrMcpUsageJobAlreadyInProgress) {
			return nil
		}
		return fmt.Errorf("创建任务记录失败: %w", err)
	}

	var usageRows []mcpUsageAggregation
	err = mysqlDB.Table("mcp_invoke_usages").
		Select("provider, account, SUM(cost) AS cost_sum").
		Where("updated_at >= ? AND updated_at < ?", windowStart, windowEnd).
		Group("provider, account").
		Having("SUM(cost) <> 0").
		Find(&usageRows).Error
	if err != nil {
		updateErr := updateMcpUsageJobRun(pg, runID, jobStatusFailed, 0, decimal.Zero, err.Error())
		if updateErr != nil {
			return fmt.Errorf("更新任务记录失败: %v; 原始错误: %w", updateErr, err)
		}
		return fmt.Errorf("聚合调用费用失败: %w", err)
	}

	if len(usageRows) == 0 {
		return updateMcpUsageJobRun(pg, runID, jobStatusSuccess, 0, decimal.Zero, "")
	}

	var (
		recordsProcessed int
		totalCost        = decimal.Zero
		hadFailure       bool
		errorMessages    []string
	)

	for _, row := range usageRows {
		provider := strings.TrimSpace(row.Provider)
		account := ""
		if row.Account.Valid {
			account = strings.TrimSpace(row.Account.String)
		}

		costCents := row.CostSum
		costUSD := decimal.NewFromInt(costCents).Div(usdScalingFactor)

		detailStatus := jobStatusSuccess
		detailError := ""

		var (
			providerEntry mcpProviderCache
			providerID    uuid.UUID
			actualCostUSD         = costUSD
			floatingRatio float64 = 1
		)
		if account == "" {
			detailStatus = jobStatusFailed
			detailError = "account为空"
		} else {
			if providerEntry, err = findMcpProviderFromMemory(providerMap, provider, account); err != nil {
				detailStatus = jobStatusFailed
				detailError = fmt.Sprintf("查找账号失败: %v", err)
			} else {
				providerID = providerEntry.ID
				floatingRatio = providerEntry.FloatingRatio
			}
		}

		if detailStatus == jobStatusSuccess {
			if floatingRatio <= 0 {
				floatingRatio = 1
			}
			if floatingRatio != 1 {
				actualCostUSD = costUSD.Div(decimal.NewFromFloat(floatingRatio))
			}
			actualCostUSD = actualCostUSD.Round(8)
			if actualCostUSD.LessThanOrEqual(decimal.Zero) {
				detailStatus = jobStatusFailed
				detailError = "结算金额为0"
			}
		}

		var previousBalance decimal.Decimal
		var newBalance decimal.Decimal

		if detailStatus == jobStatusSuccess {
			tx := pg.Begin()
			if tx.Error != nil {
				detailStatus = jobStatusFailed
				detailError = fmt.Sprintf("开启事务失败: %v", tx.Error)
			} else {
				remark := fmt.Sprintf(
					"自动扣费 %s - %s (原始$%s, 上浮%0.2f, 实际$%s)",
					windowStart.Format("2006-01-02 15:04"),
					windowEnd.Format("15:04"),
					costUSD.StringFixed(8),
					floatingRatio,
					actualCostUSD.StringFixed(8),
				)
				previousBalance, newBalance, err = applyMcpBalanceChange(tx, providerID, actualCostUSD.Neg(), remark)
				if err != nil {
					tx.Rollback()
					detailStatus = jobStatusFailed
					detailError = fmt.Sprintf("扣减余额失败: %v", err)
				} else {
					if commitErr := tx.Commit().Error; commitErr != nil {
						detailStatus = jobStatusFailed
						detailError = fmt.Sprintf("提交事务失败: %v", commitErr)
					}
				}
			}
		}

		if detailStatus == jobStatusSuccess {
			recordsProcessed++
			totalCost = totalCost.Add(actualCostUSD)
			threshold := GetLowBalanceThreshold()
			if newBalance.LessThan(threshold) {
				notifier.NotifyMcpLowBalance(provider, account, newBalance, threshold)
			}
		} else {
			hadFailure = true
			errorMessages = append(errorMessages, fmt.Sprintf("%s/%s: %s", provider, account, detailError))
		}

		detailData := map[string]interface{}{
			"run_id":        runID,
			"provider":      provider,
			"account":       account,
			"cost_cents":    costCents,
			"cost_usd":      actualCostUSD,
			"status":        detailStatus,
			"created_at":    time.Now(),
			"error_message": detailError,
		}
		if providerID != uuid.Nil {
			detailData["provider_id"] = providerID
		}
		if detailStatus == jobStatusSuccess {
			detailData["previous_balance"] = previousBalance
			detailData["new_balance"] = newBalance
		}

		if err := pg.Table("mcp_usage_balance_job_details").Create(detailData).Error; err != nil {
			hadFailure = true
			errorMessages = append(errorMessages, fmt.Sprintf("记录明细失败 %s/%s: %v", provider, account, err))
		}
	}

	finalStatus := jobStatusSuccess
	finalError := ""
	if hadFailure {
		finalStatus = jobStatusFailed
		finalError = strings.Join(errorMessages, "; ")
		if len(finalError) > 1000 {
			finalError = finalError[:1000]
		}
	}

	if err := updateMcpUsageJobRun(pg, runID, finalStatus, recordsProcessed, totalCost, finalError); err != nil {
		return fmt.Errorf("更新任务记录失败: %w", err)
	}

	if hadFailure {
		return fmt.Errorf("部分账户结算失败: %s", finalError)
	}

	return nil
}

// RunModelTokenBalanceJob 汇总模型Token消费并扣减余额
func RunModelTokenBalanceJob() error {
	// 定时任务执行前刷新低余额阈值配置
	RefreshLowBalanceThreshold()

	mysqlDB := storage.DB
	if mysqlDB == nil {
		return fmt.Errorf("MySQL未初始化")
	}

	lastWindowEnd, err := getLastProcessedModelTokenWindowEnd(mysqlDB, modelTokenJobName)
	if err != nil {
		return fmt.Errorf("获取上次处理时间失败: %w", err)
	}

	now := time.Now().UTC()
	currentWindowEnd := now.Truncate(time.Hour)

	var windowStart, windowEnd time.Time
	if lastWindowEnd.IsZero() {
		windowEnd = currentWindowEnd
		windowStart = windowEnd.Add(-time.Hour)
	} else {
		windowStart = lastWindowEnd
		windowEnd = currentWindowEnd
	}

	if !windowStart.Before(windowEnd) {
		return nil
	}

	windowStart = windowStart.UTC()
	windowEnd = windowEnd.UTC()

	runID, err := createModelTokenJobRun(mysqlDB, modelTokenJobName, windowStart, windowEnd)
	if err != nil {
		if errors.Is(err, ErrModelTokenJobAlreadyProcessed) || errors.Is(err, ErrModelTokenJobAlreadyInProgress) {
			return nil
		}
		return fmt.Errorf("创建任务记录失败: %w", err)
	}

	configMap, err := loadModelConfigsToMemory(mysqlDB)
	if err != nil {
		updateErr := updateModelTokenJobRun(mysqlDB, runID, jobStatusFailed, 0, decimal.Zero, err.Error())
		if updateErr != nil {
			return fmt.Errorf("加载模型配置失败: %v; 原始错误: %w", updateErr, err)
		}
		return fmt.Errorf("加载模型配置失败: %w", err)
	}

	startDay := windowStart.Format("2006-01-02")
	startHour := windowStart.Hour()
	endDay := windowEnd.Format("2006-01-02")
	endHour := windowEnd.Hour()

	query := mysqlDB.Table("gw_token_usages").
		Select("provider, account, model, SUM(prompt_cost + completion_cost + cache_create_cost + cache_read_cost) AS total_cost").
		Where("(day > ?) OR (day = ? AND hour >= ?)", startDay, startDay, startHour).
		Where("(day < ?) OR (day = ? AND hour < ?)", endDay, endDay, endHour).
		Group("provider, account, model").
		Having("SUM(prompt_cost + completion_cost + cache_create_cost + cache_read_cost) <> 0")

	rows, err := query.Rows()
	if err != nil {
		updateErr := updateModelTokenJobRun(mysqlDB, runID, jobStatusFailed, 0, decimal.Zero, err.Error())
		if updateErr != nil {
			return fmt.Errorf("query error update failed: %v; 原始错误: %w", updateErr, err)
		}
		return fmt.Errorf("聚合Token消费失败: %w", err)
	}
	defer rows.Close()

	hasRows := false
	var (
		recordsProcessed int
		totalCostUSD     = decimal.Zero
		hadFailure       bool
		errorMessages    []string
	)

	for rows.Next() {
		hasRows = true

		var (
			provider  string
			account   sql.NullString
			model     string
			totalCost sql.NullInt64
		)

		if scanErr := rows.Scan(&provider, &account, &model, &totalCost); scanErr != nil {
			hadFailure = true
			errorMsg := fmt.Sprintf("扫描聚合结果失败: %v", scanErr)
			errorMessages = append(errorMessages, errorMsg)
			updateErr := updateModelTokenJobRun(mysqlDB, runID, jobStatusFailed, recordsProcessed, totalCostUSD, errorMsg)
			if updateErr != nil {
				return fmt.Errorf("更新任务记录失败: %v; 原始错误: %w", updateErr, scanErr)
			}
			return fmt.Errorf("扫描聚合结果失败: %w", scanErr)
		}

		if !totalCost.Valid {
			continue
		}
		costCents := totalCost.Int64
		if costCents == 0 {
			continue
		}

		provider = strings.TrimSpace(provider)
		model = strings.TrimSpace(model)
		accountStr := ""
		if account.Valid {
			accountStr = strings.TrimSpace(account.String)
		}

		costUSD := decimal.NewFromInt(costCents).Div(usdScalingFactor)
		detailStatus := jobStatusSuccess
		detailError := ""

		var (
			modelConfigID   uint64
			previousBalance decimal.Decimal
			newBalance      decimal.Decimal
		)

		configInfo, exists := configMap[makeModelConfigKey(provider, model)]
		if !exists {
			detailStatus = jobStatusFailed
			detailError = "未找到匹配的模型配置"
		} else {
			modelConfigID = configInfo.ID
		}

		priceRatio := configInfo.PriceRatio
		if priceRatio <= 0 {
			priceRatio = 1
		}
		actualCostUSD := costUSD

		if detailStatus == jobStatusSuccess {
			if priceRatio != 1 {
				actualCostUSD = costUSD.Div(decimal.NewFromFloat(priceRatio))
			}
			actualCostUSD = actualCostUSD.Round(8)
			if actualCostUSD.LessThanOrEqual(decimal.Zero) {
				detailStatus = jobStatusFailed
				detailError = "结算金额为0"
			}
		}

		if detailStatus == jobStatusSuccess {
			tx := mysqlDB.Begin()
			if tx.Error != nil {
				detailStatus = jobStatusFailed
				detailError = fmt.Sprintf("开启事务失败: %v", tx.Error)
			} else {
				remark := fmt.Sprintf(
					"自动扣费 %s - %s (原始$%s, 上浮%0.2f, 实际$%s)",
					windowStart.Format("2006-01-02 15:04"),
					windowEnd.Format("15:04"),
					costUSD.StringFixed(8),
					priceRatio,
					actualCostUSD.StringFixed(8),
				)
				previousBalance, newBalance, err = applyModelAccountBalanceChange(tx, accountStr, actualCostUSD.Neg(), remark)
				if err != nil {
					tx.Rollback()
					detailStatus = jobStatusFailed
					detailError = fmt.Sprintf("扣减余额失败: %v", err)
				} else if commitErr := tx.Commit().Error; commitErr != nil {
					detailStatus = jobStatusFailed
					detailError = fmt.Sprintf("提交事务失败: %v", commitErr)
				}
			}
		}

		if detailStatus == jobStatusSuccess {
			recordsProcessed++
			totalCostUSD = totalCostUSD.Add(actualCostUSD)
			threshold := GetLowBalanceThreshold()
			if newBalance.LessThan(threshold) {
				notifier.NotifyModelLowBalance(provider, accountStr, model, newBalance, threshold)
			}
		} else {
			hadFailure = true
			errorMessages = append(errorMessages, fmt.Sprintf("%s/%s/%s: %s", provider, accountStr, model, detailError))
		}

		detailData := map[string]interface{}{
			"run_id":           runID,
			"provider":         provider,
			"account":          accountStr,
			"model":            model,
			"total_cost_cents": costCents,
			"total_cost_usd":   actualCostUSD,
			"status":           detailStatus,
			"created_at":       time.Now(),
			"error_message":    detailError,
		}
		if modelConfigID != 0 {
			detailData["model_config_id"] = modelConfigID
		}
		if detailStatus == jobStatusSuccess {
			detailData["previous_balance"] = previousBalance
			detailData["new_balance"] = newBalance
		}

		if detailErr := mysqlDB.Table("model_token_balance_job_details").Create(detailData).Error; detailErr != nil {
			hadFailure = true
			errorMessages = append(errorMessages, fmt.Sprintf("记录明细失败 %s/%s/%s: %v", provider, accountStr, model, detailErr))
		}
	}

	if err := rows.Err(); err != nil {
		updateErr := updateModelTokenJobRun(mysqlDB, runID, jobStatusFailed, recordsProcessed, totalCostUSD, err.Error())
		if updateErr != nil {
			return fmt.Errorf("更新任务记录失败: %v; 原始错误: %w", updateErr, err)
		}
		return fmt.Errorf("遍历聚合结果失败: %w", err)
	}

	if !hasRows {
		return updateModelTokenJobRun(mysqlDB, runID, jobStatusSuccess, 0, decimal.Zero, "")
	}

	finalStatus := jobStatusSuccess
	finalError := ""
	if hadFailure {
		finalStatus = jobStatusFailed
		finalError = strings.Join(errorMessages, "; ")
		if len(finalError) > 1000 {
			finalError = finalError[:1000]
		}
	}

	if err := updateModelTokenJobRun(mysqlDB, runID, finalStatus, recordsProcessed, totalCostUSD, finalError); err != nil {
		return fmt.Errorf("更新任务记录失败: %w", err)
	}

	if hadFailure {
		return fmt.Errorf("部分模型结算失败: %s", finalError)
	}

	return nil
}

// GetMcpAccountBalanceHistory 获取账户余额历史记录
func GetMcpAccountBalanceHistory(providerID string, start, end string) ([]map[string]interface{}, error) {
	db := storage.GetPG()
	if db == nil {
		return nil, fmt.Errorf("PostgreSQL未初始化")
	}

	providerUUID, err := uuid.Parse(providerID)
	if err != nil {
		return nil, fmt.Errorf("无效的provider_id: %w", err)
	}

	q := db.Table("mcp_account_balances").
		Select(`
			mcp_account_balances.*,
			mcp_providers.provider,
			mcp_providers.account
		`).
		Joins("LEFT JOIN mcp_providers ON mcp_account_balances.provider_id = mcp_providers.id").
		Where("mcp_account_balances.provider_id = ?", providerUUID)

	if start != "" {
		q = q.Where("mcp_account_balances.created_at >= ?", start)
	}
	if end != "" {
		q = q.Where("mcp_account_balances.created_at <= ?", end)
	}

	rows, err := q.Order("mcp_account_balances.created_at DESC").Rows()
	if err != nil {
		return nil, fmt.Errorf("查询余额历史失败: %w", err)
	}
	defer rows.Close()

	cols, _ := rows.Columns()
	list := make([]map[string]interface{}, 0)
	floatCols := []string{"balance"}
	timeCols := []string{"created_at"}

	for rows.Next() {
		vals := make([]interface{}, len(cols))
		valPtrs := make([]interface{}, len(cols))
		for i := range vals {
			valPtrs[i] = &vals[i]
		}
		if err := rows.Scan(valPtrs...); err != nil {
			return nil, err
		}

		m := map[string]interface{}{}
		isFloat := map[string]struct{}{}
		for _, k := range floatCols {
			isFloat[k] = struct{}{}
		}
		isTime := map[string]struct{}{}
		for _, k := range timeCols {
			isTime[k] = struct{}{}
		}

		for i, c := range cols {
			if _, ok := isFloat[c]; ok {
				if f, ok2 := toFloat(vals[i]); ok2 {
					m[c] = f
				} else {
					m[c] = nil
				}
				continue
			}
			if _, ok := isTime[c]; ok {
				if iso, ok2 := toTimeISO(vals[i]); ok2 {
					m[c] = iso
				} else {
					m[c] = toString(vals[i])
				}
				continue
			}
			m[c] = toString(vals[i])
		}
		list = append(list, m)
	}

	return list, nil
}

// ========== 模型账号充值记录和余额管理 ==========

// applyModelAccountBalanceChange 应用模型账号余额变更（追加式记录）
func applyModelAccountBalanceChange(tx *gorm.DB, account string, delta decimal.Decimal, remark string) (decimal.Decimal, decimal.Decimal, error) {
	var latest struct {
		Balance decimal.Decimal `gorm:"column:balance"`
	}
	prev := decimal.Zero

	err := tx.Table("gw_model_account_balances").
		Select("balance").
		Where("account = ?", account).
		Order("created_at DESC").
		Take(&latest).Error

	if err != nil {
		if !errors.Is(err, gorm.ErrRecordNotFound) {
			return decimal.Zero, decimal.Zero, err
		}
	} else {
		prev = latest.Balance
	}

	newBalance := prev.Add(delta)

	record := map[string]interface{}{
		"account":    account,
		"balance":    newBalance,
		"currency":   "USD",
		"remark":     remark,
		"created_at": time.Now(),
	}

	if err := tx.Table("gw_model_account_balances").Create(record).Error; err != nil {
		return decimal.Zero, decimal.Zero, err
	}

	return prev, newBalance, nil
}

// ListModelAccountRechargeRecords 查询模型账号充值记录
func ListModelAccountRechargeRecords(offset, limit int, provider, modelName, start, end string) (*PageResult, error) {
	db := storage.DB
	if db == nil {
		return nil, fmt.Errorf("MySQL未初始化")
	}

	var total int64
	q := db.Table("gw_model_account_recharge_records r").
		Select(`
			r.*,
			gp.name AS provider
		`).
		Joins("LEFT JOIN gw_providers gp ON r.account = gp.account").
		Where("r.deleted_at IS NULL")

	if provider != "" {
		q = q.Where("gp.name LIKE ?", "%"+provider+"%")
	}
	if start != "" {
		q = q.Where("r.recharge_date >= ?", start)
	}
	if end != "" {
		q = q.Where("r.recharge_date <= ?", end)
	}

	if err := q.Count(&total).Error; err != nil {
		return nil, fmt.Errorf("count model account recharge records: %w", err)
	}

	rows, err := q.Order("r.created_at DESC").
		Offset(offset).Limit(limit).Rows()
	if err != nil {
		return nil, fmt.Errorf("query model account recharge records: %w", err)
	}
	defer rows.Close()

	cols, _ := rows.Columns()
	list := make([]map[string]interface{}, 0)
	intCols := []string{"id", "operator_id"}
	floatCols := []string{"amount"}
	timeCols := []string{"created_at", "updated_at"}

	for rows.Next() {
		vals := make([]interface{}, len(cols))
		valPtrs := make([]interface{}, len(cols))
		for i := range vals {
			valPtrs[i] = &vals[i]
		}
		if err := rows.Scan(valPtrs...); err != nil {
			return nil, err
		}

		// 需要处理float类型
		m := normalizeGenericInts(cols, vals, intCols, timeCols)
		// 手动处理float字段
		for i, c := range cols {
			for _, fc := range floatCols {
				if c == fc {
					if f, ok := toFloat(vals[i]); ok {
						m[c] = f
					}
					break
				}
			}
		}
		list = append(list, m)
	}

	return &PageResult{List: list, Total: total}, nil
}

// CreateModelAccountRechargeRecord 创建模型账号充值记录
func CreateModelAccountRechargeRecord(account string, amount float64, rechargeDate string, operatorID interface{}, operatorName, remark string) error {
	db := storage.DB
	if db == nil {
		return fmt.Errorf("MySQL未初始化")
	}

	account = strings.TrimSpace(account)
	if account == "" {
		return fmt.Errorf("账号不能为空")
	}

	// 验证账号是否存在
	var count int64
	if err := db.Table("gw_providers").Where("account = ?", account).Count(&count).Error; err != nil {
		return fmt.Errorf("验证账号失败: %w", err)
	}
	if count == 0 {
		return fmt.Errorf("账号不存在: %s", account)
	}

	// 解析日期
	date, err := time.Parse("2006-01-02", rechargeDate)
	if err != nil {
		return fmt.Errorf("无效的日期格式: %w", err)
	}

	// 处理operator_id
	var operatorIDUint *uint64
	if operatorID != nil {
		var opID uint64
		switch v := operatorID.(type) {
		case string:
			parsed, err := strconv.ParseUint(v, 10, 64)
			if err != nil {
				operatorIDUint = nil
			} else {
				opID = parsed
				operatorIDUint = &opID
			}
		case uint64:
			operatorIDUint = &v
		case int64:
			u := uint64(v)
			operatorIDUint = &u
		case int:
			u := uint64(v)
			operatorIDUint = &u
		default:
			operatorIDUint = nil
		}
	}

	// 开始事务
	tx := db.Begin()
	if tx.Error != nil {
		return fmt.Errorf("开始事务失败: %w", tx.Error)
	}
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()

	// 1. 创建充值记录
	now := time.Now()
	record := map[string]interface{}{
		"account":       account,
		"amount":        amount,
		"currency":      "USD",
		"recharge_date": date,
		"operator_id":   operatorIDUint,
		"operator_name": operatorName,
		"remark":        remark,
		"created_at":    now,
		"updated_at":    now,
	}

	if err := tx.Table("gw_model_account_recharge_records").Create(record).Error; err != nil {
		tx.Rollback()
		return fmt.Errorf("创建充值记录失败: %w", err)
	}

	amountDecimal := decimal.NewFromFloat(amount).Round(8)
	remarkText := fmt.Sprintf("手动充值 $%s by %s", amountDecimal.StringFixed(2), operatorName)

	_, _, err = applyModelAccountBalanceChange(tx, account, amountDecimal, remarkText)
	if err != nil {
		tx.Rollback()
		return fmt.Errorf("创建余额记录失败: %w", err)
	}

	// 提交事务
	if err := tx.Commit().Error; err != nil {
		return fmt.Errorf("提交事务失败: %w", err)
	}

	return nil
}

// UpdateModelAccountRechargeRecord 更新模型账号充值记录
func UpdateModelAccountRechargeRecord(id string, amount *float64, rechargeDate *string, remark *string) error {
	db := storage.DB
	if db == nil {
		return fmt.Errorf("MySQL未初始化")
	}

	recordID, err := strconv.ParseUint(id, 10, 64)
	if err != nil {
		return fmt.Errorf("无效的记录ID: %w", err)
	}

	updates := map[string]interface{}{}
	if amount != nil {
		updates["amount"] = *amount
	}
	if rechargeDate != nil {
		date, err := time.Parse("2006-01-02", *rechargeDate)
		if err != nil {
			return fmt.Errorf("无效的日期格式: %w", err)
		}
		updates["recharge_date"] = date
	}
	if remark != nil {
		updates["remark"] = *remark
	}

	if len(updates) == 0 {
		return fmt.Errorf("没有需要更新的字段")
	}

	updates["updated_at"] = time.Now()

	return db.Table("gw_model_account_recharge_records").
		Where("id = ? AND deleted_at IS NULL", recordID).
		Updates(updates).Error
}

// DeleteModelAccountRechargeRecord 删除模型账号充值记录（软删除）
func DeleteModelAccountRechargeRecord(id string) error {
	db := storage.DB
	if db == nil {
		return fmt.Errorf("MySQL未初始化")
	}

	recordID, err := strconv.ParseUint(id, 10, 64)
	if err != nil {
		return fmt.Errorf("无效的记录ID: %w", err)
	}

	return db.Table("gw_model_account_recharge_records").
		Where("id = ?", recordID).
		Update("deleted_at", time.Now()).Error
}

// GetModelConfigAccounts 获取模型配置列表（用于下拉选择）
func GetModelConfigAccounts(enabled *bool) ([]map[string]interface{}, error) {
	db := storage.DB
	if db == nil {
		return nil, fmt.Errorf("MySQL未初始化")
	}

	q := db.Table("gw_providers").
		Select("name, api_type, account, status, priority").
		Where("deleted_at IS NULL")

	if enabled != nil {
		if *enabled {
			q = q.Where("status = ?", "active")
		} else {
			q = q.Where("status <> ?", "active")
		}
	}

	var accounts []map[string]interface{}
	rows, err := q.Order("name, account").Rows()
	if err != nil {
		return nil, fmt.Errorf("query model accounts: %w", err)
	}
	defer rows.Close()

	cols, _ := rows.Columns()
	for rows.Next() {
		vals := make([]interface{}, len(cols))
		valPtrs := make([]interface{}, len(cols))
		for i := range vals {
			valPtrs[i] = &vals[i]
		}
		if err := rows.Scan(valPtrs...); err != nil {
			return nil, err
		}

		m := make(map[string]interface{})
		for i, c := range cols {
			switch strings.ToLower(c) {
			case "priority":
				if val, ok := toInt(vals[i]); ok {
					m[c] = val
				} else {
					m[c] = nil
				}
			default:
				m[c] = toString(vals[i])
			}
		}
		accounts = append(accounts, m)
	}

	return accounts, nil
}

// GetModelAccountLatestBalance 获取模型账号最新余额
func GetModelAccountLatestBalance(account string) (map[string]interface{}, error) {
	db := storage.DB
	if db == nil {
		return nil, fmt.Errorf("MySQL未初始化")
	}

	account = strings.TrimSpace(account)
	if account == "" {
		return nil, fmt.Errorf("账号不能为空")
	}

	var balance map[string]interface{}
	err := db.Table("gw_model_account_balances b").
		Select(`
			b.*,
			gp.name AS provider,
			gp.api_type
		`).
		Joins("LEFT JOIN gw_providers gp ON b.account = gp.account").
		Where("b.account = ?", account).
		Order("b.created_at DESC").
		Limit(1).
		Find(&balance).Error

	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return map[string]interface{}{}, nil
		}
		return nil, err
	}

	// 处理数据类型
	result := make(map[string]interface{})
	for k, v := range balance {
		if k == "balance" {
			if f, ok := toFloat(v); ok {
				result[k] = f
			} else {
				result[k] = v
			}
		} else if k == "created_at" {
			if iso, ok := toTimeISO(v); ok {
				result[k] = iso
			} else {
				result[k] = toString(v)
			}
		} else {
			result[k] = toString(v)
		}
	}

	return result, nil
}

// GetModelAccountBalances 获取所有模型账号最新余额列表
func GetModelAccountBalances() ([]map[string]interface{}, error) {
	db := storage.DB
	if db == nil {
		return nil, fmt.Errorf("MySQL未初始化")
	}

	// 先获取每个账号最新的创建时间
	var latestRecords []struct {
		Account    string
		MaxCreated time.Time
	}

	err := db.Table("gw_model_account_balances").
		Select("account, MAX(created_at) as max_created").
		Group("account").
		Find(&latestRecords).Error

	if err != nil {
		return nil, fmt.Errorf("查询余额失败: %w", err)
	}

	// 为每个账号获取最新余额
	balances := make([]map[string]interface{}, 0)
	for _, lr := range latestRecords {
		var balance map[string]interface{}
		err = db.Table("gw_model_account_balances b").
			Select(`
				b.*,
				gp.name AS provider,
				gp.api_type
			`).
			Joins("LEFT JOIN gw_providers gp ON b.account = gp.account").
			Where("b.account = ? AND b.created_at = ?", lr.Account, lr.MaxCreated).
			Limit(1).
			Find(&balance).Error

		if err == nil && len(balance) > 0 {
			balances = append(balances, balance)
		}
	}

	// 处理数据类型
	result := make([]map[string]interface{}, 0)
	for _, bal := range balances {
		m := make(map[string]interface{})
		for k, v := range bal {
			if k == "balance" {
				if f, ok := toFloat(v); ok {
					m[k] = f
				} else {
					m[k] = v
				}
			} else if k == "created_at" {
				if iso, ok := toTimeISO(v); ok {
					m[k] = iso
				} else {
					m[k] = toString(v)
				}
			} else {
				m[k] = toString(v)
			}
		}
		result = append(result, m)
	}

	return result, nil
}

// GetModelAccountBalanceHistory 获取模型账号余额历史
func GetModelAccountBalanceHistory(account string, start, end string) ([]map[string]interface{}, error) {
	db := storage.DB
	if db == nil {
		return nil, fmt.Errorf("MySQL未初始化")
	}

	q := db.Table("gw_model_account_balances").
		Where("account = ?", account)

	if start != "" {
		q = q.Where("created_at >= ?", start)
	}
	if end != "" {
		q = q.Where("created_at <= ?", end)
	}

	rows, err := q.Order("created_at DESC").Rows()
	if err != nil {
		return nil, fmt.Errorf("query balance history: %w", err)
	}
	defer rows.Close()

	cols, _ := rows.Columns()
	list := make([]map[string]interface{}, 0)
	intCols := []string{"id"}
	floatCols := []string{"balance"}
	timeCols := []string{"created_at"}

	for rows.Next() {
		vals := make([]interface{}, len(cols))
		valPtrs := make([]interface{}, len(cols))
		for i := range vals {
			valPtrs[i] = &vals[i]
		}
		if err := rows.Scan(valPtrs...); err != nil {
			return nil, err
		}

		m := normalizeGenericInts(cols, vals, intCols, timeCols)
		// 手动处理float字段
		for i, c := range cols {
			for _, fc := range floatCols {
				if c == fc {
					if f, ok := toFloat(vals[i]); ok {
						m[c] = f
					}
					break
				}
			}
		}
		list = append(list, m)
	}

	return list, nil
}